@happier-dev/stack 0.1.0-preview.74.1

package/scripts/test_cmd.mjs

@@ -0,0 +1,274 @@
+import './utils/env/env.mjs';
+import { parseArgs } from './utils/cli/args.mjs';
+import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
+import { getComponentDir, getRootDir } from './utils/paths/paths.mjs';
+import { ensureDepsInstalled } from './utils/proc/pm.mjs';
+import { ensureHappyMonorepoNestedDepsInstalled } from './utils/proc/happy_monorepo_deps.mjs';
+import { pathExists } from './utils/fs/fs.mjs';
+import { run, runCapture } from './utils/proc/proc.mjs';
+import { detectPackageManagerCmd, pickFirstScript, readPackageJsonScripts } from './utils/proc/package_scripts.mjs';
+import { getInvokedCwd, inferComponentFromCwd } from './utils/cli/cwd_scope.mjs';
+import { readdir, readFile } from 'node:fs/promises';
+import { dirname, join, sep } from 'node:path';
+
+const EXTRA_COMPONENTS = ['stacks'];
+const VALID_TARGETS = ['ui', 'cli', 'server'];
+const VALID_COMPONENTS = [...VALID_TARGETS, ...EXTRA_COMPONENTS, 'all'];
+
+function targetFromComponentToken(component) {
+  const c = String(component ?? '').trim();
+  if (!c) return null;
+  if (c === 'ui' || c === 'cli' || c === 'server' || c === 'stacks' || c === 'all') return c;
+
+  // Modern (Happier) component ids:
+  if (c === 'happier-ui') return 'ui';
+  if (c === 'happier-cli') return 'cli';
+  if (c === 'happier-server' || c === 'happier-server-light') return 'server';
+
+  // Legacy (Happy) ids:
+  if (c === 'happy') return 'ui';
+  if (c === 'happy-cli') return 'cli';
+  if (c === 'happy-server' || c === 'happy-server-light') return 'server';
+
+  return null;
+}
+
+function componentFromTarget(target) {
+  const t = String(target ?? '').trim();
+  if (t === 'ui') return 'happier-ui';
+  if (t === 'cli') return 'happier-cli';
+  if (t === 'server') return 'happier-server';
+  return null;
+}
+
+function normalizeTargetsOrThrow(rawTargets) {
+  const requested = Array.isArray(rawTargets) ? rawTargets.map((t) => String(t ?? '').trim()).filter(Boolean) : [];
+  if (!requested.length) return ['all'];
+
+  const mapped = requested
+    .map((t) => {
+      const lower = t.toLowerCase();
+      return targetFromComponentToken(lower);
+    })
+    .filter(Boolean);
+
+  if (!mapped.length) return ['all'];
+  return mapped;
+}
+
+async function collectTestFiles(dir) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const files = [];
+  for (const e of entries) {
+    // Avoid dot-dirs and dot-files (e.g. .DS_Store).
+    if (e.name.startsWith('.')) continue;
+    const p = join(dir, e.name);
+    if (e.isDirectory()) {
+      files.push(...(await collectTestFiles(p)));
+      continue;
+    }
+    if (!e.isFile()) continue;
+    if (!e.name.endsWith('.test.mjs')) continue;
+    files.push(p);
+  }
+  files.sort();
+  return files;
+}
+
+function pickTestScript(scripts) {
+  const candidates = [
+    'test',
+    'tst',
+    'test:ci',
+    'test:unit',
+    'check:test',
+  ];
+  return pickFirstScript(scripts, candidates);
+}
+
+async function resolveTestDirForComponent({ component, dir }) {
+  // Monorepo mode:
+  // When the UI component dir resolves to a subdirectory (apps/ui, legacy expo-app, etc),
+  // we prefer running tests from the monorepo root scripts when available.
+  if (component !== 'happier-ui') return dir;
+
+  const abs = dir;
+  const isLegacyExpoApp = abs.endsWith(`${sep}expo-app`) || abs.endsWith('/expo-app');
+  const isAppsUi = abs.endsWith(`${sep}apps${sep}ui`) || abs.endsWith('/apps/ui');
+  const isLegacyPackagesApp = abs.endsWith(`${sep}packages${sep}app`) || abs.endsWith('/packages/app');
+  if (!isLegacyExpoApp && !isAppsUi && !isLegacyPackagesApp) return dir;
+
+  const parent = isAppsUi || isLegacyPackagesApp ? dirname(dirname(abs)) : dirname(abs);
+  try {
+    const scripts = await readPackageJsonScripts(parent);
+    if (!scripts) return dir;
+    if ((scripts?.test ?? '').toString().trim().length === 0) return dir;
+
+    // Only redirect when the parent is clearly intended as the monorepo root.
+    const pkg = JSON.parse(await readFile(join(parent, 'package.json'), 'utf-8'));
+    const name = String(pkg?.name ?? '').trim();
+    if (name !== 'monorepo') return dir;
+    return parent;
+  } catch {
+    return dir;
+  }
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  const { flags } = parseArgs(argv);
+  const json = wantsJson(argv, { flags });
+
+  if (wantsHelp(argv, { flags })) {
+    printResult({
+      json,
+      data: { components: VALID_COMPONENTS, flags: ['--json'] },
+      text: [
+        '[test] usage:',
+        '  hstack test [ui|cli|server|all|stacks] [--json]',
+        '',
+        'targets:',
+        `  ${VALID_COMPONENTS.join(' | ')}`,
+        '',
+        'examples:',
+        '  hstack test',
+        '  hstack test stacks',
+        '  hstack test ui cli',
+        '',
+        'note:',
+        '  If run from inside a repo checkout/worktree and no targets are provided, defaults to the inferred app (ui/cli/server).',
+      ].join('\n'),
+    });
+    return;
+  }
+
+  const rootDir = getRootDir(import.meta.url);
+
+  const positionals = argv.filter((a) => !a.startsWith('--'));
+  const inferred =
+    positionals.length === 0
+      ? inferComponentFromCwd({
+          rootDir,
+          invokedCwd: getInvokedCwd(process.env),
+          components: ['happier-ui', 'happier-cli', 'happier-server'],
+        })
+      : null;
+  if (inferred) {
+    if (!(process.env.HAPPIER_STACK_REPO_DIR ?? '').toString().trim()) {
+      process.env.HAPPIER_STACK_REPO_DIR = inferred.repoDir;
+    }
+  }
+
+  const inferredTarget = inferred ? targetFromComponentToken(inferred.component) : null;
+  const requested = normalizeTargetsOrThrow(positionals.length ? positionals : inferredTarget ? [inferredTarget] : ['all']);
+  const wantAll = requested.includes('all');
+  // Default `all` excludes "stacks" to avoid coupling to stack tests and their baselines.
+  const targets = wantAll ? VALID_TARGETS : requested;
+
+  const results = [];
+  for (const target of targets) {
+    if (!VALID_COMPONENTS.includes(target)) {
+      results.push({ target, ok: false, skipped: false, error: `unknown target (expected one of: ${VALID_COMPONENTS.join(', ')})` });
+      continue;
+    }
+
+    if (target === 'stacks') {
+      try {
+        // eslint-disable-next-line no-console
+        console.log('[test] stacks: running node --test (hstack unit tests)');
+        // Note: do not rely on shell glob expansion here.
+        // Node 20 does not expand globs for `--test`, and bash/sh won't expand globs inside quotes.
+        // Enumerate files ourselves so this works reliably in CI.
+        const scriptsDir = join(rootDir, 'scripts');
+        const testFiles = await collectTestFiles(scriptsDir);
+        if (testFiles.length === 0) {
+          throw new Error(`[test] stacks: no test files found under ${scriptsDir}`);
+        }
+        await run(process.execPath, ['--test', ...testFiles], { cwd: rootDir, env: process.env });
+        results.push({ target, ok: true, skipped: false, dir: rootDir, pm: 'node', script: '--test' });
+      } catch (e) {
+        results.push({ target, ok: false, skipped: false, dir: rootDir, pm: 'node', script: '--test', error: String(e?.message ?? e) });
+      }
+      continue;
+    }
+
+    const component = componentFromTarget(target);
+    const rawDir = getComponentDir(rootDir, component);
+    const dir = await resolveTestDirForComponent({ component, dir: rawDir });
+    if (!(await pathExists(dir))) {
+      results.push({ target, ok: false, skipped: false, dir, error: `missing target dir: ${dir}` });
+      continue;
+    }
+
+    const scripts = await readPackageJsonScripts(dir);
+    if (!scripts) {
+      results.push({ target, ok: true, skipped: true, dir, reason: 'no package.json' });
+      continue;
+    }
+
+    const script = pickTestScript(scripts);
+    if (!script) {
+      results.push({ target, ok: true, skipped: true, dir, reason: 'no test script found in package.json' });
+      continue;
+    }
+
+    if (target === 'ui') {
+      await ensureHappyMonorepoNestedDepsInstalled({
+        happyTestDir: dir,
+        quiet: json,
+        env: process.env,
+        ensureDepsInstalled,
+      });
+    }
+
+    await ensureDepsInstalled(dir, target, { quiet: json, env: process.env });
+    const pm = await detectPackageManagerCmd(dir);
+
+    try {
+      const line = `[test] ${target}: running ${pm.name} ${script}\n`;
+      if (json) {
+        process.stderr.write(line);
+        const out = await runCapture(pm.cmd, pm.argsForScript(script), { cwd: dir, env: process.env });
+        if (out) process.stderr.write(out);
+      } else {
+        // eslint-disable-next-line no-console
+        console.log(line.trimEnd());
+        await run(pm.cmd, pm.argsForScript(script), { cwd: dir, env: process.env });
+      }
+      results.push({ target, ok: true, skipped: false, dir, pm: pm.name, script });
+    } catch (e) {
+      results.push({ target, ok: false, skipped: false, dir, pm: pm.name, script, error: String(e?.message ?? e) });
+    }
+  }
+
+  const ok = results.every((r) => r.ok);
+  if (json) {
+    printResult({ json, data: { ok, results } });
+    return;
+  }
+
+  const lines = ['[test] results:'];
+  for (const r of results) {
+    if (r.ok && r.skipped) {
+      lines.push(`- ↪ ${r.target}: skipped (${r.reason})`);
+    } else if (r.ok) {
+      lines.push(`- ✅ ${r.target}: ok (${r.pm} ${r.script})`);
+    } else {
+      lines.push(`- ❌ ${r.target}: failed (${r.pm ?? 'unknown'} ${r.script ?? ''})`);
+      if (r.error) lines.push(`  - ${r.error}`);
+    }
+  }
+  if (!ok) {
+    lines.push('');
+    lines.push('[test] failed');
+  }
+  printResult({ json: false, text: lines.join('\n') });
+  if (!ok) {
+    process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error('[test] failed:', err);
+  process.exit(1);
+});

