@happier-dev/stack 0.1.0 → 0.2.0

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

@@ -59,6 +59,30 @@ async function writeStubYarnCaptureKind({ binDir }) {
   await chmod(yarnPath, 0o755);
 }
 
+async function writeStubYarnCaptureEnv({ binDir }) {
+  await mkdir(binDir, { recursive: true });
+  const yarnPath = join(binDir, 'yarn');
+  await writeFile(
+    yarnPath,
+    [
+      '#!/usr/bin/env node',
+      'const fs = require("fs");',
+      'const args = process.argv.slice(2);',
+      "if (args.includes('--version')) { console.log('1.22.22'); process.exit(0); }",
+      'if (args[0] === "run") {',
+      '  const out = process.env.TEST_OUT_FILE || "";',
+      '  if (out) {',
+      '    fs.writeFileSync(out, JSON.stringify({ TSX_TSCONFIG_PATH: process.env.TSX_TSCONFIG_PATH || "" }), "utf-8");',
+      '  }',
+      '  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 () => {
@@ -129,3 +153,33 @@ test('pmSpawnScript marks stack-owned infra processes with HAPPIER_STACK_PROCESS
   const kind = (await readFile(outFile, 'utf-8')).trim();
   assert.equal(kind, 'infra');
 });
+
+test('pmSpawnScript scopes TSX_TSCONFIG_PATH to the component tsconfig', async (t) => {
+  const root = await mkdtemp(join(tmpdir(), 'hs-pm-spawn-tsx-tsconfig-'));
+  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');
+  await writeFile(join(componentDir, 'tsconfig.json'), '{ "compilerOptions": {} }\n', 'utf-8');
+
+  const outFile = join(root, 'tsx-env.json');
+  const binDir = join(root, 'bin');
+  await writeStubYarnCaptureEnv({ binDir });
+
+  const env = {
+    ...process.env,
+    PATH: `${binDir}:${process.env.PATH ?? ''}`,
+    TEST_OUT_FILE: outFile,
+    TSX_TSCONFIG_PATH: '/tmp/foreign-component/tsconfig.json',
+  };
+  const child = await pmSpawnScript({ dir: componentDir, label: 'spawn-test', script: 'noop', env, quiet: true, options: { silent: true } });
+  const res = await waitExit(child);
+  assert.equal(res.code, 0);
+
+  const captured = JSON.parse(await readFile(outFile, 'utf-8'));
+  assert.equal(captured.TSX_TSCONFIG_PATH, join(componentDir, 'tsconfig.json'));
+});

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

@@ -1,6 +1,6 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { chmod, mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { chmod, mkdtemp, mkdir, readFile, rm, utimes, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { spawn } from 'node:child_process';
@@ -19,6 +19,8 @@ async function writeYarnEnvDumpStub({ binDir, outputPath }) {
       '  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,',
+      '  REDISMS_DISABLE_POSTINSTALL: process.env.REDISMS_DISABLE_POSTINSTALL ?? null,',
+      '  HOME: process.env.HOME ?? null,',
       '  NODE_ENV: process.env.NODE_ENV ?? null,',
       '  YARN_PRODUCTION: process.env.YARN_PRODUCTION ?? null,',
       '  npm_config_production: process.env.npm_config_production ?? null,',
@@ -33,6 +35,44 @@ async function writeYarnEnvDumpStub({ binDir, outputPath }) {
   await writeFile(outputPath, '', 'utf-8');
 }
 
+async function writeYarnRuntimeDumpStub({ 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 = {",
+      '  fakeNodeUsed: process.env.FAKE_NODE_USED ?? null,',
+      '  execPath: process.execPath,',
+      '};',
+      "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');
+}
+
+async function writeNvmNodeShim({ nvmDir, version }) {
+  const binDir = join(nvmDir, 'versions', 'node', version, 'bin');
+  await mkdir(binDir, { recursive: true });
+  const nodePath = join(binDir, 'node');
+  await writeFile(
+    nodePath,
+    [
+      '#!/bin/bash',
+      'set -euo pipefail',
+      'export FAKE_NODE_USED=1',
+      `exec ${JSON.stringify(process.execPath)} "$@"`,
+    ].join('\n') + '\n',
+    'utf-8'
+  );
+  await chmod(nodePath, 0o755);
+}
+
 async function writeYarnArgDumpStub({ binDir, outputPath }) {
   await mkdir(binDir, { recursive: true });
   const yarnPath = join(binDir, 'yarn');
@@ -117,6 +157,79 @@ async function writeYarnBuildCreatesDistStub({ binDir, outputPath, cliDir }) {
   await writeFile(outputPath, '', 'utf-8');
 }
 
+async function writeYarnBuildCreatesPartialDistWithMissingChunkStub({ binDir, outputPath, cliDir }) {
+  await mkdir(binDir, { recursive: true });
+  const yarnPath = join(binDir, 'yarn');
+  await writeFile(
+    yarnPath,
+    [
+      '#!/usr/bin/env bash',
+      'set -euo pipefail',
+      'echo "$*" >> "${OUTPUT_PATH:?}"',
+      'if [ "${1:-}" = "--version" ]; then',
+      '  echo "1.22.22"',
+      '  exit 0',
+      'fi',
+      'if [ "${1:-}" = "build" ]; then',
+      `  mkdir -p ${JSON.stringify(join(cliDir, 'dist'))}`,
+      // Simulate a "successful" build that leaves a broken local import graph.
+      // This should be treated as a build failure by ensureCliBuilt.
+      `  echo "import './index-inner.mjs';" > ${JSON.stringify(join(cliDir, 'dist', 'index.mjs'))}`,
+      `  echo "import './missing-chunk.mjs';" > ${JSON.stringify(join(cliDir, 'dist', 'index-inner.mjs'))}`,
+      '  exit 0',
+      'fi',
+      'exit 0',
+    ].join('\n') + '\n',
+    'utf-8'
+  );
+  await chmod(yarnPath, 0o755);
+  await writeFile(outputPath, '', 'utf-8');
+}
+
+async function writeYarnSlowBuildCreatesDistStub({ binDir, outputPath, cliDir }) {
+  await mkdir(binDir, { recursive: true });
+  const yarnPath = join(binDir, 'yarn');
+  await writeFile(
+    yarnPath,
+    [
+      '#!/usr/bin/env bash',
+      'set -euo pipefail',
+      'echo "$*" >> "${OUTPUT_PATH:?}"',
+      'if [ "${1:-}" = "--version" ]; then',
+      '  echo "1.22.22"',
+      '  exit 0',
+      'fi',
+      'if [ "${1:-}" = "build" ]; then',
+      '  sleep 1',
+      `  mkdir -p ${JSON.stringify(join(cliDir, 'dist'))}`,
+      `  echo "export const built = true;" > ${JSON.stringify(join(cliDir, 'dist', 'index.mjs'))}`,
+      '  exit 0',
+      'fi',
+      'exit 0',
+    ].join('\n') + '\n',
+    'utf-8'
+  );
+  await chmod(yarnPath, 0o755);
+  await writeFile(outputPath, '', 'utf-8');
+}
+
+async function waitForFileText(path, matcher, { timeoutMs = 5_000 } = {}) {
+  const startedAt = Date.now();
+  for (;;) {
+    try {
+      const text = await readFile(path, 'utf-8');
+      if (matcher.test(text)) {
+        return;
+      }
+    } catch {
+    }
+    if (Date.now() - startedAt >= timeoutMs) {
+      throw new Error(`timed out waiting for ${path} to match ${matcher}`);
+    }
+    await new Promise((resolve) => setTimeout(resolve, 25));
+  }
+}
+
 async function runCapture(cmd, args, { cwd, env } = {}) {
   return await new Promise((resolve, reject) => {
     const proc = spawn(cmd, args, { cwd, env, stdio: ['ignore', 'pipe', 'pipe'] });
@@ -225,6 +338,29 @@ test('ensureDepsInstalled skips dependency refresh in service mode when node_mod
   assert.ok(!out.includes('install'), `expected no yarn install in service mode, got:\n${out}`);
 });
 
+test('ensureDepsInstalled skips dependency refresh when explicitly disabled in local mode', async (t) => {
+  const fixture = await createStackCacheFixture(t, 'hs-pm-stack-cache-local-refresh-disable-');
+  const { root, envPath, componentDir, binDir } = fixture;
+  const outputPath = join(root, 'argv.txt');
+
+  await writeYarnArgDumpStub({ binDir, outputPath });
+
+  await mkdir(join(componentDir, 'node_modules'), { recursive: true });
+  await writeFile(join(componentDir, 'node_modules', '.yarn-integrity'), 'old\n', 'utf-8');
+  await writeFile(join(componentDir, 'yarn.lock'), '# new lock\n', 'utf-8');
+
+  applyEnvOverrides(t, {
+    PATH: `${binDir}:${process.env.PATH ?? ''}`,
+    OUTPUT_PATH: outputPath,
+    HAPPIER_STACK_ENV_FILE: envPath,
+    HAPPIER_STACK_SKIP_REFRESH_DEPS: '1',
+  });
+
+  await ensureDepsInstalled(componentDir, 'test-component', { quiet: true, env: process.env });
+  const out = await readFile(outputPath, 'utf-8');
+  assert.ok(!out.includes('install'), `expected no yarn install when refresh is disabled, got:\n${out}`);
+});
+
 test('ensureDepsInstalled scrubs production-mode env for yarn installs', async (t) => {
   const fixture = await createStackCacheFixture(t, 'hs-pm-stack-cache-prod-scrub-');
   const { root, envPath, componentDir, binDir } = fixture;
@@ -273,6 +409,73 @@ test('ensureDepsInstalled scrubs production-mode env even without a stack env fi
   assert.notEqual(parsed.NPM_CONFIG_PRODUCTION, 'true');
 });
 
+test('ensureDepsInstalled disables redis-memory-server postinstall for stack-managed installs', async (t) => {
+  const fixture = await createStackCacheFixture(t, 'hs-pm-redis-memory-server-postinstall-disable-');
+  const { root, envPath, componentDir, binDir } = fixture;
+  const outputPath = join(root, 'env.json');
+  await writeYarnEnvDumpStub({ binDir, outputPath });
+
+  applyEnvOverrides(t, {
+    PATH: `${binDir}:${process.env.PATH ?? ''}`,
+    OUTPUT_PATH: outputPath,
+    HAPPIER_STACK_ENV_FILE: envPath,
+  });
+
+  await ensureDepsInstalled(componentDir, 'test-component', { quiet: true, env: process.env });
+  const parsed = JSON.parse(await readFile(outputPath, 'utf-8'));
+  assert.equal(parsed.REDISMS_DISABLE_POSTINSTALL, '1');
+});
+
+test('ensureDepsInstalled honors HAPPIER_STACK_PM_CACHE_BASE_DIR when no stack env file is present', async (t) => {
+  const fixture = await createStackCacheFixture(t, 'hs-pm-explicit-cache-base-');
+  const { root, componentDir, binDir } = fixture;
+  const outputPath = join(root, 'env.json');
+  await writeYarnEnvDumpStub({ binDir, outputPath });
+
+  const cacheBase = join(root, 'pm-cache');
+
+  applyEnvOverrides(t, {
+    PATH: `${binDir}:${process.env.PATH ?? ''}`,
+    OUTPUT_PATH: outputPath,
+    HAPPIER_STACK_ENV_FILE: null,
+    HAPPIER_STACK_PM_CACHE_BASE_DIR: cacheBase,
+    XDG_CACHE_HOME: null,
+    YARN_CACHE_FOLDER: null,
+    npm_config_cache: null,
+  });
+
+  await ensureDepsInstalled(componentDir, 'test-component', { quiet: true });
+  const parsed = JSON.parse(await readFile(outputPath, 'utf-8'));
+  assert.equal(parsed.XDG_CACHE_HOME, join(cacheBase, 'xdg'));
+  assert.equal(parsed.YARN_CACHE_FOLDER, join(cacheBase, 'yarn'));
+  assert.equal(parsed.npm_config_cache, join(cacheBase, 'npm'));
+  assert.equal(parsed.HOME, join(cacheBase, 'home'));
+});
+
+test('ensureDepsInstalled prefers the .nvmrc node runtime for yarn shebangs when available', async (t) => {
+  const fixture = await createStackCacheFixture(t, 'hs-pm-nvm-node-runtime-');
+  const { root, componentDir, binDir } = fixture;
+  const outputPath = join(root, 'runtime.json');
+  const nvmDir = join(root, '.nvm');
+  const version = 'v22.22.1';
+
+  await writeYarnRuntimeDumpStub({ binDir, outputPath });
+  await writeNvmNodeShim({ nvmDir, version });
+  await writeFile(join(componentDir, '.nvmrc'), `${version}\n`, 'utf-8');
+
+  applyEnvOverrides(t, {
+    PATH: `${binDir}:${dirname(process.execPath)}:/usr/bin:/bin`,
+    OUTPUT_PATH: outputPath,
+    HAPPIER_STACK_ENV_FILE: null,
+    NVM_DIR: nvmDir,
+  });
+
+  await ensureDepsInstalled(componentDir, 'test-component', { quiet: true });
+  const parsed = JSON.parse(await readFile(outputPath, 'utf-8'));
+  assert.equal(parsed.fakeNodeUsed, '1');
+  assert.match(parsed.execPath, /node$/);
+});
+
 test('ensureDepsInstalled prefers yarn when component is inside the Happy monorepo (packages/ layout)', async (t) => {
   const root = await mkdtemp(join(tmpdir(), 'hs-pm-happy-monorepo-yarn-'));
   t.after(async () => {
@@ -341,6 +544,47 @@ test('ensureDepsInstalled forces non-production yarn installs', async (t) => {
   assert.match(installLine, /--production=false\b/);
 });
 
+test('ensureDepsInstalled regenerates server Prisma provider outputs when sqlite generated clients are missing', async (t) => {
+  const root = await mkdtemp(join(tmpdir(), 'hs-pm-server-generate-providers-'));
+  t.after(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  await mkdir(join(root, 'apps', 'ui'), { recursive: true });
+  await mkdir(join(root, 'apps', 'cli'), { recursive: true });
+  await mkdir(join(root, 'apps', 'server', 'prisma', 'sqlite'), { recursive: true });
+  await writeFile(join(root, 'apps', 'ui', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(root, 'apps', 'cli', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(
+    join(root, 'apps', 'server', 'package.json'),
+    JSON.stringify({ name: '@happier-dev/server', scripts: { 'generate:providers': 'tsx ./scripts/generateClients.ts' } }, null, 2) + '\n',
+    'utf-8',
+  );
+  await writeFile(join(root, 'apps', 'server', 'prisma', 'schema.prisma'), 'datasource db { provider = "postgresql" }\n', 'utf-8');
+  await writeFile(join(root, 'apps', 'server', 'prisma', 'sqlite', 'schema.prisma'), 'datasource db { provider = "sqlite" }\n', 'utf-8');
+  await writeFile(join(root, 'package.json'), '{ "name": "monorepo", "private": true }\n', 'utf-8');
+  await writeFile(join(root, 'yarn.lock'), '# yarn\n', 'utf-8');
+
+  await mkdir(join(root, 'node_modules', '.prisma', 'client'), { recursive: true });
+  await writeFile(join(root, 'node_modules', '.prisma', 'client', 'default.js'), 'module.exports = {};\n', 'utf-8');
+  await writeFile(join(root, 'node_modules', '.yarn-integrity'), 'ok\n', 'utf-8');
+
+  const componentDir = join(root, 'apps', 'server');
+  const binDir = join(root, 'bin');
+  const outputPath = join(root, 'argv.txt');
+  await writeYarnArgDumpStub({ binDir, outputPath });
+
+  applyEnvOverrides(t, {
+    PATH: `${binDir}:/usr/bin:/bin`,
+    OUTPUT_PATH: outputPath,
+    HAPPIER_STACK_ENV_FILE: null,
+  });
+
+  await ensureDepsInstalled(componentDir, 'happier-server-light', { quiet: true });
+  const out = await readFile(outputPath, 'utf-8');
+  assert.match(out, /\bworkspace @happier-dev\/server generate:providers\b/, `expected provider generation, got:\n${out}`);
+});
+
 test('ensureDepsInstalled refreshes monorepo dependencies when root yarn.lock changes', async (t) => {
   const root = await mkdtemp(join(tmpdir(), 'hs-pm-happy-monorepo-refresh-'));
   t.after(async () => {
@@ -364,6 +608,13 @@ test('ensureDepsInstalled refreshes monorepo dependencies when root yarn.lock ch
 
   // Root yarn.lock is newer than the integrity file -> should trigger `yarn install`.
   await writeFile(join(root, 'yarn.lock'), '# yarn\n', 'utf-8');
+  // Some filesystems (and CI runners) can create both files within the same timestamp quantum.
+  // Make the "lock newer than integrity" ordering explicit to keep this test deterministic.
+  const base = Date.now();
+  const older = new Date(base - 10_000);
+  const newer = new Date(base);
+  await utimes(join(root, 'node_modules', '.yarn-integrity'), older, older);
+  await utimes(join(root, 'yarn.lock'), newer, newer);
 
   const binDir = join(root, 'bin');
   const outputPath = join(root, 'argv.txt');
@@ -380,6 +631,50 @@ test('ensureDepsInstalled refreshes monorepo dependencies when root yarn.lock ch
   assert.match(out, /\binstall\b/);
 });
 
+test('ensureDepsInstalled skips monorepo refresh when node_modules is newer even without root yarn integrity', async (t) => {
+  const root = await mkdtemp(join(tmpdir(), 'hs-pm-happy-monorepo-missing-integrity-'));
+  t.after(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  await mkdir(join(root, 'apps', 'ui'), { recursive: true });
+  await mkdir(join(root, 'apps', 'cli'), { recursive: true });
+  await mkdir(join(root, 'apps', 'server'), { recursive: true });
+  await writeFile(join(root, 'apps', 'ui', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(root, 'apps', 'cli', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(root, 'apps', 'server', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(root, 'package.json'), '{ "name": "monorepo", "private": true }\n', 'utf-8');
+  await writeFile(join(root, 'yarn.lock'), '# yarn\n', 'utf-8');
+
+  await mkdir(join(root, 'node_modules', '@scope', 'pkg'), { recursive: true });
+  await writeFile(join(root, 'node_modules', '.placeholder'), 'ok\n', 'utf-8');
+  await writeFile(join(root, 'node_modules', '@scope', 'pkg', 'package.json'), '{}\n', 'utf-8');
+
+  const base = Date.now();
+  const older = new Date(base - 10_000);
+  const newer = new Date(base);
+  await Promise.all([
+    utimes(join(root, 'package.json'), older, older),
+    utimes(join(root, 'yarn.lock'), older, older),
+    utimes(join(root, 'apps', 'ui', 'package.json'), older, older),
+    utimes(join(root, 'node_modules'), newer, newer),
+  ]);
+
+  const binDir = join(root, 'bin');
+  const outputPath = join(root, 'argv.txt');
+  await writeYarnArgDumpStub({ binDir, outputPath });
+
+  applyEnvOverrides(t, {
+    PATH: `${binDir}:/usr/bin:/bin`,
+    OUTPUT_PATH: outputPath,
+    HAPPIER_STACK_ENV_FILE: null,
+  });
+
+  await ensureDepsInstalled(join(root, 'apps', 'ui'), 'happier-ui', { quiet: true });
+  const out = await readFile(outputPath, 'utf-8');
+  assert.doesNotMatch(out, /\binstall\b/, `expected no yarn install when node_modules is already newer, got:\n${out}`);
+});
+
 test('ensureDepsInstalled falls back to npm in binary mode when yarn is unavailable', async (t) => {
   const root = await mkdtemp(join(tmpdir(), 'hs-pm-binary-mode-npm-'));
   t.after(async () => {
@@ -439,6 +734,7 @@ test('ensureCliBuilt restores previous dist output when build fails', async (t)
   await mkdir(cliDir, { recursive: true });
   await writeFile(join(cliDir, 'package.json'), '{ "name": "cli-test" }\n', 'utf-8');
   await writeFile(join(cliDir, 'yarn.lock'), '# yarn\n', 'utf-8');
+  await writeFile(join(cliDir, '.gitignore'), 'dist/\n', 'utf-8');
   await mkdir(join(cliDir, 'node_modules'), { recursive: true });
   await writeFile(join(cliDir, 'node_modules', '.yarn-integrity'), 'ok\n', 'utf-8');
 
@@ -463,6 +759,164 @@ test('ensureCliBuilt restores previous dist output when build fails', async (t)
   assert.equal(restored, 'export const stable = true;\n');
 });
 
+test('ensureCliBuilt restores previous dist output when build produces a broken dist import graph', async (t) => {
+  const root = await mkdtemp(join(tmpdir(), 'hs-pm-cli-build-partial-'));
+  t.after(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  const cliDir = join(root, 'apps', 'cli');
+  await mkdir(cliDir, { recursive: true });
+  await writeFile(join(cliDir, 'package.json'), '{ "name": "cli-test" }\n', 'utf-8');
+  await writeFile(join(cliDir, 'yarn.lock'), '# yarn\n', 'utf-8');
+  await writeFile(join(cliDir, '.gitignore'), 'dist/\n', 'utf-8');
+  await mkdir(join(cliDir, 'node_modules'), { recursive: true });
+  await writeFile(join(cliDir, 'node_modules', '.yarn-integrity'), 'ok\n', 'utf-8');
+
+  const distIndex = join(cliDir, 'dist', 'index.mjs');
+  await mkdir(dirname(distIndex), { recursive: true });
+  await writeFile(distIndex, 'export const stable = true;\n', 'utf-8');
+
+  const binDir = join(root, 'bin');
+  const outputPath = join(root, 'argv.txt');
+  await writeYarnBuildCreatesPartialDistWithMissingChunkStub({ binDir, outputPath, cliDir });
+
+  applyEnvOverrides(t, {
+    PATH: `${binDir}:/usr/bin:/bin`,
+    OUTPUT_PATH: outputPath,
+    HAPPIER_STACK_CLI_BUILD_MODE: 'always',
+    HAPPIER_STACK_ENV_FILE: null,
+  });
+
+  await assert.rejects(() => ensureCliBuilt(cliDir, { buildCli: true, quiet: true }));
+  const restored = await readFile(distIndex, 'utf-8');
+  assert.equal(restored, 'export const stable = true;\n');
+});
+
+test('ensureCliBuilt serializes concurrent rebuilds so dist is built once when the git signature still matches', async (t) => {
+  const root = await mkdtemp(join(tmpdir(), 'hs-pm-cli-build-lock-'));
+  t.after(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  const cliDir = join(root, 'apps', 'cli');
+  await mkdir(cliDir, { recursive: true });
+  await writeFile(join(cliDir, 'package.json'), '{ "name": "cli-test" }\n', 'utf-8');
+  await writeFile(join(cliDir, 'yarn.lock'), '# yarn\n', 'utf-8');
+  await mkdir(join(cliDir, 'node_modules'), { recursive: true });
+  await writeFile(join(cliDir, 'node_modules', '.yarn-integrity'), 'ok\n', 'utf-8');
+
+  await runCapture('git', ['init'], { cwd: cliDir });
+  await runCapture('git', ['config', 'user.email', 'hstack-test@example.test'], { cwd: cliDir });
+  await runCapture('git', ['config', 'user.name', 'hstack-test'], { cwd: cliDir });
+  await runCapture('git', ['add', '.'], { cwd: cliDir });
+  await runCapture('git', ['commit', '-m', 'init'], { cwd: cliDir });
+
+  const distIndex = join(cliDir, 'dist', 'index.mjs');
+  await mkdir(dirname(distIndex), { recursive: true });
+  await writeFile(distIndex, 'export const stable = true;\n', 'utf-8');
+
+  const binDir = join(root, 'bin');
+  const outputPath = join(root, 'argv.txt');
+  await writeYarnSlowBuildCreatesDistStub({ binDir, outputPath, cliDir });
+
+  applyEnvOverrides(t, {
+    PATH: `${binDir}:/usr/bin:/bin`,
+    OUTPUT_PATH: outputPath,
+    HAPPIER_STACK_CLI_BUILD_MODE: 'always',
+    HAPPIER_STACK_HOME_DIR: join(root, 'home'),
+    HAPPIER_STACK_ENV_FILE: null,
+  });
+
+  await Promise.all([
+    ensureCliBuilt(cliDir, { buildCli: true, quiet: true, env: process.env }),
+    ensureCliBuilt(cliDir, { buildCli: true, quiet: true, env: process.env }),
+  ]);
+
+  const argv = await readFile(outputPath, 'utf-8');
+  const buildInvocations = argv
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line === 'build');
+  assert.equal(buildInvocations.length, 1);
+  assert.equal(await readFile(distIndex, 'utf-8'), 'export const built = true;\n');
+});
+
+test('ensureCliBuilt rebuilds after waiting in always mode when worktree changed during the earlier build', async (t) => {
+  const root = await mkdtemp(join(tmpdir(), 'hs-pm-cli-build-lock-always-dirty-'));
+  t.after(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  const cliDir = join(root, 'apps', 'cli');
+  await mkdir(cliDir, { recursive: true });
+  await writeFile(join(cliDir, 'package.json'), '{ "name": "cli-test" }\n', 'utf-8');
+  await writeFile(join(cliDir, 'yarn.lock'), '# yarn\n', 'utf-8');
+  await mkdir(join(cliDir, 'node_modules'), { recursive: true });
+  await writeFile(join(cliDir, 'node_modules', '.yarn-integrity'), 'ok\n', 'utf-8');
+  await writeFile(join(cliDir, 'tracked.txt'), 'initial\n', 'utf-8');
+
+  await runCapture('git', ['init'], { cwd: cliDir });
+  await runCapture('git', ['config', 'user.email', 'hstack-test@example.test'], { cwd: cliDir });
+  await runCapture('git', ['config', 'user.name', 'hstack-test'], { cwd: cliDir });
+  await runCapture('git', ['add', '.'], { cwd: cliDir });
+  await runCapture('git', ['commit', '-m', 'init'], { cwd: cliDir });
+
+  const binDir = join(root, 'bin');
+  const outputPath = join(root, 'argv.txt');
+  await mkdir(binDir, { recursive: true });
+  const yarnPath = join(binDir, 'yarn');
+  await writeFile(
+    yarnPath,
+    [
+      '#!/usr/bin/env bash',
+      'set -euo pipefail',
+      'echo "$*" >> "${OUTPUT_PATH:?}"',
+      'if [ "${1:-}" = "--version" ]; then',
+      '  echo "1.22.22"',
+      '  exit 0',
+      'fi',
+      'if [ "${1:-}" = "build" ]; then',
+      '  sleep 1',
+      `  mkdir -p ${JSON.stringify(join(cliDir, 'dist'))}`,
+      `  echo "export const built = true;" > ${JSON.stringify(join(cliDir, 'dist', 'index.mjs'))}`,
+      '  exit 0',
+      'fi',
+      'exit 0',
+    ].join('\n') + '\n',
+    'utf-8'
+  );
+  await chmod(yarnPath, 0o755);
+  await writeFile(outputPath, '', 'utf-8');
+
+  applyEnvOverrides(t, {
+    PATH: `${binDir}:/usr/bin:/bin`,
+    OUTPUT_PATH: outputPath,
+    HAPPIER_STACK_CLI_BUILD_MODE: 'always',
+    HAPPIER_STACK_HOME_DIR: join(root, 'home'),
+    HAPPIER_STACK_ENV_FILE: null,
+  });
+
+  const distIndex = join(cliDir, 'dist', 'index.mjs');
+  await mkdir(dirname(distIndex), { recursive: true });
+  await writeFile(distIndex, 'export const stable = true;\n', 'utf-8');
+
+  const firstBuildPromise = ensureCliBuilt(cliDir, { buildCli: true, quiet: true, env: process.env });
+  await waitForFileText(outputPath, /(^|\n)build(\n|$)/);
+  const secondBuildPromise = ensureCliBuilt(cliDir, { buildCli: true, quiet: true, env: process.env });
+  await writeFile(join(cliDir, 'tracked.txt'), 'changed during build\n', 'utf-8');
+
+  await Promise.all([firstBuildPromise, secondBuildPromise]);
+
+  const argv = await readFile(outputPath, 'utf-8');
+  const buildInvocations = argv
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line === 'build');
+  assert.equal(buildInvocations.length, 2);
+  assert.equal(await readFile(distIndex, 'utf-8'), 'export const built = true;\n');
+});
+
 test('ensureCliBuilt restores dist from .dist.hstack-backup when previous build was interrupted', async (t) => {
   const root = await mkdtemp(join(tmpdir(), 'hs-pm-cli-build-interrupted-'));
   t.after(async () => {

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

@@ -0,0 +1,92 @@
+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 { ensureDepsInstalled } from './pm.mjs';
+
+async function writeJson(path, obj) {
+  await writeFile(path, JSON.stringify(obj, null, 2) + '\n', 'utf-8');
+}
+
+async function writeStubYarnThatRequiresYes({ binDir }) {
+  await mkdir(binDir, { recursive: true });
+  const yarnPath = join(binDir, 'yarn');
+  await writeFile(
+    yarnPath,
+    [
+      '#!/usr/bin/env node',
+      'const args = process.argv.slice(2);',
+      "if (args.includes('--version')) {",
+      '  let buf = "";',
+      '  let done = false;',
+      '  const finish = (code) => {',
+      '    if (done) return;',
+      '    done = true;',
+      '    process.exit(code);',
+      '  };',
+      '  const t = setTimeout(() => finish(3), 1500);',
+      '  process.stdin.on("data", (d) => {',
+      '    buf += String(d);',
+      '    if (buf.toLowerCase().includes("y")) {',
+      '      clearTimeout(t);',
+      '      finish(0);',
+      '    }',
+      '  });',
+      '  process.stdin.on("end", () => {',
+      '    clearTimeout(t);',
+      '    finish(buf.toLowerCase().includes("y") ? 0 : 4);',
+      '  });',
+      '  try { process.stdin.resume(); } catch {}',
+      '  return;',
+      '}',
+      'process.exit(0);',
+    ].join('\n') + '\n',
+    'utf-8'
+  );
+  await chmod(yarnPath, 0o755);
+}
+
+test('ensureDepsInstalled auto-answers Corepack-style prompts for yarn readiness in a TTY parent', async (t) => {
+  const root = await mkdtemp(join(tmpdir(), 'hs-pm-yarn-ready-'));
+  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');
+  await mkdir(join(componentDir, 'node_modules'), { recursive: true });
+
+  const binDir = join(root, 'bin');
+  await writeStubYarnThatRequiresYes({ binDir });
+
+  const originalIsTty = process.stdin.isTTY;
+  let restored = false;
+  try {
+    Object.defineProperty(process.stdin, 'isTTY', { value: true, configurable: true });
+    t.after(() => {
+      if (restored) return;
+      restored = true;
+      try {
+        Object.defineProperty(process.stdin, 'isTTY', { value: originalIsTty, configurable: true });
+      } catch {
+        // ignore
+      }
+    });
+  } catch {
+    // If isTTY is non-configurable in this environment, the test still provides coverage on CI
+    // where stdin tends to be a pipe; fall back without forcing TTY mode.
+  }
+
+  await ensureDepsInstalled(componentDir, 'stub-component', {
+    quiet: false,
+    env: {
+      ...process.env,
+      PATH: `${binDir}:${process.env.PATH ?? ''}`,
+      HAPPIER_STACK_SKIP_REFRESH_DEPS: '1',
+    },
+  });
+});