happy-stacks 0.3.0 → 0.5.0

package/scripts/utils/proc/pm.mjs

@@ -1,7 +1,7 @@
 import { homedir } from 'node:os';
 import { dirname, join, resolve, sep } from 'node:path';
 import { existsSync } from 'node:fs';
-import { chmod, mkdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
+import { chmod, mkdir, readFile, readdir, rename, rm, stat, writeFile } from 'node:fs/promises';
 import { createHash } from 'node:crypto';
 
 import { pathExists } from '../fs/fs.mjs';
@@ -50,12 +50,12 @@ export async function requirePnpm() {
   );
 }
 
-async function getComponentPm(dir) {
+async function getComponentPm(dir, env = process.env) {
   const yarnLock = join(dir, 'yarn.lock');
   if (await pathExists(yarnLock)) {
     // IMPORTANT: when happy-stacks itself is pinned to pnpm via Corepack, running `yarn`
     // from the happy-stacks cwd can be blocked. Always probe yarn with cwd=componentDir.
-    if (!(await commandExists('yarn', { cwd: dir }))) {
+    if (!(await commandExists('yarn', { cwd: dir, env }))) {
       throw new Error(`[local] yarn is required for component at ${dir} (yarn.lock present). Install it via Corepack: \`corepack enable\``);
     }
     return { name: 'yarn', cmd: 'yarn' };
@@ -66,6 +66,23 @@ async function getComponentPm(dir) {
   return { name: 'pnpm', cmd: 'pnpm' };
 }
 
+const _yarnReadyKeys = new Set();
+
+async function ensureYarnReady({ dir, env, quiet = false }) {
+  const e = env && typeof env === 'object' ? env : process.env;
+  // In stack mode we isolate HOME/cache; key by effective HOME+XDG cache so we only do this once.
+  const key = `${resolve(dir)}|${String(e.HOME ?? '')}|${String(e.XDG_CACHE_HOME ?? '')}`;
+  if (_yarnReadyKeys.has(key)) return;
+
+  // If stdin isn't a TTY (e.g. `happys tui ...` uses stdio:ignore for child stdin),
+  // Corepack prompts can deadlock. Provide a single "yes" to unblock initial downloads.
+  const isTui = (e.HAPPY_STACKS_TUI ?? e.HAPPY_LOCAL_TUI ?? '').toString().trim() === '1';
+  const autoYes = isTui || !process.stdin.isTTY;
+  const stdio = quiet ? 'ignore' : 'inherit';
+  await run('yarn', ['--version'], { cwd: dir, env: e, stdio, ...(autoYes ? { input: 'y\n' } : {}) });
+  _yarnReadyKeys.add(key);
+}
+
 export async function requireDir(label, dir) {
   if (await pathExists(dir)) {
     return;
@@ -76,7 +93,71 @@ export async function requireDir(label, dir) {
   );
 }
 
-export async function ensureDepsInstalled(dir, label, { quiet = false } = {}) {
+function resolveStackCacheBaseDirFromEnv(env) {
+  const envFile = (env.HAPPY_STACKS_ENV_FILE ?? env.HAPPY_LOCAL_ENV_FILE ?? '').toString().trim();
+  if (!envFile) return null;
+  try {
+    return join(dirname(envFile), 'cache');
+  } catch {
+    return null;
+  }
+}
+
+async function applyStackCacheEnv(baseEnv) {
+  const env = { ...(baseEnv && typeof baseEnv === 'object' ? baseEnv : process.env) };
+  const envFile = (env.HAPPY_STACKS_ENV_FILE ?? env.HAPPY_LOCAL_ENV_FILE ?? '').toString().trim();
+  const stackCacheBase = resolveStackCacheBaseDirFromEnv(env);
+  if (!stackCacheBase) return env;
+
+  // Prisma engines currently default to ~/.cache/prisma (via os.homedir()).
+  // In stack mode, isolate HOME for package-manager driven commands so Prisma/Yarn/NPM don't
+  // depend on global home caches (and so sandboxed runs can succeed).
+  const isolateHomeRaw = (env.HAPPY_STACKS_PM_ISOLATE_HOME ?? env.HAPPY_LOCAL_PM_ISOLATE_HOME ?? '').toString().trim();
+  const isolateHome = isolateHomeRaw ? isolateHomeRaw !== '0' : true;
+  if (isolateHome && envFile) {
+    const stackHome = join(dirname(envFile), 'home');
+    env.HOME = stackHome;
+    env.USERPROFILE = stackHome;
+    try {
+      await mkdir(stackHome, { recursive: true });
+    } catch {
+      // best-effort
+    }
+  }
+
+  if (!(env.XDG_CACHE_HOME ?? '').toString().trim()) {
+    env.XDG_CACHE_HOME = join(stackCacheBase, 'xdg');
+  }
+  if (!(env.YARN_CACHE_FOLDER ?? '').toString().trim()) {
+    env.YARN_CACHE_FOLDER = join(stackCacheBase, 'yarn');
+  }
+  if (!(env.npm_config_cache ?? '').toString().trim()) {
+    env.npm_config_cache = join(stackCacheBase, 'npm');
+  }
+  // Corepack caches downloaded package managers (like Yarn) under COREPACK_HOME.
+  // In stack mode we want this to be stable and writable so first-run downloads don't prompt/hang in TUI.
+  if (!(env.COREPACK_HOME ?? '').toString().trim()) {
+    env.COREPACK_HOME = join(stackCacheBase, 'corepack');
+  }
+  // Avoid Corepack mutating package.json by auto-adding a packageManager field.
+  // (This is safe and reduces noise when Corepack is used implicitly.)
+  if (!(env.COREPACK_ENABLE_AUTO_PIN ?? '').toString().trim()) {
+    env.COREPACK_ENABLE_AUTO_PIN = '0';
+  }
+
+  try {
+    await mkdir(env.XDG_CACHE_HOME, { recursive: true });
+    await mkdir(env.YARN_CACHE_FOLDER, { recursive: true });
+    await mkdir(env.npm_config_cache, { recursive: true });
+    await mkdir(env.COREPACK_HOME, { recursive: true });
+  } catch {
+    // best-effort
+  }
+
+  return env;
+}
+
+export async function ensureDepsInstalled(dir, label, { quiet = false, env: envIn = process.env } = {}) {
   const pkgJson = join(dir, 'package.json');
   if (!(await pathExists(pkgJson))) {
     return;
@@ -84,8 +165,12 @@ export async function ensureDepsInstalled(dir, label, { quiet = false } = {}) {
 
   const nodeModules = join(dir, 'node_modules');
   const pnpmModulesMeta = join(dir, 'node_modules', '.modules.yaml');
-  const pm = await getComponentPm(dir);
   const stdio = quiet ? 'ignore' : 'inherit';
+  const env = await applyStackCacheEnv(envIn);
+  const pm = await getComponentPm(dir, env);
+  if (pm.name === 'yarn') {
+    await ensureYarnReady({ dir, env, quiet });
+  }
 
   if (await pathExists(nodeModules)) {
     const yarnLock = join(dir, 'yarn.lock');
@@ -100,7 +185,7 @@ export async function ensureDepsInstalled(dir, label, { quiet = false } = {}) {
         console.log(`[local] converting ${label} dependencies back to yarn (reinstalling node_modules)...`);
       }
       await rm(nodeModules, { recursive: true, force: true });
-      await run(pm.cmd, ['install'], { cwd: dir, stdio });
+      await run(pm.cmd, ['install'], { cwd: dir, stdio, env });
     }
 
     // If dependencies changed since the last install, re-run install even if node_modules exists.
@@ -113,16 +198,39 @@ export async function ensureDepsInstalled(dir, label, { quiet = false } = {}) {
       }
     };
 
+    const patchesMtimeMs = async () => {
+      // Happy's mobile app (and some other repos) use patch-package and keep patches under `patches/`.
+      // If a patch file changes but yarn.lock/package.json do not, Yarn won't reinstall and
+      // patch-package won't re-apply the patch, leading to confusing "why isn't my patch wired?"
+      // failures later (e.g. during iOS pod install).
+      const patchesDir = join(dir, 'patches');
+      if (!(await pathExists(patchesDir))) return 0;
+      try {
+        const entries = await readdir(patchesDir, { withFileTypes: true });
+        let max = 0;
+        for (const e of entries) {
+          if (!e.isFile()) continue;
+          if (!e.name.endsWith('.patch')) continue;
+          const m = await mtimeMs(join(patchesDir, e.name));
+          if (m > max) max = m;
+        }
+        return max;
+      } catch {
+        return 0;
+      }
+    };
+
     if (pm.name === 'yarn' && (await pathExists(yarnLock))) {
       const lockM = await mtimeMs(yarnLock);
       const pkgM = await mtimeMs(pkgJson);
       const intM = await mtimeMs(yarnIntegrity);
-      if (!intM || lockM > intM || pkgM > intM) {
+      const patchM = await patchesMtimeMs();
+      if (!intM || lockM > intM || pkgM > intM || patchM > intM) {
         if (!quiet) {
           // eslint-disable-next-line no-console
-          console.log(`[local] refreshing ${label} dependencies (yarn.lock/package.json changed)...`);
+          console.log(`[local] refreshing ${label} dependencies (yarn.lock/package.json/patches changed)...`);
         }
-        await run(pm.cmd, ['install'], { cwd: dir, stdio });
+        await run(pm.cmd, ['install'], { cwd: dir, stdio, env });
       }
     }
 
@@ -134,7 +242,7 @@ export async function ensureDepsInstalled(dir, label, { quiet = false } = {}) {
           // eslint-disable-next-line no-console
           console.log(`[local] refreshing ${label} dependencies (pnpm-lock changed)...`);
         }
-        await run(pm.cmd, ['install'], { cwd: dir, stdio });
+        await run(pm.cmd, ['install'], { cwd: dir, stdio, env });
       }
     }
 
@@ -145,7 +253,7 @@ export async function ensureDepsInstalled(dir, label, { quiet = false } = {}) {
     // eslint-disable-next-line no-console
     console.log(`[local] installing ${label} dependencies (first run)...`);
   }
-  await run(pm.cmd, ['install'], { cwd: dir, stdio });
+  await run(pm.cmd, ['install'], { cwd: dir, stdio, env });
 }
 
 export async function ensureCliBuilt(cliDir, { buildCli }) {
@@ -161,14 +269,20 @@ export async function ensureCliBuilt(cliDir, { buildCli }) {
   // - HAPPY_STACKS_CLI_BUILD=0 (legacy: HAPPY_LOCAL_CLI_BUILD=0)
   const modeRaw = (process.env.HAPPY_STACKS_CLI_BUILD_MODE ?? process.env.HAPPY_LOCAL_CLI_BUILD_MODE ?? 'auto').trim().toLowerCase();
   const mode = modeRaw === 'always' || modeRaw === 'auto' || modeRaw === 'never' ? modeRaw : 'auto';
-  if (mode === 'never') {
-    return { built: false, reason: 'mode_never' };
-  }
   const distEntrypoint = join(cliDir, 'dist', 'index.mjs');
   const buildStatePath = resolveBuildStatePath({ label: 'happy-cli', dir: cliDir });
   const gitSig = await computeGitWorktreeSignature(cliDir);
   const prev = await readJsonIfExists(buildStatePath);
 
+  // "never" should prevent rebuild churn, but it must not make the stack unrunnable.
+  // If the dist entrypoint is missing, build once even in "never" mode.
+  if (mode === 'never') {
+    if (await pathExists(distEntrypoint)) {
+      return { built: false, reason: 'mode_never' };
+    }
+    // fallthrough to build
+  }
+
   if (mode === 'auto') {
     // If dist doesn't exist, we must build.
     if (!(await pathExists(distEntrypoint))) {
@@ -186,6 +300,18 @@ export async function ensureCliBuilt(cliDir, { buildCli }) {
   const pm = await getComponentPm(cliDir);
   await run(pm.cmd, ['build'], { cwd: cliDir });
 
+  // Sanity check: happy-cli daemon entrypoint must exist after a successful build.
+  // Without this, watch-based rebuilds can restart the daemon into a MODULE_NOT_FOUND crash,
+  // which looks like the UI "dies out of nowhere" even though the root cause is missing build output.
+  if (!(await pathExists(distEntrypoint))) {
+    throw new Error(
+      `[local] happy-cli build finished but did not produce expected entrypoint.\n` +
+        `Expected: ${distEntrypoint}\n` +
+        `Fix: run the component build directly and inspect its output:\n` +
+        `  cd "${cliDir}" && ${pm.cmd} build`
+    );
+  }
+
   // Persist new build state (best-effort).
   const nowSig = gitSig ?? (await computeGitWorktreeSignature(cliDir));
   if (nowSig) {
@@ -288,11 +414,15 @@ export async function pmExecBin(dirOrOpts, binArg, argsArg, optsArg) {
   const bin = usesObjectStyle ? dirOrOpts.bin : binArg;
   const args = usesObjectStyle ? (dirOrOpts.args ?? []) : (argsArg ?? []);
 
-  const env = usesObjectStyle ? (dirOrOpts.env ?? process.env) : (optsArg?.env ?? process.env);
+  const envIn = usesObjectStyle ? (dirOrOpts.env ?? process.env) : (optsArg?.env ?? process.env);
+  const env = await applyStackCacheEnv(envIn);
   const quiet = usesObjectStyle ? Boolean(dirOrOpts.quiet) : Boolean(optsArg?.quiet);
   const stdio = quiet ? 'ignore' : 'inherit';
 
-  const pm = await getComponentPm(dir);
+  const pm = await getComponentPm(dir, env);
+  if (pm.name === 'yarn') {
+    await ensureYarnReady({ dir, env, quiet });
+  }
   if (pm.name === 'yarn') {
     await run(pm.cmd, ['run', bin, ...args], { cwd: dir, env, stdio });
     return;
@@ -301,17 +431,41 @@ export async function pmExecBin(dirOrOpts, binArg, argsArg, optsArg) {
 }
 
 export async function pmSpawnBin(dir, label, bin, args, { env = process.env } = {}) {
-  const pm = await getComponentPm(dir);
+  const usesObjectStyle = typeof dir === 'object' && dir !== null;
+  const componentDir = usesObjectStyle ? dir.dir : dir;
+  const componentLabel = usesObjectStyle ? dir.label : label;
+  const componentBin = usesObjectStyle ? dir.bin : bin;
+  const componentArgs = usesObjectStyle ? (dir.args ?? []) : (args ?? []);
+  const componentEnv = usesObjectStyle ? (dir.env ?? process.env) : (env ?? process.env);
+  const options = usesObjectStyle ? (dir.options ?? {}) : {};
+
+  const effectiveEnv = await applyStackCacheEnv(componentEnv);
+  const pm = await getComponentPm(componentDir, effectiveEnv);
+  if (pm.name === 'yarn') {
+    await ensureYarnReady({ dir: componentDir, env: effectiveEnv, quiet: false });
+  }
   if (pm.name === 'yarn') {
-    return spawnProc(label, pm.cmd, ['run', bin, ...args], env, { cwd: dir });
+    return spawnProc(componentLabel, pm.cmd, ['run', componentBin, ...componentArgs], effectiveEnv, { cwd: componentDir, ...options });
   }
-  return spawnProc(label, pm.cmd, ['exec', bin, ...args], env, { cwd: dir });
+  return spawnProc(componentLabel, pm.cmd, ['exec', componentBin, ...componentArgs], effectiveEnv, { cwd: componentDir, ...options });
 }
 
 export async function pmSpawnScript(dir, label, script, args, { env = process.env } = {}) {
-  const pm = await getComponentPm(dir);
+  const usesObjectStyle = typeof dir === 'object' && dir !== null;
+  const componentDir = usesObjectStyle ? dir.dir : dir;
+  const componentLabel = usesObjectStyle ? dir.label : label;
+  const componentScript = usesObjectStyle ? dir.script : script;
+  const componentArgs = usesObjectStyle ? (dir.args ?? []) : (args ?? []);
+  const componentEnv = usesObjectStyle ? (dir.env ?? process.env) : (env ?? process.env);
+  const options = usesObjectStyle ? (dir.options ?? {}) : {};
+
+  const effectiveEnv = await applyStackCacheEnv(componentEnv);
+  const pm = await getComponentPm(componentDir, effectiveEnv);
+  if (pm.name === 'yarn') {
+    await ensureYarnReady({ dir: componentDir, env: effectiveEnv, quiet: false });
+  }
   if (pm.name === 'yarn') {
-    return spawnProc(label, pm.cmd, ['run', script, ...args], env, { cwd: dir });
+    return spawnProc(componentLabel, pm.cmd, ['run', componentScript, ...componentArgs], effectiveEnv, { cwd: componentDir, ...options });
   }
-  return spawnProc(label, pm.cmd, ['run', script, ...args], env, { cwd: dir });
+  return spawnProc(componentLabel, pm.cmd, ['run', componentScript, ...componentArgs], effectiveEnv, { cwd: componentDir, ...options });
 }

package/scripts/utils/proc/pm_spawn.test.mjs

@@ -0,0 +1,76 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { chmod, mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { pmSpawnBin, pmSpawnScript } from './pm.mjs';
+
+async function writeJson(path, obj) {
+  await writeFile(path, JSON.stringify(obj, null, 2) + '\n', 'utf-8');
+}
+
+async function waitExit(child) {
+  return await new Promise((resolve) => {
+    child.on('exit', (code, signal) => resolve({ code, signal }));
+  });
+}
+
+async function writeStubYarn({ binDir }) {
+  await mkdir(binDir, { recursive: true });
+  const yarnPath = join(binDir, 'yarn');
+  await writeFile(
+    yarnPath,
+    [
+      '#!/usr/bin/env node',
+      'const args = process.argv.slice(2);',
+      // ensureYarnReady calls: yarn --version
+      "if (args.includes('--version')) { console.log('1.22.22'); process.exit(0); }",
+      // pmSpawn* calls: yarn run <script/bin> ...
+      'if (args[0] === "run") process.exit(0);',
+      'process.exit(0);',
+    ].join('\n') + '\n',
+    'utf-8'
+  );
+  await chmod(yarnPath, 0o755);
+}
+
+test('pmSpawnScript does not reference effectiveEnv before initialization', async (t) => {
+  const root = await mkdtemp(join(tmpdir(), 'hs-pm-spawn-script-'));
+  t.after(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  const componentDir = join(root, 'component');
+  await mkdir(componentDir, { recursive: true });
+  await writeJson(join(componentDir, 'package.json'), { name: 'component', version: '0.0.0' });
+  await writeFile(join(componentDir, 'yarn.lock'), '# yarn\n', 'utf-8');
+
+  const binDir = join(root, 'bin');
+  await writeStubYarn({ binDir });
+
+  const env = { ...process.env, PATH: `${binDir}:${process.env.PATH ?? ''}` };
+  const child = await pmSpawnScript(componentDir, 'spawn-test', 'noop', [], { env });
+  const res = await waitExit(child);
+  assert.equal(res.code, 0);
+});
+
+test('pmSpawnBin does not reference effectiveEnv before initialization', async (t) => {
+  const root = await mkdtemp(join(tmpdir(), 'hs-pm-spawn-bin-'));
+  t.after(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  const componentDir = join(root, 'component');
+  await mkdir(componentDir, { recursive: true });
+  await writeJson(join(componentDir, 'package.json'), { name: 'component', version: '0.0.0' });
+  await writeFile(join(componentDir, 'yarn.lock'), '# yarn\n', 'utf-8');
+
+  const binDir = join(root, 'bin');
+  await writeStubYarn({ binDir });
+
+  const env = { ...process.env, PATH: `${binDir}:${process.env.PATH ?? ''}` };
+  const child = await pmSpawnBin(componentDir, 'spawn-test', 'prisma', ['generate'], { env });
+  const res = await waitExit(child);
+  assert.equal(res.code, 0);
+});

package/scripts/utils/proc/pm_stack_cache_env.test.mjs

@@ -0,0 +1,142 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { chmod, mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+
+import { ensureDepsInstalled, pmExecBin } from './pm.mjs';
+
+async function writeYarnEnvDumpStub({ binDir, outputPath }) {
+  await mkdir(binDir, { recursive: true });
+  const yarnPath = join(binDir, 'yarn');
+  await writeFile(
+    yarnPath,
+    [
+      '#!/usr/bin/env node',
+      "const { writeFileSync } = require('node:fs');",
+      "const out = {",
+      '  XDG_CACHE_HOME: process.env.XDG_CACHE_HOME ?? null,',
+      '  YARN_CACHE_FOLDER: process.env.YARN_CACHE_FOLDER ?? null,',
+      '  npm_config_cache: process.env.npm_config_cache ?? null,',
+      '};',
+      "writeFileSync(process.env.OUTPUT_PATH, JSON.stringify(out, null, 2) + '\\n');",
+      'process.exit(0);',
+    ].join('\n') + '\n',
+    'utf-8'
+  );
+  await chmod(yarnPath, 0o755);
+  await writeFile(outputPath, '', 'utf-8');
+}
+
+function expectedCacheEnv({ envPath }) {
+  const base = join(dirname(envPath), 'cache');
+  return {
+    xdg: join(base, 'xdg'),
+    yarn: join(base, 'yarn'),
+    npm: join(base, 'npm'),
+  };
+}
+
+async function withEnv(vars, fn) {
+  const old = {};
+  for (const k of Object.keys(vars)) old[k] = process.env[k];
+  try {
+    for (const [k, v] of Object.entries(vars)) {
+      if (v == null) delete process.env[k];
+      else process.env[k] = String(v);
+    }
+    return await fn();
+  } finally {
+    for (const [k, v] of Object.entries(old)) {
+      if (v == null) delete process.env[k];
+      else process.env[k] = v;
+    }
+  }
+}
+
+test('ensureDepsInstalled sets stack-scoped cache env vars for yarn installs', async (t) => {
+  const root = await mkdtemp(join(tmpdir(), 'hs-pm-stack-cache-install-'));
+  t.after(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  const stackDir = join(root, 'stacks', 'exp1');
+  const envPath = join(stackDir, 'env');
+  await mkdir(dirname(envPath), { recursive: true });
+  await writeFile(envPath, 'HAPPY_STACKS_STACK=exp1\n', 'utf-8');
+
+  const componentDir = join(root, 'component');
+  await mkdir(componentDir, { recursive: true });
+  await writeFile(join(componentDir, 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(componentDir, 'yarn.lock'), '# yarn\n', 'utf-8');
+
+  const binDir = join(root, 'bin');
+  const outputPath = join(root, 'env.json');
+  await writeYarnEnvDumpStub({ binDir, outputPath });
+
+  const exp = expectedCacheEnv({ envPath });
+  const oldPath = process.env.PATH;
+
+  await withEnv(
+    {
+      PATH: `${binDir}:${oldPath ?? ''}`,
+      OUTPUT_PATH: outputPath,
+      HAPPY_STACKS_ENV_FILE: envPath,
+      HAPPY_LOCAL_ENV_FILE: envPath,
+      XDG_CACHE_HOME: null,
+      YARN_CACHE_FOLDER: null,
+      npm_config_cache: null,
+    },
+    async () => {
+      await ensureDepsInstalled(componentDir, 'test-component', { quiet: true });
+      const parsed = JSON.parse(await readFile(outputPath, 'utf-8'));
+      assert.equal(parsed.XDG_CACHE_HOME, exp.xdg);
+      assert.equal(parsed.YARN_CACHE_FOLDER, exp.yarn);
+      assert.equal(parsed.npm_config_cache, exp.npm);
+    }
+  );
+});
+
+test('pmExecBin sets stack-scoped cache env vars for yarn runs', async (t) => {
+  const root = await mkdtemp(join(tmpdir(), 'hs-pm-stack-cache-exec-'));
+  t.after(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  const stackDir = join(root, 'stacks', 'exp1');
+  const envPath = join(stackDir, 'env');
+  await mkdir(dirname(envPath), { recursive: true });
+  await writeFile(envPath, 'HAPPY_STACKS_STACK=exp1\n', 'utf-8');
+
+  const componentDir = join(root, 'component');
+  await mkdir(componentDir, { recursive: true });
+  await writeFile(join(componentDir, 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(componentDir, 'yarn.lock'), '# yarn\n', 'utf-8');
+
+  const binDir = join(root, 'bin');
+  const outputPath = join(root, 'env.json');
+  await writeYarnEnvDumpStub({ binDir, outputPath });
+
+  const exp = expectedCacheEnv({ envPath });
+  const oldPath = process.env.PATH;
+
+  await withEnv(
+    {
+      PATH: `${binDir}:${oldPath ?? ''}`,
+      OUTPUT_PATH: outputPath,
+      HAPPY_STACKS_ENV_FILE: envPath,
+      HAPPY_LOCAL_ENV_FILE: envPath,
+      XDG_CACHE_HOME: null,
+      YARN_CACHE_FOLDER: null,
+      npm_config_cache: null,
+    },
+    async () => {
+      await pmExecBin({ dir: componentDir, bin: 'prisma', args: ['generate'], env: process.env, quiet: true });
+      const parsed = JSON.parse(await readFile(outputPath, 'utf-8'));
+      assert.equal(parsed.XDG_CACHE_HOME, exp.xdg);
+      assert.equal(parsed.YARN_CACHE_FOLDER, exp.yarn);
+      assert.equal(parsed.npm_config_cache, exp.npm);
+    }
+  );
+});
+