package/scripts/test_cmd.test.mjs

@@ -0,0 +1,133 @@
+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, signal) => resolve({ code: code ?? (signal ? 1 : 0), signal: signal ?? null, stdout, stderr }));
+  });
+}
+
+async function writeYarnOkPackage({ dir, name, scriptOutput }) {
+  await mkdir(join(dir, 'node_modules'), { recursive: true });
+  await writeFile(join(dir, 'yarn.lock'), '# stub lock\n', 'utf-8');
+  await writeFile(join(dir, 'test-script.mjs'), `process.stdout.write(${JSON.stringify(scriptOutput)});\n`, 'utf-8');
+  await writeFile(
+    join(dir, 'package.json'),
+    JSON.stringify(
+      {
+        name,
+        private: true,
+        packageManager: 'yarn@1.22.22',
+        scripts: {
+          test: 'node ./test-script.mjs',
+        },
+      },
+      null,
+      2
+    ),
+    'utf-8'
+  );
+  // Ensure deps are considered "already installed" by hstack.
+  await writeFile(join(dir, 'node_modules', '.yarn-integrity'), 'ok\n', 'utf-8');
+}
+
+async function setupTestCmdFixture({ importMetaUrl, t, tmpPrefix }) {
+  const scriptsDir = dirname(fileURLToPath(importMetaUrl));
+  const rootDir = dirname(scriptsDir);
+
+  const tmp = await mkdtemp(join(tmpdir(), tmpPrefix));
+  t.after(async () => {
+    await rm(tmp, { recursive: true, force: true }).catch(() => {});
+  });
+
+  const monoRoot = join(tmp, 'mono');
+  const appDir = join(monoRoot, 'apps', 'ui');
+
+  await mkdir(appDir, { recursive: true });
+
+  await writeYarnOkPackage({ dir: monoRoot, name: 'monorepo', scriptOutput: 'ROOT_TEST_RUN' });
+  await writeYarnOkPackage({ dir: appDir, name: 'happy-app', scriptOutput: 'APP_TEST_RUN' });
+
+  const env = {
+    ...process.env,
+    HAPPIER_STACK_REPO_DIR: monoRoot,
+    // Prevent env.mjs from auto-discovering and loading a real machine stack env file,
+    // which would overwrite our component dir override.
+    HAPPIER_STACK_STACK: 'test-stack',
+    HAPPIER_STACK_ENV_FILE: join(tmp, 'nonexistent-env'),
+  };
+
+  return { rootDir, monoRoot, appDir, env };
+}
+
+test('hstack test --json keeps stdout JSON-only and runs monorepo root when happy points at apps/ui', async (t) => {
+  const fixture = await setupTestCmdFixture({
+    importMetaUrl: import.meta.url,
+    t,
+    tmpPrefix: 'happy-stacks-test-cmd-json-',
+  });
+
+  const res = await runNode([join(fixture.rootDir, 'scripts', 'test_cmd.mjs'), 'ui', '--json'], {
+    cwd: fixture.rootDir,
+    env: fixture.env,
+  });
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstderr:\n${res.stderr}\nstdout:\n${res.stdout}`);
+
+  // Stdout must be JSON only.
+  let parsed;
+  try {
+    parsed = JSON.parse(res.stdout);
+  } catch (e) {
+    throw new Error(
+      `stdout was not valid JSON.\n` +
+        `error: ${String(e?.message ?? e)}\n` +
+        `stdout:\n${res.stdout}\n` +
+        `stderr:\n${res.stderr}\n`
+    );
+  }
+  assert.equal(
+    parsed?.ok,
+    true,
+    `expected ok=true, got:\n${JSON.stringify(parsed, null, 2)}\n\nstderr:\n${res.stderr}\n\nstdout:\n${res.stdout}`
+  );
+  assert.equal(parsed?.results?.length, 1);
+  assert.equal(parsed.results[0].target, 'ui');
+
+  // Monorepo detection: when happy points at apps/ui, tests should run from the monorepo root.
+  assert.equal(parsed.results[0].dir, fixture.monoRoot);
+
+  // Any command output should be written to stderr (to keep stdout JSON-only).
+  assert.ok(res.stderr.includes('ROOT_TEST_RUN'));
+  assert.ok(!res.stderr.includes('APP_TEST_RUN'));
+});
+
+test('hstack test (non-json) keeps monorepo-root routing and reports human-readable summary', async (t) => {
+  const fixture = await setupTestCmdFixture({
+    importMetaUrl: import.meta.url,
+    t,
+    tmpPrefix: 'happy-stacks-test-cmd-text-',
+  });
+
+  const res = await runNode([join(fixture.rootDir, 'scripts', 'test_cmd.mjs'), 'ui'], {
+    cwd: fixture.rootDir,
+    env: fixture.env,
+  });
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstderr:\n${res.stderr}\nstdout:\n${res.stdout}`);
+
+  assert.ok(res.stdout.includes('[test] ui: running yarn test'), res.stdout);
+  assert.ok(res.stdout.includes('ROOT_TEST_RUN'), res.stdout);
+  assert.ok(!res.stdout.includes('APP_TEST_RUN'), res.stdout);
+  assert.ok(res.stdout.includes('[test] results:'), res.stdout);
+  assert.ok(res.stdout.includes('- ✅ ui: ok (yarn test)'), res.stdout);
+});

