happy-stacks 0.4.0 → 0.5.0

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

@@ -0,0 +1,60 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { promptWorktreeSource } from './wizard.mjs';
+
+test('promptWorktreeSource does not list worktrees unless user selects "pick"', async () => {
+  let listed = 0;
+  const listWorktreeSpecs = async () => {
+    listed++;
+    return ['slopus/pr/123'];
+  };
+
+  const promptSelect = async () => 'default';
+  const prompt = async () => '';
+
+  const res = await promptWorktreeSource({
+    rl: {},
+    rootDir: '/tmp',
+    component: 'happy',
+    stackName: 'exp1',
+    createRemote: 'upstream',
+    deps: { listWorktreeSpecs, promptSelect, prompt },
+  });
+
+  assert.equal(res, 'default');
+  assert.equal(listed, 0);
+});
+
+test('promptWorktreeSource lists worktrees when user selects "pick"', async () => {
+  let listed = 0;
+  const listWorktreeSpecs = async () => {
+    listed++;
+    return ['slopus/pr/123', 'slopus/pr/456'];
+  };
+
+  let selectCount = 0;
+  const promptSelect = async (_rl, { title }) => {
+    selectCount++;
+    if (selectCount === 1) {
+      assert.ok(title.startsWith('Select '));
+      return 'pick';
+    }
+    assert.ok(title.startsWith('Available '));
+    return 'slopus/pr/456';
+  };
+  const prompt = async () => '';
+
+  const res = await promptWorktreeSource({
+    rl: {},
+    rootDir: '/tmp',
+    component: 'happy',
+    stackName: 'exp1',
+    createRemote: 'upstream',
+    deps: { listWorktreeSpecs, promptSelect, prompt },
+  });
+
+  assert.equal(res, 'slopus/pr/456');
+  assert.equal(listed, 1);
+});
+

package/scripts/utils/dev/daemon.mjs

