@happier-dev/stack 0.1.0-preview.74.1

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

@@ -0,0 +1,49 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile, rm, stat, utimes, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { ensureEnvFilePruned, ensureEnvFileUpdated } from './env_file.mjs';
+
+async function withTempRoot(t) {
+  const dir = await mkdtemp(join(tmpdir(), 'happy-stacks-env-file-'));
+  t.after(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+  return dir;
+}
+
+test('ensureEnvFileUpdated appends new key and ensures trailing newline', async (t) => {
+  const dir = await withTempRoot(t);
+  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 (t) => {
+  const dir = await withTempRoot(t);
+  const envPath = join(dir, 'env');
+
+  await writeFile(envPath, 'FOO=bar\n', 'utf-8');
+  const oldTime = new Date('2001-01-01T00:00:00.000Z');
+  await utimes(envPath, oldTime, oldTime);
+  const before = await stat(envPath);
+
+  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 (t) => {
+  const dir = await withTempRoot(t);
+  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');
+});

package/scripts/utils/env/env_local.mjs

@@ -0,0 +1,25 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { ensureEnvFileUpdated } from './env_file.mjs';
+import { ensureUserConfigEnvUpdated, getHomeEnvLocalPath, getHomeEnvPath } from './config.mjs';
+
+export async function ensureEnvLocalUpdated({ rootDir, updates }) {
+  // Behavior:
+  // - If a stack env file is explicitly set, write there (stack-scoped).
+  // - If the user has run `hstack init` (home config exists), write to the main stack env file (user config).
+  // - If no home config exists (legacy cloned-repo usage), write to <repo>/env.local for repo-local behavior.
+  const explicit = (process.env.HAPPIER_STACK_ENV_FILE ?? '').trim();
+  if (explicit) {
+    await ensureEnvFileUpdated({ envPath: explicit, updates });
+    return;
+  }
+
+  const hasHomeConfig = existsSync(getHomeEnvPath()) || existsSync(getHomeEnvLocalPath());
+  if (hasHomeConfig) {
+    await ensureUserConfigEnvUpdated({ cliRootDir: rootDir, updates });
+    return;
+  }
+
+  await ensureEnvFileUpdated({ envPath: join(rootDir, 'env.local'), updates });
+}

package/scripts/utils/env/load_env_file.mjs

@@ -0,0 +1,34 @@
+import { readFile } from 'node:fs/promises';
+import { parseDotenv } from './dotenv.mjs';
+
+export async function loadEnvFile(path, { override = false, overridePrefix = null } = {}) {
+  try {
+    const contents = await readFile(path, 'utf-8');
+    const parsed = parseDotenv(contents);
+    for (const [k, v] of parsed.entries()) {
+      const allowOverride = override && (!overridePrefix || k.startsWith(overridePrefix));
+      if (allowOverride || process.env[k] == null || process.env[k] === '') {
+        process.env[k] = v;
+      }
+    }
+  } catch {
+    // ignore missing/invalid env file
+  }
+}
+
+export async function loadEnvFileIgnoringPrefixes(path, { ignorePrefixes = [] } = {}) {
+  try {
+    const contents = await readFile(path, 'utf-8');
+    const parsed = parseDotenv(contents);
+    for (const [k, v] of parsed.entries()) {
+      if (ignorePrefixes.some((p) => k.startsWith(p))) {
+        continue;
+      }
+      if (process.env[k] == null || process.env[k] === '') {
+        process.env[k] = v;
+      }
+    }
+  } catch {
+    // ignore missing/invalid env file
+  }
+}

package/scripts/utils/env/read.mjs

@@ -0,0 +1,30 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+
+import { parseDotenv } from './dotenv.mjs';
+
+export async function readEnvValueFromFile(envPath, key, { defaultValue = '' } = {}) {
+  try {
+    const p = String(envPath ?? '').trim();
+    const k = String(key ?? '').trim();
+    if (!p || !k) return defaultValue;
+    if (!existsSync(p)) return defaultValue;
+    const raw = await readFile(p, 'utf-8');
+    const parsed = parseDotenv(raw ?? '');
+    return String(parsed.get(k) ?? '').trim();
+  } catch {
+    return defaultValue;
+  }
+}
+
+export async function readEnvObjectFromFile(envPath) {
+  try {
+    const p = String(envPath ?? '').trim();
+    if (!p || !existsSync(p)) return {};
+    const raw = await readFile(p, 'utf-8');
+    return Object.fromEntries(parseDotenv(raw ?? '').entries());
+  } catch {
+    return {};
+  }
+}
+

package/scripts/utils/env/sandbox.mjs

@@ -0,0 +1,13 @@
+export function getSandboxDir() {
+  const v = (process.env.HAPPIER_STACK_SANDBOX_DIR ?? '').trim();
+  return v || '';
+}
+
+export function isSandboxed() {
+  return Boolean(getSandboxDir());
+}
+
+export function sandboxAllowsGlobalSideEffects() {
+  const raw = (process.env.HAPPIER_STACK_SANDBOX_ALLOW_GLOBAL ?? '').trim().toLowerCase();
+  return raw === '1' || raw === 'true' || raw === 'yes' || raw === 'y';
+}

package/scripts/utils/env/scrub_env.mjs

@@ -0,0 +1,69 @@
+export const SANDBOX_PRESERVE_KEYS = [
+  'HAPPIER_STACK_VERBOSE',
+  'HAPPIER_STACK_INVOKED_CWD',
+  'HAPPIER_STACK_SANDBOX_DIR',
+  'HAPPIER_STACK_SANDBOX_ALLOW_GLOBAL',
+  'HAPPIER_STACK_UPDATE_CHECK',
+  'HAPPIER_STACK_UPDATE_CHECK_INTERVAL_MS',
+  'HAPPIER_STACK_UPDATE_NOTIFY_INTERVAL_MS',
+];
+
+export const STACK_WRAPPER_PRESERVE_KEYS = [
+  // Stack/env pointers:
+  'HAPPIER_STACK_ENV_FILE',
+  'HAPPIER_STACK_STACK',
+
+  // Sandbox detection + policy.
+  'HAPPIER_STACK_SANDBOX_DIR',
+  'HAPPIER_STACK_SANDBOX_ALLOW_GLOBAL',
+
+  // Sandbox-enforced dirs.
+  'HAPPIER_STACK_CLI_ROOT_DISABLE',
+  'HAPPIER_STACK_CANONICAL_HOME_DIR',
+  'HAPPIER_STACK_HOME_DIR',
+  'HAPPIER_STACK_WORKSPACE_DIR',
+  'HAPPIER_STACK_RUNTIME_DIR',
+  'HAPPIER_STACK_STORAGE_DIR',
+
+  // UX knobs.
+  'HAPPIER_STACK_VERBOSE',
+  // TUI marker (set by `hstack tui` and must survive stack env scrubbing).
+  'HAPPIER_STACK_TUI',
+  'HAPPIER_STACK_UPDATE_CHECK',
+  'HAPPIER_STACK_UPDATE_CHECK_INTERVAL_MS',
+  'HAPPIER_STACK_UPDATE_NOTIFY_INTERVAL_MS',
+
+  // Guided auth flow coordination across wrappers.
+  'HAPPIER_STACK_DAEMON_WAIT_FOR_AUTH',
+  'HAPPIER_STACK_AUTH_FLOW',
+
+  // Safe global defaults.
+  'HAPPIER_STACK_STACK_PORT_START',
+
+  'HAPPIER_STACK_BIND_MODE',
+  'HAPPIER_STACK_EXPO_HOST',
+
+  // Expo dev-server port strategy.
+  'HAPPIER_STACK_EXPO_DEV_PORT',
+  'HAPPIER_STACK_EXPO_DEV_PORT_STRATEGY',
+  'HAPPIER_STACK_EXPO_DEV_PORT_BASE',
+  'HAPPIER_STACK_EXPO_DEV_PORT_RANGE',
+];
+
+export function scrubHappierStackEnv(
+  env,
+  { keepHappierStackKeys = [], clearUnprefixedKeys = [] } = {},
+) {
+  const input = env && typeof env === 'object' ? env : {};
+  const out = { ...input };
+  const keep = new Set((keepHappierStackKeys ?? []).map((k) => String(k).trim()).filter(Boolean));
+  for (const k of Object.keys(out)) {
+    if (k.startsWith('HAPPIER_STACK_') && !keep.has(k)) {
+      delete out[k];
+    }
+  }
+  for (const k of (clearUnprefixedKeys ?? []).map((x) => String(x).trim()).filter(Boolean)) {
+    delete out[k];
+  }
+  return out;
+}

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

@@ -0,0 +1,102 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  SANDBOX_PRESERVE_KEYS,
+  STACK_WRAPPER_PRESERVE_KEYS,
+  scrubHappierStackEnv,
+} from './scrub_env.mjs';
+
+test('scrubHappierStackEnv removes non-preserved HAPPIER_STACK_* vars and clears selected unprefixed keys', () => {
+  const env = {
+    PATH: '/bin',
+    HAPPIER_STACK_VERBOSE: '1',
+    HAPPIER_STACK_FOO: 'bar',
+    HAPPIER_HOME_DIR: '/tmp/happier-home',
+    HAPPIER_SERVER_URL: 'http://example.com',
+  };
+
+  const scrubbed = scrubHappierStackEnv(env, {
+    keepHappierStackKeys: SANDBOX_PRESERVE_KEYS,
+    clearUnprefixedKeys: ['HAPPIER_HOME_DIR', 'HAPPIER_SERVER_URL'],
+  });
+
+  assert.equal(scrubbed.PATH, '/bin');
+  assert.equal(scrubbed.HAPPIER_STACK_VERBOSE, '1');
+  assert.equal(scrubbed.HAPPIER_STACK_FOO, undefined);
+  assert.equal(scrubbed.HAPPIER_HOME_DIR, undefined);
+  assert.equal(scrubbed.HAPPIER_SERVER_URL, undefined);
+});
+
+test('scrubHappierStackEnv keeps runtime-critical non-HAPPIER env keys', () => {
+  const env = {
+    PATH: '/bin:/usr/bin',
+    HOME: '/tmp/home',
+    TMPDIR: '/tmp',
+    SHELL: '/bin/zsh',
+    HAPPIER_STACK_SECRET: 'drop-me',
+  };
+
+  const scrubbed = scrubHappierStackEnv(env, {
+    keepHappierStackKeys: [],
+    clearUnprefixedKeys: [],
+  });
+
+  assert.equal(scrubbed.PATH, '/bin:/usr/bin');
+  assert.equal(scrubbed.HOME, '/tmp/home');
+  assert.equal(scrubbed.TMPDIR, '/tmp');
+  assert.equal(scrubbed.SHELL, '/bin/zsh');
+  assert.equal(scrubbed.HAPPIER_STACK_SECRET, undefined);
+});
+
+test('scrubHappierStackEnv preserves only explicitly kept HAPPIER_STACK keys', () => {
+  const env = {
+    HAPPIER_STACK_VERBOSE: '1',
+    HAPPIER_STACK_SANDBOX_DIR: '/tmp/sandbox',
+    HAPPIER_STACK_SECRET: 'drop-me',
+  };
+  const scrubbed = scrubHappierStackEnv(env, {
+    keepHappierStackKeys: [' HAPPIER_STACK_SANDBOX_DIR ', ''],
+    clearUnprefixedKeys: [],
+  });
+
+  assert.equal(scrubbed.HAPPIER_STACK_SANDBOX_DIR, '/tmp/sandbox');
+  assert.equal(scrubbed.HAPPIER_STACK_VERBOSE, undefined);
+  assert.equal(scrubbed.HAPPIER_STACK_SECRET, undefined);
+});
+
+test('scrubHappierStackEnv trims and de-duplicates clearUnprefixedKeys', () => {
+  const env = {
+    PATH: '/bin',
+    HAPPIER_HOME_DIR: '/tmp/home',
+    HAPPIER_SERVER_URL: 'http://localhost:3000',
+    HAPPIER_STACK_KEEP: 'keep',
+  };
+  const scrubbed = scrubHappierStackEnv(env, {
+    keepHappierStackKeys: ['HAPPIER_STACK_KEEP'],
+    clearUnprefixedKeys: [' HAPPIER_HOME_DIR ', 'HAPPIER_SERVER_URL', 'HAPPIER_SERVER_URL'],
+  });
+
+  assert.equal(scrubbed.PATH, '/bin');
+  assert.equal(scrubbed.HAPPIER_HOME_DIR, undefined);
+  assert.equal(scrubbed.HAPPIER_SERVER_URL, undefined);
+  assert.equal(scrubbed.HAPPIER_STACK_KEEP, 'keep');
+});
+
+test('scrubHappierStackEnv preserves HAPPIER_STACK_TUI in stack wrapper mode', () => {
+  const env = {
+    PATH: '/bin',
+    HAPPIER_STACK_TUI: '1',
+    HAPPIER_STACK_VERBOSE: '1',
+    HAPPIER_STACK_SECRET: 'drop-me',
+  };
+  const scrubbed = scrubHappierStackEnv(env, {
+    keepHappierStackKeys: STACK_WRAPPER_PRESERVE_KEYS,
+    clearUnprefixedKeys: [],
+  });
+
+  assert.equal(scrubbed.PATH, '/bin');
+  assert.equal(scrubbed.HAPPIER_STACK_TUI, '1');
+  assert.equal(scrubbed.HAPPIER_STACK_VERBOSE, '1');
+  assert.equal(scrubbed.HAPPIER_STACK_SECRET, undefined);
+});

package/scripts/utils/env/values.mjs

@@ -0,0 +1,13 @@
+export function getEnvValue(obj, key) {
+  const v = (obj?.[key] ?? '').toString().trim();
+  return v || '';
+}
+
+export function getEnvValueAny(obj, keys) {
+  for (const k of keys) {
+    const v = getEnvValue(obj, k);
+    if (v) return v;
+  }
+  return '';
+}
+

package/scripts/utils/expo/command.mjs

@@ -0,0 +1,65 @@
+import { join } from 'node:path';
+
+import { ensureDepsInstalled } from '../proc/pm.mjs';
+import { run } from '../proc/proc.mjs';
+import { spawnProc } from '../proc/proc.mjs';
+import { ensureExpoIsolationEnv, getExpoStatePaths, wantsExpoClearCache } from './expo.mjs';
+
+export async function prepareExpoCommandEnv({
+  baseDir,
+  kind,
+  projectDir,
+  baseEnv,
+  stateFileName,
+}) {
+  const env = { ...(baseEnv ?? process.env) };
+  const paths = getExpoStatePaths({ baseDir, kind, projectDir, stateFileName });
+  await ensureExpoIsolationEnv({ env, stateDir: paths.stateDir, expoHomeDir: paths.expoHomeDir, tmpDir: paths.tmpDir });
+  return { env, paths };
+}
+
+export function maybeAddExpoClear({ args, env }) {
+  const next = [...(args ?? [])];
+  if (wantsExpoClearCache({ env: env ?? process.env })) {
+    // Expo supports `--clear` for start, and `-c` for export.
+    // Callers should pass the right flag for their subcommand; we only add when missing.
+    if (!next.includes('--clear') && !next.includes('-c')) {
+      // Prefer `--clear` as a safe default; callers can override per-command.
+      next.push('--clear');
+    }
+  }
+  return next;
+}
+
+export async function expoExec({
+  dir,
+  projectDir,
+  args,
+  env,
+  ensureDepsLabel = 'happy',
+  quiet = false,
+}) {
+  const runnerDir = dir;
+  const cwd = projectDir ?? runnerDir;
+  await ensureDepsInstalled(runnerDir, ensureDepsLabel, { quiet, env });
+  const expoBin = join(runnerDir, 'node_modules', '.bin', 'expo');
+  await run(expoBin, args, { cwd, env, stdio: quiet ? 'ignore' : 'inherit' });
+}
+
+export async function expoSpawn({
+  label,
+  dir,
+  projectDir,
+  args,
+  env,
+  ensureDepsLabel = 'happy',
+  quiet = false,
+  options,
+}) {
+  const runnerDir = dir;
+  const cwd = projectDir ?? runnerDir;
+  await ensureDepsInstalled(runnerDir, ensureDepsLabel, { quiet, env });
+  const expoBin = join(runnerDir, 'node_modules', '.bin', 'expo');
+  return spawnProc(label, expoBin, args, env, { cwd, ...(options ?? {}) });
+}
+

package/scripts/utils/expo/expo.mjs

@@ -0,0 +1,139 @@
+import { createHash } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+import { isPidAlive } from '../proc/pids.mjs';
+import { isTcpPortFree } from '../net/ports.mjs';
+
+export { isPidAlive };
+
+function resolveMetroStatusTimeoutMsFromEnv(env = process.env) {
+  const raw = (env.HAPPIER_STACK_EXPO_METRO_STATUS_TIMEOUT_MS ?? '').toString().trim();
+  const n = raw ? Number(raw) : null;
+  if (Number.isFinite(n) && n > 0) return n;
+  return 800;
+}
+
+export async function looksLikeExpoMetro({ port, timeoutMs = null } = {}) {
+  const p = Number(port);
+  if (!Number.isFinite(p) || p <= 0) return false;
+  const ms = Number.isFinite(Number(timeoutMs)) && Number(timeoutMs) > 0 ? Number(timeoutMs) : resolveMetroStatusTimeoutMsFromEnv();
+  const url = `http://127.0.0.1:${p}/status`;
+  try {
+    const controller = typeof AbortController !== 'undefined' ? new AbortController() : null;
+    const timeout = setTimeout(() => controller?.abort(), ms);
+    try {
+      const res = await fetch(url, { signal: controller?.signal });
+      const txt = await res.text().catch(() => '');
+      return res.ok && String(txt).toLowerCase().includes('packager-status:running');
+    } finally {
+      clearTimeout(timeout);
+    }
+  } catch {
+    return false;
+  }
+}
+
+function hashDir(dir) {
+  return createHash('sha1').update(String(dir ?? '')).digest('hex').slice(0, 12);
+}
+
+export function getExpoStatePaths({ baseDir, kind, projectDir, stateFileName = 'expo.state.json' }) {
+  const key = hashDir(projectDir);
+  const stateDir = join(baseDir, kind, key);
+  return {
+    key,
+    stateDir,
+    statePath: join(stateDir, stateFileName),
+    expoHomeDir: join(stateDir, 'expo-home'),
+    tmpDir: join(stateDir, 'tmp'),
+  };
+}
+
+export async function ensureExpoIsolationEnv({ env, stateDir, expoHomeDir, tmpDir }) {
+  await mkdir(stateDir, { recursive: true });
+  await mkdir(expoHomeDir, { recursive: true });
+  await mkdir(tmpDir, { recursive: true });
+
+  // Expo CLI uses this to override ~/.expo.
+  // Always override: stack/worktree isolation must not fall back to the user's global ~/.expo.
+  env.__UNSAFE_EXPO_HOME_DIRECTORY = expoHomeDir;
+
+  // Metro default cache root is `path.join(os.tmpdir(), 'metro-cache')`, so TMPDIR isolates it.
+  // Always override: macOS sets TMPDIR by default, so a "set-if-missing" guard would not isolate Metro.
+  env.TMPDIR = tmpDir;
+}
+
+export function wantsExpoClearCache({ env }) {
+  const raw = (env.HAPPIER_STACK_EXPO_CLEAR_CACHE ?? '').trim();
+  if (raw) {
+    return raw !== '0';
+  }
+  // Default: clear cache when non-interactive (LLMs/services), keep fast iteration in TTY shells.
+  return !(process.stdin.isTTY && process.stdout.isTTY);
+}
+
+export async function readPidState(statePath) {
+  try {
+    if (!existsSync(statePath)) return null;
+    const raw = await readFile(statePath, 'utf-8');
+    const state = JSON.parse(raw);
+    const pid = Number(state?.pid);
+    if (!Number.isFinite(pid) || pid <= 0) return null;
+    return state;
+  } catch {
+    return null;
+  }
+}
+
+export async function isStateProcessRunning(statePath) {
+  const state = await readPidState(statePath);
+  if (!state) return { running: false, state: null };
+  const pid = Number(state.pid);
+  if (isPidAlive(pid)) {
+    return { running: true, state, reason: 'pid' };
+  }
+
+  // Expo/Metro can sometimes be “up” even if the original wrapper pid exited (pm/yarn layers).
+  // If we have a port and something is listening on it, treat it as running only if it looks like Metro.
+  const port = Number(state?.port);
+  if (Number.isFinite(port) && port > 0) {
+    try {
+      const free = await isTcpPortFree(port, { host: '127.0.0.1' });
+      if (!free) {
+        const ok = await looksLikeExpoMetro({ port });
+        if (ok) {
+          return { running: true, state, reason: 'port' };
+        }
+        return { running: false, state };
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  return { running: false, state };
+}
+
+export async function writePidState(statePath, state) {
+  await mkdir(dirname(statePath), { recursive: true }).catch(() => {});
+  await writeFile(statePath, JSON.stringify(state, null, 2) + '\n', 'utf-8');
+}
+
+export async function killPid(pid) {
+  const n = Number(pid);
+  if (!Number.isFinite(n) || n <= 1) return;
+  try {
+    process.kill(n, 'SIGTERM');
+  } catch {
+    return;
+  }
+  await delay(500);
+  try {
+    process.kill(n, 0);
+    process.kill(n, 'SIGKILL');
+  } catch {
+    // exited
+  }
+}

package/scripts/utils/expo/expo_state_running.test.mjs

@@ -0,0 +1,48 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import http from 'node:http';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { isStateProcessRunning } from './expo.mjs';
+
+function listen(server) {
+  return new Promise((resolve, reject) => {
+    server.on('error', reject);
+    server.listen(0, '127.0.0.1', () => resolve());
+  });
+}
+
+function close(server) {
+  return new Promise((resolve) => server.close(() => resolve()));
+}
+
+test('isStateProcessRunning does not treat occupied port as running when /status is not Metro', async () => {
+  const tmp = await mkdtemp(join(tmpdir(), 'hstack-expo-state-running-'));
+  const srv = http.createServer((req, res) => {
+    if (req.url === '/status') {
+      res.writeHead(200, { 'content-type': 'text/plain' });
+      res.end('not-metro');
+      return;
+    }
+    res.writeHead(200, { 'content-type': 'text/plain' });
+    res.end('ok');
+  });
+  try {
+    await listen(srv);
+    const addr = srv.address();
+    assert.ok(addr && typeof addr === 'object' && typeof addr.port === 'number', 'expected server to be listening');
+    const port = addr.port;
+
+    const statePath = join(tmp, 'expo.state.json');
+    await writeFile(statePath, JSON.stringify({ pid: 999999, port }, null, 2) + '\n', 'utf-8');
+
+    const res = await isStateProcessRunning(statePath);
+    assert.equal(res.running, false);
+  } finally {
+    await close(srv).catch(() => {});
+    await rm(tmp, { recursive: true, force: true });
+  }
+});
+