package/scripts/test_integration.mjs

@@ -0,0 +1,33 @@
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { collectTestFiles } from './utils/test/collect_test_files.mjs';
+
+async function main() {
+  const packageRoot = fileURLToPath(new URL('..', import.meta.url));
+  const scriptsDir = join(packageRoot, 'scripts');
+  const testsDir = join(packageRoot, 'tests');
+
+  const testFiles = [];
+  testFiles.push(...(await collectTestFiles({
+    dir: scriptsDir,
+    includeSuffixes: ['.integration.test.mjs', '.real.integration.test.mjs'],
+  })));
+  testFiles.push(...(await collectTestFiles({
+    dir: testsDir,
+    includeSuffixes: ['.integration.test.mjs', '.real.integration.test.mjs'],
+  })));
+
+  if (testFiles.length === 0) {
+    process.stdout.write('[stack:test:integration] no integration test files found; skipping\n');
+    process.exit(0);
+  }
+
+  const { spawnSync } = await import('node:child_process');
+  const res = spawnSync(process.execPath, ['--test', ...testFiles], { stdio: 'inherit' });
+  process.exit(res.status ?? 1);
+}
+
+main().catch((e) => {
+  process.stderr.write(`[stack:test:integration] ${String(e?.stack ?? e)}\n`);
+  process.exit(1);
+});