@@ -124,7 +124,20 @@ export function watchHappyCliAndRestartDaemon({
       try {
         // eslint-disable-next-line no-console
         console.log('[local] watch: happy-cli changed → rebuilding + restarting daemon...');
-        await ensureCliBuilt(cliDir, { buildCli });
+        try {
+          await ensureCliBuilt(cliDir, { buildCli });
+        } catch (e) {
+          // IMPORTANT:
+          // - A rebuild can legitimately fail while an agent is mid-edit (e.g. TS errors).
+          // - In that case we must NOT restart the daemon (we'd just restart into a broken build),
+          //   and we must NOT crash the parent dev process. Keep watching for the next change.
+          const msg = e instanceof Error ? e.stack || e.message : String(e);
+          // eslint-disable-next-line no-console
+          console.error('[local] watch: happy-cli rebuild failed; keeping daemon running (will retry on next change).');
+          // eslint-disable-next-line no-console
+          console.error(msg);
+          return;
+        }
         const distEntrypoint = join(cliDir, 'dist', 'index.mjs');
         if (!existsSync(distEntrypoint)) {
           console.warn(

package/scripts/utils/dev/expo_dev.mjs

@@ -1,3 +1,7 @@
+import { fork } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import net from 'node:net';
 import {
   ensureExpoIsolationEnv,
   getExpoStatePaths,
@@ -11,6 +15,11 @@ import { killProcessGroupOwnedByStack } from '../proc/ownership.mjs';
 import { expoSpawn } from '../expo/command.mjs';
 import { resolveMobileExpoConfig } from '../mobile/config.mjs';
 import { resolveMobileReachableServerUrl } from '../server/mobile_api_url.mjs';
+import { getTailscaleStatus } from '../tailscale/ip.mjs';
+import { pickLanIpv4 } from '../net/lan_ip.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 
 function normalizeExpoHost(raw) {
   const v = String(raw ?? '').trim().toLowerCase();
@@ -18,6 +27,140 @@ function normalizeExpoHost(raw) {
   return 'lan';
 }
 
+/**
+ * Resolve whether Tailscale forwarding for Expo is enabled.
+ *
+ * Can be enabled via:
+ * - --expo-tailscale flag (passed as expoTailscale option)
+ * - HAPPY_STACKS_EXPO_TAILSCALE=1 env var
+ * - HAPPY_LOCAL_EXPO_TAILSCALE=1 env var (legacy)
+ */
+export function resolveExpoTailscaleEnabled({ env = process.env, expoTailscale = false } = {}) {
+  if (expoTailscale) return true;
+  const envVal = (env.HAPPY_STACKS_EXPO_TAILSCALE ?? env.HAPPY_LOCAL_EXPO_TAILSCALE ?? '').toString().trim();
+  return envVal === '1' || envVal.toLowerCase() === 'true';
+}
+
+/**
+ * Start a TCP forwarder process for Expo Tailscale access.
+ *
+ * Forwards from Tailscale IP:port to the LAN IP:port where Expo actually binds.
+ *
+ * @param {Object} options
+ * @param {number} options.metroPort - The Metro bundler port
+ * @param {Object} options.baseEnv - Base environment variables
+ * @param {string} options.stackName - Stack name for logging
+ * @param {Array} options.children - Array to track child processes
+ * @returns {Promise<{ ok: boolean, pid?: number, tailscaleIp?: string, lanIp?: string, error?: string }>}
+ */
+export async function startExpoTailscaleForwarder({ metroPort, baseEnv, stackName, children }) {
+  const ts = await getTailscaleStatus();
+  if (!ts.available || !ts.ip) {
+    // Common case: Tailscale app installed but toggle is off / not connected.
+    // This must never fail stack startup; just skip with a clear message.
+    return { ok: false, error: ts.error || 'Tailscale is not connected' };
+  }
+  const tailscaleIp = ts.ip;
+
+  // Some platforms / Tailscale variants report an IP but do not allow binding to it (EADDRNOTAVAIL).
+  // If we can't bind *at all*, don't spawn the forwarder process (it will just error noisily).
+  const canBind = await new Promise((resolve) => {
+    const srv = net.createServer();
+    const done = (ok, err) => {
+      try {
+        srv.close(() => resolve({ ok, err }));
+      } catch {
+        resolve({ ok, err });
+      }
+    };
+    srv.once('error', (err) => done(false, err));
+    srv.listen(0, tailscaleIp, () => done(true, null));
+  });
+  if (!canBind.ok) {
+    const code = canBind.err && typeof canBind.err === 'object' ? canBind.err.code : '';
+    const msg = canBind.err instanceof Error ? canBind.err.message : String(canBind.err ?? '');
+    const hint =
+      code === 'EADDRNOTAVAIL'
+        ? `Tailscale IP ${tailscaleIp} is not bindable on this machine (EADDRNOTAVAIL).`
+        : `Tailscale IP ${tailscaleIp} is not bindable (${code || 'error'}).`;
+    return { ok: false, error: `${hint}${msg ? ` ${msg}` : ''}`.trim() };
+  }
+
+  // Determine where Expo binds (LAN IP when host=lan, localhost otherwise)
+  const host = resolveExpoDevHost({ env: baseEnv });
+  let targetHost = '127.0.0.1';
+  if (host === 'lan') {
+    const lanIp = pickLanIpv4();
+    if (lanIp) targetHost = lanIp;
+  }
+
+  const label = `expo-ts-fwd${stackName ? `-${stackName}` : ''}`;
+  const forwarderScript = join(__dirname, '..', 'net', 'tcp_forward.mjs');
+
+  // Fork the forwarder as a child process
+  // Note: fork() requires 'ipc' in stdio array
+  const forwarderProc = fork(forwarderScript, [
+    `--listen-host=${tailscaleIp}`,
+    `--listen-port=${metroPort}`,
+    `--target-host=${targetHost}`,
+    `--target-port=${metroPort}`,
+    `--label=${label}`,
+  ], {
+    env: { ...baseEnv },
+    stdio: ['ignore', 'pipe', 'pipe', 'ipc'],
+    detached: process.platform !== 'win32',
+  });
+
+  // Prefix forwarder output
+  const outPrefix = `[${label}] `;
+  forwarderProc.stdout?.on('data', (d) => process.stdout.write(outPrefix + d.toString()));
+  forwarderProc.stderr?.on('data', (d) => process.stderr.write(outPrefix + d.toString()));
+
+  // Wait until the forwarder actually starts listening (or fails) before declaring success.
+  const ready = await new Promise((resolve) => {
+    const t = setTimeout(() => resolve({ ok: false, error: 'forwarder startup timed out' }), 2000);
+    const done = (res) => {
+      clearTimeout(t);
+      resolve(res);
+    };
+    forwarderProc.once('message', (m) => {
+      if (m && typeof m === 'object' && m.type === 'ready') {
+        done({ ok: true });
+      } else if (m && typeof m === 'object' && m.type === 'error') {
+        done({ ok: false, error: m.message ? String(m.message) : 'failed to start' });
+      }
+    });
+    forwarderProc.once('exit', (code, sig) => {
+      done({ ok: false, error: `exited (code=${code}, sig=${sig})` });
+    });
+    forwarderProc.once('error', (e) => {
+      done({ ok: false, error: e instanceof Error ? e.message : String(e) });
+    });
+  });
+
+  if (!ready.ok) {
+    try {
+      forwarderProc.kill('SIGKILL');
+    } catch {
+      // ignore
+    }
+    return { ok: false, error: ready.error || 'failed to start forwarder' };
+  }
+
+  children.push(forwarderProc);
+
+  // eslint-disable-next-line no-console
+  console.log(`[local] expo: Tailscale forwarder started (${tailscaleIp}:${metroPort} -> ${targetHost}:${metroPort})`);
+
+  return {
+    ok: true,
+    pid: forwarderProc.pid,
+    tailscaleIp,
+    lanIp: targetHost,
+    proc: forwarderProc,
+  };
+}
+
 export function resolveExpoDevHost({ env = process.env } = {}) {
   // Always prefer LAN by default so phones can reach Metro.
   const raw = (env.HAPPY_STACKS_EXPO_HOST ?? env.HAPPY_LOCAL_EXPO_HOST ?? '').toString();
@@ -76,6 +219,7 @@ export async function ensureDevExpoServer({
   envPath,
   children,
   spawnOptions = {},
+  expoTailscale = false,
 } = {}) {
   const wantWeb = Boolean(startUi);
   const wantDevClient = Boolean(startMobile);
@@ -144,13 +288,20 @@ export async function ensureDevExpoServer({
   const running = await isStateProcessRunning(paths.statePath);
   const alreadyRunning = Boolean(running.running);
 
+  // Resolve Tailscale forwarding preference
+  const wantTailscale = resolveExpoTailscaleEnabled({ env: baseEnv, expoTailscale });
+
   // Always publish runtime metadata when we can.
-  const publishRuntime = async ({ pid, port }) => {
+  const publishRuntime = async ({ pid, port, tailscaleForwarderPid = null, tailscaleIp = null }) => {
     if (!stackMode || !runtimeStatePath) return;
     const nPid = Number(pid);
     const nPort = Number(port);
+    const nTsPid = Number(tailscaleForwarderPid);
     await recordStackRuntimeUpdate(runtimeStatePath, {
-      processes: { expoPid: Number.isFinite(nPid) && nPid > 1 ? nPid : null },
+      processes: {
+        expoPid: Number.isFinite(nPid) && nPid > 1 ? nPid : null,
+        expoTailscaleForwarderPid: Number.isFinite(nTsPid) && nTsPid > 1 ? nTsPid : null,
+      },
       expo: {
         port: Number.isFinite(nPort) && nPort > 0 ? nPort : null,
         // For now keep these populated for callers that still expect webPort/mobilePort.
@@ -160,6 +311,8 @@ export async function ensureDevExpoServer({
         devClientEnabled: wantDevClient,
         host: resolveExpoDevHost({ env }),
         scheme: wantDevClient ? scheme : null,
+        tailscaleEnabled: wantTailscale,
+        tailscaleIp: tailscaleIp ?? null,
       },
     }).catch(() => {});
   };
@@ -224,7 +377,27 @@ export async function ensureDevExpoServer({
   const proc = await expoSpawn({ label: 'expo', dir: uiDir, args, env, options: spawnOptions });
   children.push(proc);
 
-  await publishRuntime({ pid: proc.pid, port: metroPort });
+  // Start Tailscale forwarder if enabled
+  let tailscaleResult = null;
+  if (wantTailscale) {
+    tailscaleResult = await startExpoTailscaleForwarder({
+      metroPort,
+      baseEnv,
+      stackName,
+      children,
+    });
+    if (!tailscaleResult.ok) {
+      // eslint-disable-next-line no-console
+      console.warn(`[local] expo: Tailscale forwarder not started: ${tailscaleResult.error}`);
+    }
+  }
+
+  await publishRuntime({
+    pid: proc.pid,
+    port: metroPort,
+    tailscaleForwarderPid: tailscaleResult?.pid ?? null,
+    tailscaleIp: tailscaleResult?.tailscaleIp ?? null,
+  });
 
   try {
     await writePidState(paths.statePath, {
@@ -236,11 +409,22 @@ export async function ensureDevExpoServer({
       devClientEnabled: wantDevClient,
       host,
       scheme: wantDevClient ? scheme : null,
+      tailscaleEnabled: wantTailscale,
+      tailscaleForwarderPid: tailscaleResult?.pid ?? null,
+      tailscaleIp: tailscaleResult?.tailscaleIp ?? null,
     });
   } catch {
     // ignore
   }
 
-  return { ok: true, skipped: false, pid: proc.pid, port: metroPort, proc, mode: expoModeLabel({ wantWeb, wantDevClient }) };
+  return {
+    ok: true,
+    skipped: false,
+    pid: proc.pid,
+    port: metroPort,
+    proc,
+    mode: expoModeLabel({ wantWeb, wantDevClient }),
+    tailscale: tailscaleResult ?? null,
+  };
 }
 

package/scripts/utils/dev/server.mjs

@@ -2,6 +2,7 @@ import { join, resolve } from 'node:path';
 
 import { ensureDepsInstalled, pmSpawnScript } from '../proc/pm.mjs';
 import { applyHappyServerMigrations, ensureHappyServerManagedInfra } from '../server/infra/happy_server_infra.mjs';
+import { resolveServerDevScript } from '../server/flavor_scripts.mjs';
 import { waitForServerReady } from '../server/server.mjs';
 import { isTcpPortFree, pickNextFreeTcpPort } from '../net/ports.mjs';
 import { readStackRuntimeStateFile, recordStackRuntimeUpdate } from '../stack/runtime_state.mjs';
@@ -87,12 +88,7 @@ export async function startDevServer({
   await ensureDepsInstalled(serverDir, serverComponentName);
 
   const prismaPush = (baseEnv.HAPPY_STACKS_PRISMA_PUSH ?? baseEnv.HAPPY_LOCAL_PRISMA_PUSH ?? '1').toString().trim() !== '0';
-  const serverScript =
-    serverComponentName === 'happy-server'
-      ? 'start'
-      : serverComponentName === 'happy-server-light' && !prismaPush
-        ? 'start'
-        : 'dev';
+  const serverScript = resolveServerDevScript({ serverComponentName, serverDir, prismaPush });
 
   // Restart behavior (stack-safe): only kill when we can prove ownership via runtime state.
   if (restart && stackMode && runtimeStatePath && serverAlreadyRunning) {
@@ -155,19 +151,27 @@ export function watchDevServerAndRestart({
       const pid = Number(serverProcRef?.current?.pid);
       if (!Number.isFinite(pid) || pid <= 1) return;
 
-      // eslint-disable-next-line no-console
-      console.log('[local] watch: server changed → restarting...');
-      await killProcessGroupOwnedByStack(pid, { stackName, envPath, label: 'server', json: false });
+      try {
+        // eslint-disable-next-line no-console
+        console.log('[local] watch: server changed → restarting...');
+        await killProcessGroupOwnedByStack(pid, { stackName, envPath, label: 'server', json: false });
 
-      const next = await pmSpawnScript({ label: 'server', dir: serverDir, script: serverScript, env: serverEnv });
-      children.push(next);
-      serverProcRef.current = next;
-      if (stackMode && runtimeStatePath) {
-        await recordStackRuntimeUpdate(runtimeStatePath, { processes: { serverPid: next.pid } }).catch(() => {});
+        const next = await pmSpawnScript({ label: 'server', dir: serverDir, script: serverScript, env: serverEnv });
+        children.push(next);
+        serverProcRef.current = next;
+        if (stackMode && runtimeStatePath) {
+          await recordStackRuntimeUpdate(runtimeStatePath, { processes: { serverPid: next.pid } }).catch(() => {});
+        }
+        await waitForServerReady(internalServerUrl);
+        // eslint-disable-next-line no-console
+        console.log(`[local] watch: server restarted (pid=${next.pid}, port=${serverPort})`);
+      } catch (e) {
+        const msg = e instanceof Error ? e.stack || e.message : String(e);
+        // eslint-disable-next-line no-console
+        console.error('[local] watch: server restart failed; keeping existing process as-is (will retry on next change).');
+        // eslint-disable-next-line no-console
+        console.error(msg);
       }
-      await waitForServerReady(internalServerUrl);
-      // eslint-disable-next-line no-console
-      console.log(`[local] watch: server restarted (pid=${next.pid}, port=${serverPort})`);
     },
   });
 }

package/scripts/utils/edison/git_roots.mjs

@@ -0,0 +1,29 @@
+import { dirname, join, resolve } from 'node:path';
+import { existsSync } from 'node:fs';
+
+export function findGitRootForPath(dir) {
+  let cur = resolve(String(dir ?? '').trim());
+  if (!cur) return '';
+  while (true) {
+    try {
+      if (existsSync(join(cur, '.git'))) {
+        return cur;
+      }
+    } catch {
+      // ignore
+    }
+    const parent = dirname(cur);
+    if (parent === cur) return '';
+    cur = parent;
+  }
+}
+
+export function normalizeGitRoots(paths) {
+  const list = Array.isArray(paths) ? paths : [];
+  const normalized = list
+    .map((d) => findGitRootForPath(d) || String(d ?? '').trim())
+    .map((d) => resolve(d))
+    .filter(Boolean);
+  return Array.from(new Set(normalized));
+}
+

package/scripts/utils/edison/git_roots.test.mjs

@@ -0,0 +1,36 @@
+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 { findGitRootForPath, normalizeGitRoots } from './git_roots.mjs';
+
+async function withTempRoot(t) {
+  const dir = await mkdtemp(join(tmpdir(), 'happy-stacks-edison-git-roots-'));
+  t.after(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+  return dir;
+}
+
+test('findGitRootForPath returns nearest ancestor containing .git marker', async (t) => {
+  const root = await withTempRoot(t);
+  const repoRoot = join(root, 'repo');
+  await mkdir(join(repoRoot, 'a', 'b'), { recursive: true });
+  await writeFile(join(repoRoot, '.git'), 'gitdir: /tmp/fake\n', 'utf-8');
+
+  assert.equal(findGitRootForPath(join(repoRoot, 'a', 'b')), repoRoot);
+});
+
+test('normalizeGitRoots de-duplicates multiple paths inside the same repo', async (t) => {
+  const root = await withTempRoot(t);
+  const repoRoot = join(root, 'repo');
+  await mkdir(join(repoRoot, 'expo-app'), { recursive: true });
+  await mkdir(join(repoRoot, 'cli'), { recursive: true });
+  await writeFile(join(repoRoot, '.git'), 'gitdir: /tmp/fake\n', 'utf-8');
+
+  const roots = normalizeGitRoots([join(repoRoot, 'expo-app'), join(repoRoot, 'cli')]);
+  assert.deepEqual(roots, [repoRoot]);
+});
+

package/scripts/utils/env/env.mjs

@@ -162,7 +162,12 @@ if (hasHomeConfig) {
   const stacksStorageRootRaw = (process.env.HAPPY_STACKS_STORAGE_DIR ?? process.env.HAPPY_LOCAL_STORAGE_DIR ?? '').trim();
   const stacksStorageRoot = stacksStorageRootRaw ? expandHome(stacksStorageRootRaw) : join(homedir(), '.happy', 'stacks');
   const allowLegacy = !isSandboxed() || sandboxAllowsGlobalSideEffects();
-  const legacyStacksRoot = allowLegacy ? join(homedir(), '.happy', 'local', 'stacks') : join(stacksStorageRoot, '__legacy_disabled__');
+  // If the user explicitly overrides the stacks storage root, do not auto-discover a legacy env file from the real home dir.
+  // This keeps isolated runs (tests, sandboxes, custom dirs) from accidentally loading a "real" machine stack env file.
+  const legacyStacksRoot =
+    allowLegacy && !stacksStorageRootRaw
+      ? join(homedir(), '.happy', 'local', 'stacks')
+      : join(stacksStorageRoot, '__legacy_disabled__');
 
   const candidates = [
     join(stacksStorageRoot, stackName, 'env'),
@@ -204,8 +209,7 @@ process.env.NPM_CONFIG_PACKAGE_MANAGER_STRICT = process.env.NPM_CONFIG_PACKAGE_M
   const delimiter = process.platform === 'win32' ? ';' : ':';
   const current = (process.env.PATH ?? '').split(delimiter).filter(Boolean);
   const nodeBinDir = dirname(process.execPath);
-  const want = [nodeBinDir, '/opt/homebrew/bin', '/opt/homebrew/sbin', '/usr/local/bin'];
+  const want = [nodeBinDir, '/opt/homebrew/bin', '/opt/homebrew/sbin', '/usr/local/bin', '/usr/bin', '/bin'];
   const next = [...want.filter((p) => p && !current.includes(p)), ...current];
   process.env.PATH = next.join(delimiter);
 })();
-

package/scripts/utils/env/env_file.mjs

@@ -7,7 +7,9 @@ export async function ensureEnvFileUpdated({ envPath, updates }) {
     return;
   }
   await mkdir(dirname(envPath), { recursive: true });
-  await writeFileIfChanged(envPath, applyEnvUpdates(await readText(envPath), updates), envPath);
+  const existing = await readText(envPath);
+  const next = applyEnvUpdates(existing, updates);
+  await writeFileIfChanged(existing, next, envPath);
 }
 
 export async function ensureEnvFilePruned({ envPath, removeKeys }) {
@@ -30,7 +32,7 @@ async function readText(path) {
 }
 
 function applyEnvUpdates(existing, updates) {
-  const lines = existing.split('\n');
+  const lines = existing ? existing.split('\n') : [];
   const next = [...lines];
 
   const upsert = (key, value) => {

package/scripts/utils/env/env_file.test.mjs

@@ -0,0 +1,44 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile, stat, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+
+import { ensureEnvFilePruned, ensureEnvFileUpdated } from './env_file.mjs';
+
+test('ensureEnvFileUpdated appends new key and ensures trailing newline', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'happy-stacks-env-file-'));
+  const envPath = join(dir, 'env');
+
+  await ensureEnvFileUpdated({ envPath, updates: [{ key: 'OPENAI_API_KEY', value: 'sk-test' }] });
+  const next = await readFile(envPath, 'utf-8');
+  assert.equal(next, 'OPENAI_API_KEY=sk-test\n');
+});
+
+test('ensureEnvFileUpdated does not touch file when no content changes', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'happy-stacks-env-file-'));
+  const envPath = join(dir, 'env');
+
+  await writeFile(envPath, 'FOO=bar\n', 'utf-8');
+  const before = await stat(envPath);
+
+  // Ensure filesystem mtime resolution won't hide unintended writes.
+  await delay(25);
+
+  await ensureEnvFileUpdated({ envPath, updates: [{ key: 'FOO', value: 'bar' }] });
+  const after = await stat(envPath);
+  assert.equal(after.mtimeMs, before.mtimeMs);
+});
+
+test('ensureEnvFilePruned removes a key but keeps comments/blank lines', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'happy-stacks-env-file-'));
+  const envPath = join(dir, 'env');
+
+  await writeFile(envPath, '# header\nFOO=bar\n\nBAZ=qux\n', 'utf-8');
+  await ensureEnvFilePruned({ envPath, removeKeys: ['FOO'] });
+
+  const next = await readFile(envPath, 'utf-8');
+  assert.equal(next, '# header\n\nBAZ=qux\n');
+});
+