happy-stacks 0.4.0 → 0.5.0

package/scripts/worktrees_archive_cmd.test.mjs

@@ -0,0 +1,245 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtemp, mkdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+function runCmd(cmd, args, { cwd, env }) {
+  return new Promise((resolve, reject) => {
+    const cleanEnv = {};
+    for (const [k, v] of Object.entries(env ?? {})) {
+      if (v == null) continue;
+      cleanEnv[k] = String(v);
+    }
+    const proc = spawn(cmd, args, { cwd, env: cleanEnv, stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+    proc.stdout.on('data', (d) => (stdout += String(d)));
+    proc.stderr.on('data', (d) => (stderr += String(d)));
+    proc.on('error', reject);
+    proc.on('exit', (code) => resolve({ code: code ?? 0, stdout, stderr }));
+  });
+}
+
+function runNode(args, { cwd, env }) {
+  return runCmd(process.execPath, args, { cwd, env });
+}
+
+async function runOk(cmd, args, { cwd, env }) {
+  const res = await runCmd(cmd, args, { cwd, env });
+  assert.equal(res.code, 0, `expected exit 0 for ${cmd} ${args.join(' ')}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+  return res;
+}
+
+test('happys wt archive detaches and moves a git worktree (preserving uncommitted changes)', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-wt-archive-'));
+
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+  const workspaceDir = join(tmp, 'workspace');
+  const componentsDir = join(workspaceDir, 'components');
+
+  const baseEnv = {
+    ...Object.fromEntries(Object.entries(process.env).filter(([k]) => !k.startsWith('HAPPY_STACKS_') && !k.startsWith('HAPPY_LOCAL_'))),
+    GIT_TERMINAL_PROMPT: '0',
+    HAPPY_STACKS_HOME_DIR: homeDir,
+    HAPPY_STACKS_STORAGE_DIR: storageDir,
+    HAPPY_STACKS_WORKSPACE_DIR: workspaceDir,
+  };
+
+  const repoDir = join(componentsDir, 'happy');
+  await mkdir(repoDir, { recursive: true });
+  await runOk('git', ['init', '-b', 'main'], { cwd: repoDir, env: baseEnv });
+  await runOk('git', ['config', 'user.name', 'Test'], { cwd: repoDir, env: baseEnv });
+  await runOk('git', ['config', 'user.email', 'test@example.com'], { cwd: repoDir, env: baseEnv });
+  await writeFile(join(repoDir, 'README.md'), 'hello\n', 'utf-8');
+  await runOk('git', ['add', 'README.md'], { cwd: repoDir, env: baseEnv });
+  await runOk('git', ['commit', '-m', 'init'], { cwd: repoDir, env: baseEnv });
+
+  const worktreeDir = join(componentsDir, '.worktrees', 'happy', 'slopus', 'pr', 'test-archive');
+  await mkdir(dirname(worktreeDir), { recursive: true });
+  await runOk('git', ['worktree', 'add', '-b', 'slopus/pr/test-archive', worktreeDir, 'main'], { cwd: repoDir, env: baseEnv });
+
+  await writeFile(join(worktreeDir, 'staged.txt'), 'staged\n', 'utf-8');
+  await runOk('git', ['add', 'staged.txt'], { cwd: worktreeDir, env: baseEnv });
+  await writeFile(join(worktreeDir, 'untracked.txt'), 'untracked\n', 'utf-8');
+  await writeFile(join(worktreeDir, 'README.md'), 'hello\nchanged\n', 'utf-8');
+
+  const beforeStatus = await runOk('git', ['status', '--porcelain'], { cwd: worktreeDir, env: baseEnv });
+  assert.ok(beforeStatus.stdout.includes('A  staged.txt'), `expected staged file in status\n${beforeStatus.stdout}`);
+  assert.ok(beforeStatus.stdout.includes(' M README.md'), `expected modified file in status\n${beforeStatus.stdout}`);
+  assert.ok(beforeStatus.stdout.includes('?? untracked.txt'), `expected untracked file in status\n${beforeStatus.stdout}`);
+
+  const date = '2000-01-02';
+  // Simulate a minimal PATH environment like launchd/SwiftBar shells.
+  const nodeEnv = { ...baseEnv, PATH: '' };
+  const res = await runNode([join(rootDir, 'scripts', 'worktrees.mjs'), 'archive', 'happy', 'slopus/pr/test-archive', `--date=${date}`, '--json'], {
+    cwd: rootDir,
+    env: nodeEnv,
+  });
+  assert.equal(res.code, 0, `expected archive exit 0\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+  const parsed = JSON.parse(res.stdout);
+  assert.equal(parsed.ok, true, `expected ok=true JSON output\n${res.stdout}`);
+
+  const archivedDir = join(componentsDir, '.worktrees-archive', date, 'happy', 'slopus', 'pr', 'test-archive');
+  assert.equal(parsed.destDir, archivedDir, `expected destDir in JSON output to match archive path\n${res.stdout}`);
+  const legacyGitFile = await stat(join(archivedDir, '.git.worktree')).catch(() => null);
+  assert.equal(legacyGitFile, null, 'expected .git.worktree to be removed (avoid untracked noise)');
+  const gitStat = await stat(join(archivedDir, '.git'));
+  assert.ok(gitStat.isDirectory(), 'expected archived .git to be a directory (detached repo)');
+
+  const meta = await readFile(join(archivedDir, 'ARCHIVE_META.txt'), 'utf-8');
+  assert.ok(meta.includes('component=happy'), `expected component in ARCHIVE_META.txt\n${meta}`);
+  assert.ok(meta.includes('ref=slopus/pr/test-archive'), `expected ref in ARCHIVE_META.txt\n${meta}`);
+
+  const afterStatus = await runOk('git', ['status', '--porcelain'], { cwd: archivedDir, env: baseEnv });
+  assert.ok(afterStatus.stdout.includes('A  staged.txt'), `expected staged file preserved\n${afterStatus.stdout}`);
+  assert.ok(afterStatus.stdout.includes(' M README.md'), `expected modified file preserved\n${afterStatus.stdout}`);
+  assert.ok(afterStatus.stdout.includes('?? untracked.txt'), `expected untracked file preserved\n${afterStatus.stdout}`);
+
+  const list = await runOk('git', ['worktree', 'list', '--porcelain'], { cwd: repoDir, env: baseEnv });
+  assert.ok(!list.stdout.includes(worktreeDir), `expected source repo worktree entry pruned\n${list.stdout}`);
+
+  const branchExists = await runCmd('git', ['show-ref', '--verify', 'refs/heads/slopus/pr/test-archive'], { cwd: repoDir, env: baseEnv });
+  assert.notEqual(branchExists.code, 0, 'expected source repo branch deleted');
+});
+
+test('happys wt archive refuses to break stacks unless --detach-stacks is provided', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-wt-archive-stacks-'));
+
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+  const workspaceDir = join(tmp, 'workspace');
+  const componentsDir = join(workspaceDir, 'components');
+
+  const baseEnv = {
+    ...process.env,
+    GIT_TERMINAL_PROMPT: '0',
+    HAPPY_STACKS_HOME_DIR: homeDir,
+    HAPPY_STACKS_STORAGE_DIR: storageDir,
+    HAPPY_STACKS_WORKSPACE_DIR: workspaceDir,
+  };
+
+  const repoDir = join(componentsDir, 'happy');
+  await mkdir(repoDir, { recursive: true });
+  await runOk('git', ['init', '-b', 'main'], { cwd: repoDir, env: baseEnv });
+  await runOk('git', ['config', 'user.name', 'Test'], { cwd: repoDir, env: baseEnv });
+  await runOk('git', ['config', 'user.email', 'test@example.com'], { cwd: repoDir, env: baseEnv });
+  await writeFile(join(repoDir, 'README.md'), 'hello\n', 'utf-8');
+  await runOk('git', ['add', 'README.md'], { cwd: repoDir, env: baseEnv });
+  await runOk('git', ['commit', '-m', 'init'], { cwd: repoDir, env: baseEnv });
+
+  const worktreeDir = join(componentsDir, '.worktrees', 'happy', 'slopus', 'pr', 'linked-to-stack');
+  await mkdir(dirname(worktreeDir), { recursive: true });
+  await runOk('git', ['worktree', 'add', '-b', 'slopus/pr/linked-to-stack', worktreeDir, 'main'], { cwd: repoDir, env: baseEnv });
+  await writeFile(join(worktreeDir, 'untracked.txt'), 'untracked\n', 'utf-8');
+
+  const stackName = 'exp-test';
+  const envPath = join(storageDir, stackName, 'env');
+  await mkdir(dirname(envPath), { recursive: true });
+  await writeFile(envPath, [`HAPPY_STACKS_STACK=${stackName}`, `HAPPY_STACKS_COMPONENT_DIR_HAPPY=${worktreeDir}`, ''].join('\n'), 'utf-8');
+
+  const date = '2000-01-03';
+  const nodeEnv = { ...baseEnv, PATH: '' };
+
+  const denied = await runNode(
+    [join(rootDir, 'scripts', 'worktrees.mjs'), 'archive', 'happy', 'slopus/pr/linked-to-stack', `--date=${date}`],
+    { cwd: rootDir, env: nodeEnv }
+  );
+  assert.notEqual(denied.code, 0, `expected archive to refuse without --detach-stacks\nstdout:\n${denied.stdout}\nstderr:\n${denied.stderr}`);
+
+  const ok = await runNode(
+    [
+      join(rootDir, 'scripts', 'worktrees.mjs'),
+      'archive',
+      'happy',
+      'slopus/pr/linked-to-stack',
+      `--date=${date}`,
+      '--detach-stacks',
+      '--json',
+    ],
+    { cwd: rootDir, env: nodeEnv }
+  );
+  assert.equal(ok.code, 0, `expected archive to succeed with --detach-stacks\nstdout:\n${ok.stdout}\nstderr:\n${ok.stderr}`);
+
+  const nextEnv = await readFile(envPath, 'utf-8');
+  assert.ok(!nextEnv.includes('HAPPY_STACKS_COMPONENT_DIR_HAPPY='), `expected stack env to detach from worktree\n${nextEnv}`);
+
+  const archivedDir = join(componentsDir, '.worktrees-archive', date, 'happy', 'slopus', 'pr', 'linked-to-stack');
+  const gitStat = await stat(join(archivedDir, '.git'));
+  assert.ok(gitStat.isDirectory(), 'expected archived .git to be a directory (detached repo)');
+});
+
+test('happys wt archive can archive a broken git worktree (missing .git/worktrees entry)', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-wt-archive-broken-'));
+
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+  const workspaceDir = join(tmp, 'workspace');
+  const componentsDir = join(workspaceDir, 'components');
+
+  const baseEnv = {
+    ...Object.fromEntries(Object.entries(process.env).filter(([k]) => !k.startsWith('HAPPY_STACKS_') && !k.startsWith('HAPPY_LOCAL_'))),
+    GIT_TERMINAL_PROMPT: '0',
+    HAPPY_STACKS_HOME_DIR: homeDir,
+    HAPPY_STACKS_STORAGE_DIR: storageDir,
+    HAPPY_STACKS_WORKSPACE_DIR: workspaceDir,
+  };
+
+  const repoDir = join(componentsDir, 'happy');
+  await mkdir(repoDir, { recursive: true });
+  await runOk('git', ['init', '-b', 'main'], { cwd: repoDir, env: baseEnv });
+  await runOk('git', ['config', 'user.name', 'Test'], { cwd: repoDir, env: baseEnv });
+  await runOk('git', ['config', 'user.email', 'test@example.com'], { cwd: repoDir, env: baseEnv });
+  await writeFile(join(repoDir, 'README.md'), 'hello\n', 'utf-8');
+  await runOk('git', ['add', 'README.md'], { cwd: repoDir, env: baseEnv });
+  await runOk('git', ['commit', '-m', 'init'], { cwd: repoDir, env: baseEnv });
+
+  const worktreeDir = join(componentsDir, '.worktrees', 'happy', 'slopus', 'pr', 'broken-worktree');
+  await mkdir(dirname(worktreeDir), { recursive: true });
+  await runOk('git', ['worktree', 'add', '-b', 'slopus/pr/broken-worktree', worktreeDir, 'main'], { cwd: repoDir, env: baseEnv });
+
+  // Create uncommitted changes (no staging; the index will be deleted when we break the worktree).
+  await writeFile(join(worktreeDir, 'untracked.txt'), 'untracked\n', 'utf-8');
+  await writeFile(join(worktreeDir, 'README.md'), 'hello\nchanged\n', 'utf-8');
+
+  // Simulate a corrupted linked worktree by removing its gitdir entry from the source repo.
+  const gitFile = await readFile(join(worktreeDir, '.git'), 'utf-8');
+  const gitdirLine = gitFile
+    .split('\n')
+    .map((l) => l.trim())
+    .find((l) => l.startsWith('gitdir:'));
+  assert.ok(gitdirLine, `expected .git file to include gitdir line\n${gitFile}`);
+  const gitdir = gitdirLine.slice('gitdir:'.length).trim();
+  assert.ok(gitdir, `expected gitdir path\n${gitFile}`);
+  // Use an absolute path so we can rm it reliably.
+  const gitdirAbs = gitdir.startsWith('/') ? gitdir : join(worktreeDir, gitdir);
+  await rm(gitdirAbs, { recursive: true, force: true });
+
+  const date = '2000-01-05';
+  const nodeEnv = { ...baseEnv, PATH: '' };
+  const res = await runNode([join(rootDir, 'scripts', 'worktrees.mjs'), 'archive', 'happy', 'slopus/pr/broken-worktree', `--date=${date}`, '--json'], {
+    cwd: rootDir,
+    env: nodeEnv,
+  });
+  assert.equal(res.code, 0, `expected archive exit 0\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+  const parsed = JSON.parse(res.stdout);
+  assert.equal(parsed.ok, true, `expected ok=true JSON output\n${res.stdout}`);
+  assert.equal(parsed.branch, 'slopus/pr/broken-worktree', 'expected branch name to be preserved');
+
+  const archivedDir = join(componentsDir, '.worktrees-archive', date, 'happy', 'slopus', 'pr', 'broken-worktree');
+  const gitStat = await stat(join(archivedDir, '.git'));
+  assert.ok(gitStat.isDirectory(), 'expected archived .git to be a directory (detached repo)');
+
+  const afterStatus = await runOk('git', ['status', '--porcelain'], { cwd: archivedDir, env: baseEnv });
+  assert.ok(afterStatus.stdout.includes(' M README.md'), `expected modified file preserved\n${afterStatus.stdout}`);
+  assert.ok(afterStatus.stdout.includes('?? untracked.txt'), `expected untracked file preserved\n${afterStatus.stdout}`);
+});

package/scripts/worktrees_cursor_monorepo_root.test.mjs

@@ -0,0 +1,63 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+function runNode(args, { cwd, env }) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(process.execPath, args, { cwd, env, stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+    proc.stdout.on('data', (d) => (stdout += String(d)));
+    proc.stderr.on('data', (d) => (stderr += String(d)));
+    proc.on('error', reject);
+    proc.on('exit', (code) => resolve({ code: code ?? 0, stdout, stderr }));
+  });
+}
+
+test('happys wt cursor opens the monorepo root (not a subpackage dir) in monorepo worktrees', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-wt-cursor-mono-'));
+
+  const workspaceDir = join(tmp, 'workspace');
+  const homeDir = join(tmp, 'home');
+  const sandboxDir = join(tmp, 'sandbox');
+
+  const monoRoot = join(workspaceDir, 'components', '.worktrees', 'happy', 'slopus', 'tmp', 'mono-wt');
+  await mkdir(join(monoRoot, 'expo-app'), { recursive: true });
+  await mkdir(join(monoRoot, 'cli'), { recursive: true });
+  await mkdir(join(monoRoot, 'server'), { recursive: true });
+  await writeFile(join(monoRoot, '.git'), 'gitdir: dummy\n', 'utf-8');
+  await writeFile(join(monoRoot, 'expo-app', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(monoRoot, 'cli', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(monoRoot, 'server', 'package.json'), '{}\n', 'utf-8');
+
+  const env = {
+    ...process.env,
+    HAPPY_STACKS_HOME_DIR: homeDir,
+    HAPPY_STACKS_WORKSPACE_DIR: workspaceDir,
+    HAPPY_STACKS_SANDBOX_DIR: sandboxDir,
+  };
+
+  const resHappy = await runNode(
+    [join(rootDir, 'scripts', 'worktrees.mjs'), 'cursor', 'happy', 'slopus/tmp/mono-wt', '--json'],
+    { cwd: rootDir, env }
+  );
+  assert.equal(resHappy.code, 0, `expected exit 0, got ${resHappy.code}\nstdout:\n${resHappy.stdout}\nstderr:\n${resHappy.stderr}`);
+  const parsedHappy = JSON.parse(resHappy.stdout);
+  assert.equal(parsedHappy.dir, monoRoot);
+
+  const resCli = await runNode(
+    [join(rootDir, 'scripts', 'worktrees.mjs'), 'cursor', 'happy-cli', 'slopus/tmp/mono-wt', '--json'],
+    { cwd: rootDir, env }
+  );
+  assert.equal(resCli.code, 0, `expected exit 0, got ${resCli.code}\nstdout:\n${resCli.stdout}\nstderr:\n${resCli.stderr}`);
+  const parsedCli = JSON.parse(resCli.stdout);
+  assert.equal(parsedCli.dir, monoRoot);
+
+  await rm(tmp, { recursive: true, force: true });
+});

package/scripts/worktrees_list_specs_no_recurse.test.mjs

@@ -0,0 +1,33 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { listWorktreeSpecs } from './utils/git/worktrees.mjs';
+
+test('listWorktreeSpecs does not recurse into worktree roots', async () => {
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-list-wt-specs-'));
+  try {
+    const workspaceDir = join(tmp, 'workspace');
+    const env = { ...process.env, HAPPY_STACKS_WORKSPACE_DIR: workspaceDir };
+    const rootDir = tmp;
+
+    const wtRoot = join(workspaceDir, 'components', '.worktrees', 'happy', 'slopus', 'tmp', 'mono-wt');
+    await mkdir(wtRoot, { recursive: true });
+    await writeFile(join(wtRoot, '.git'), 'gitdir: dummy\n', 'utf-8');
+
+    // If listWorktreeSpecs incorrectly recurses into worktree roots, it would discover this nested ".git"
+    // and return an extra spec.
+    const nested = join(wtRoot, 'nested');
+    await mkdir(nested, { recursive: true });
+    await writeFile(join(nested, '.git'), 'gitdir: dummy\n', 'utf-8');
+
+    const specs = await listWorktreeSpecs({ rootDir, component: 'happy', env });
+    assert.ok(specs.includes('slopus/tmp/mono-wt'), specs.join('\n'));
+    assert.ok(!specs.includes('slopus/tmp/mono-wt/nested'), specs.join('\n'));
+  } finally {
+    await rm(tmp, { recursive: true, force: true });
+  }
+});
+

package/scripts/worktrees_monorepo_use_group.test.mjs

@@ -0,0 +1,67 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+function runNode(args, { cwd, env }) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(process.execPath, args, { cwd, env, stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+    proc.stdout.on('data', (d) => (stdout += String(d)));
+    proc.stderr.on('data', (d) => (stderr += String(d)));
+    proc.on('error', reject);
+    proc.on('exit', (code) => resolve({ code: code ?? 0, stdout, stderr }));
+  });
+}
+
+test('happys wt use switches all monorepo group components when target is a monorepo worktree', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-wt-use-mono-'));
+
+  const workspaceDir = join(tmp, 'workspace');
+  const homeDir = join(tmp, 'home');
+  const sandboxDir = join(tmp, 'sandbox');
+  const envFile = join(tmp, 'env');
+
+  const monoRoot = join(workspaceDir, 'components', '.worktrees', 'happy', 'slopus', 'tmp', 'mono-wt');
+  await mkdir(join(monoRoot, 'expo-app'), { recursive: true });
+  await mkdir(join(monoRoot, 'cli'), { recursive: true });
+  await mkdir(join(monoRoot, 'server'), { recursive: true });
+  await writeFile(join(monoRoot, '.git'), 'gitdir: dummy\n', 'utf-8');
+  await writeFile(join(monoRoot, 'expo-app', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(monoRoot, 'cli', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(monoRoot, 'server', 'package.json'), '{}\n', 'utf-8');
+
+  await writeFile(envFile, '', 'utf-8');
+
+  const env = {
+    ...process.env,
+    HAPPY_STACKS_STACK: 'exp',
+    HAPPY_LOCAL_STACK: 'exp',
+    HAPPY_STACKS_HOME_DIR: homeDir,
+    HAPPY_STACKS_WORKSPACE_DIR: workspaceDir,
+    HAPPY_STACKS_SANDBOX_DIR: sandboxDir,
+    HAPPY_STACKS_ENV_FILE: envFile,
+  };
+
+  const res = await runNode(
+    [join(rootDir, 'scripts', 'worktrees.mjs'), 'use', 'happy', 'slopus/tmp/mono-wt', '--force', '--json'],
+    { cwd: rootDir, env }
+  );
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+
+  const parsed = JSON.parse(res.stdout);
+  assert.deepEqual(parsed.updatedComponents, ['happy', 'happy-cli', 'happy-server']);
+
+  const contents = await readFile(envFile, 'utf-8');
+  assert.ok(contents.includes(`HAPPY_STACKS_COMPONENT_DIR_HAPPY=${monoRoot}\n`), contents);
+  assert.ok(contents.includes(`HAPPY_STACKS_COMPONENT_DIR_HAPPY_CLI=${monoRoot}\n`), contents);
+  assert.ok(contents.includes(`HAPPY_STACKS_COMPONENT_DIR_HAPPY_SERVER=${monoRoot}\n`), contents);
+
+  await rm(tmp, { recursive: true, force: true });
+});