package/scripts/testkit/auth_testkit.mjs

@@ -0,0 +1,121 @@
+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 sanitizeEnv(env) {
+  if (!env) return undefined;
+  const clean = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (value == null) continue;
+    clean[key] = String(value);
+  }
+  return clean;
+}
+
+export function getStackRootFromMeta(metaUrl) {
+  const scriptsDir = dirname(fileURLToPath(metaUrl));
+  return dirname(scriptsDir);
+}
+
+export function hstackBinPath(rootDir) {
+  return join(rootDir, 'bin', 'hstack.mjs');
+}
+
+export function authScriptPath(rootDir) {
+  return join(rootDir, 'scripts', 'auth.mjs');
+}
+
+export async function runNodeCapture(args, { cwd, env, input } = {}) {
+  return await new Promise((resolve, reject) => {
+    const usePipeInput = input != null;
+    const proc = spawn(process.execPath, args, {
+      cwd,
+      env: sanitizeEnv(env),
+      stdio: [usePipeInput ? 'pipe' : 'ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+    proc.stdout.on('data', (chunk) => {
+      stdout += String(chunk);
+    });
+    proc.stderr.on('data', (chunk) => {
+      stderr += String(chunk);
+    });
+    proc.on('error', reject);
+    proc.on('close', (code, signal) => {
+      resolve({ code: code ?? (signal ? 128 : 0), signal, stdout, stderr });
+    });
+
+    if (usePipeInput) {
+      proc.stdin.write(String(input));
+      proc.stdin.end();
+    }
+  });
+}
+
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function isPidAlive(pid) {
+  if (!pid || pid <= 1) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code !== 'ESRCH';
+  }
+}
+
+export async function terminateChildProcess(child, { signal = 'SIGTERM', timeoutMs = 800 } = {}) {
+  if (!child) return true;
+  if (child.exitCode != null) return true;
+  const waitForExit = new Promise((resolve) => {
+    child.once('exit', () => resolve());
+  });
+
+  try {
+    child.kill(signal);
+  } catch {}
+  await Promise.race([waitForExit, wait(timeoutMs)]);
+  if (child.exitCode == null) {
+    try {
+      child.kill('SIGKILL');
+    } catch {}
+    await Promise.race([waitForExit, wait(timeoutMs)]);
+  }
+  return !isPidAlive(child.pid);
+}
+
+export async function createAuthStackFixture({
+  prefix,
+  stackName = 'main',
+  stackEnvLines = [],
+}) {
+  const tmpDir = await mkdtemp(join(tmpdir(), prefix));
+  const storageDir = join(tmpDir, 'storage');
+  await mkdir(join(storageDir, stackName), { recursive: true });
+  const envPath = join(storageDir, stackName, 'env');
+  await writeFile(envPath, [...stackEnvLines, ''].join('\n'), 'utf-8');
+
+  return {
+    tmpDir,
+    storageDir,
+    envPath,
+    buildEnv(extra = {}) {
+      return {
+        ...process.env,
+        HAPPIER_STACK_STORAGE_DIR: storageDir,
+        HAPPIER_STACK_STACK: stackName,
+        HAPPIER_STACK_ENV_FILE: envPath,
+        ...extra,
+      };
+    },
+    async cleanup() {
+      await rm(tmpDir, { recursive: true, force: true });
+    },
+  };
+}

package/scripts/testkit/doctor_testkit.mjs

@@ -0,0 +1,68 @@
+import { spawn } from 'node:child_process';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+export function runNode(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(process.execPath, 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, signal) => resolve({ code: code ?? (signal ? 1 : 0), signal, stdout, stderr }));
+  });
+}
+
+async function writeStubHappierCli({ dir }) {
+  await mkdir(join(dir, 'bin'), { recursive: true });
+  await mkdir(join(dir, 'dist'), { recursive: true });
+  await writeFile(
+    join(dir, 'bin', 'happier.mjs'),
+    [
+      `if (process.argv.includes('daemon') && process.argv.includes('status')) {`,
+      `  console.log('Daemon is running');`,
+      `  process.exit(0);`,
+      `}`,
+      `console.log('ok');`,
+    ].join('\n'),
+    'utf-8'
+  );
+  await writeFile(join(dir, 'dist', 'index.mjs'), `export {};`, 'utf-8');
+}
+
+export async function createDoctorWorkspaceFixture(t, { tmpPrefix = 'happier-stack-doctor-' } = {}) {
+  const tmp = await mkdtemp(join(tmpdir(), tmpPrefix));
+  t.after(async () => {
+    await rm(tmp, { recursive: true, force: true });
+  });
+
+  const monoRoot = join(tmp, 'workspace', 'happier');
+  const stubServer = join(monoRoot, 'apps', 'server');
+  const stubCli = join(monoRoot, 'apps', 'cli');
+  const stubUi = join(monoRoot, 'apps', 'ui');
+  await mkdir(stubUi, { recursive: true });
+  await mkdir(stubServer, { recursive: true });
+  await mkdir(stubCli, { recursive: true });
+  await writeFile(join(stubUi, 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(stubCli, 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(stubServer, 'package.json'), '{}\n', 'utf-8');
+  await writeStubHappierCli({ dir: stubCli });
+
+  return { tmp, monoRoot };
+}
+
+export function doctorEnv({ monoRoot, extraEnv = {} } = {}) {
+  return {
+    ...process.env,
+    HAPPIER_STACK_REPO_DIR: monoRoot,
+    HAPPIER_STACK_CLI_ROOT_DISABLE: '1',
+    ...extraEnv,
+  };
+}