@happier-dev/stack 0.1.0-preview.5.1

package/scripts/self.mjs

@@ -0,0 +1,465 @@
+import './utils/env/env.mjs';
+
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+
+import { compareVersions, installRuntimeFromNpm, readNpmDistTagVersion, resolveNpmPackageNameOverride } from '@happier-dev/cli-common/update';
+
+import { parseArgs } from './utils/cli/args.mjs';
+import { pathExists } from './utils/fs/fs.mjs';
+import { run } from './utils/proc/proc.mjs';
+import { expandHome } from './utils/paths/canonical_home.mjs';
+import { getHappyStacksHomeDir, getRootDir } from './utils/paths/paths.mjs';
+import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
+import { getRuntimeDir } from './utils/paths/runtime.mjs';
+import { readJsonIfExists } from './utils/fs/json.mjs';
+import { readPackageJsonVersion } from './utils/fs/package_json.mjs';
+import { banner, bullets, cmd, kv, sectionTitle } from './utils/ui/layout.mjs';
+import { cyan, dim, green, yellow } from './utils/ui/ansi.mjs';
+import { getCanonicalHomeEnvPath, getHomeEnvPath, ensureCanonicalHomeEnvUpdated, ensureHomeEnvUpdated } from './utils/env/config.mjs';
+import { ensureEnvFilePruned } from './utils/env/env_file.mjs';
+import { coerceHappyMonorepoRootFromPath, getDevRepoDir, getRepoDir, getWorkspaceDir, resolveStackEnvPath } from './utils/paths/paths.mjs';
+import { parseEnvToObject } from './utils/env/dotenv.mjs';
+
+function packageJsonPathForNodeModules({ rootDir, packageName }) {
+  const name = String(packageName ?? '').trim();
+  if (!name) return null;
+  const parts = name.split('/').filter(Boolean);
+  return join(rootDir, 'node_modules', ...parts, 'package.json');
+}
+
+function cachePaths() {
+  const home = getHappyStacksHomeDir();
+  return {
+    home,
+    cacheDir: join(home, 'cache'),
+    updateJson: join(home, 'cache', 'update.json'),
+  };
+}
+
+async function writeJsonSafe(path, obj) {
+  try {
+    await mkdir(join(path, '..'), { recursive: true });
+  } catch {
+    // ignore
+  }
+  try {
+    await writeFile(path, JSON.stringify(obj, null, 2) + '\n', 'utf-8');
+  } catch {
+    // ignore
+  }
+}
+
+async function getRuntimeInstalledVersion() {
+  const runtimeDir = getRuntimeDir();
+  const invoker = await readJsonIfExists(join(getRootDir(import.meta.url), 'package.json'), { defaultValue: null });
+  const pkgName = String(invoker?.name ?? '').trim();
+  if (!pkgName) return null;
+  const pkgJson = packageJsonPathForNodeModules({ rootDir: runtimeDir, packageName: pkgName });
+  if (!pkgJson) return null;
+  return await readPackageJsonVersion(pkgJson);
+}
+
+async function getInvokerVersion({ rootDir }) {
+  return await readPackageJsonVersion(join(rootDir, 'package.json'));
+}
+
+function parseSelfChannel({ flags, kv }) {
+  if (flags.has('--preview')) return 'preview';
+  const raw = String(kv.get('--channel') ?? '').trim();
+  return raw === 'preview' ? 'preview' : 'stable';
+}
+
+async function fetchLatestVersion({ packageName, distTag, cwd }) {
+  const pkg = String(packageName ?? '').trim();
+  if (!pkg) return null;
+  return readNpmDistTagVersion({ packageName: pkg, distTag, cwd, env: process.env });
+}
+
+async function cmdStatus({ rootDir, argv }) {
+  const { flags, kv: kvArgs } = parseArgs(argv);
+  const json = wantsJson(argv, { flags });
+  const doCheck = !flags.has('--no-check');
+  const channel = parseSelfChannel({ flags, kv: kvArgs });
+  const distTag = channel === 'preview' ? 'next' : 'latest';
+
+  const { updateJson, cacheDir } = cachePaths();
+  const invoker = await readJsonIfExists(join(rootDir, 'package.json'), { defaultValue: null });
+  const packageName = resolveNpmPackageNameOverride({
+    envValue: process.env.HAPPIER_STACK_UPDATE_PACKAGE_NAME,
+    fallback: String(invoker?.name ?? '').trim(),
+  });
+  const invokerVersion = await getInvokerVersion({ rootDir });
+  const runtimeDir = getRuntimeDir();
+  const runtimeVersion = await getRuntimeInstalledVersion();
+
+  const cached = await readJsonIfExists(updateJson, { defaultValue: null });
+
+  let latest = cached?.latest ?? null;
+  let checkedAt = cached?.checkedAt ?? null;
+  let updateAvailable = Boolean(cached?.updateAvailable);
+
+  if (doCheck) {
+    try {
+      latest = await fetchLatestVersion({ packageName, distTag, cwd: rootDir });
+      checkedAt = Date.now();
+      const current = runtimeVersion || invokerVersion;
+      updateAvailable = Boolean(current && latest && compareVersions(latest, current) > 0);
+      await mkdir(cacheDir, { recursive: true });
+      await writeJsonSafe(updateJson, {
+        checkedAt,
+        latest,
+        current: current || null,
+        runtimeVersion: runtimeVersion || null,
+        invokerVersion: invokerVersion || null,
+        updateAvailable,
+        notifiedAt: cached?.notifiedAt ?? null,
+      });
+    } catch {
+      // ignore network/npm failures; keep cached values
+    }
+  }
+
+  printResult({
+    json,
+    data: {
+      ok: true,
+      invoker: { version: invokerVersion, rootDir },
+      runtime: { dir: runtimeDir, installed: Boolean(runtimeVersion), version: runtimeVersion },
+      update: { cachedLatest: cached?.latest ?? null, latest, checkedAt, updateAvailable },
+    },
+    text: [
+      '',
+      banner('self', { subtitle: 'Runtime install + self-update.' }),
+      '',
+      sectionTitle('Versions'),
+      bullets([
+        kv('invoker:', invokerVersion ? cyan(invokerVersion) : dim('unknown')),
+        kv('runtime:', runtimeVersion ? cyan(runtimeVersion) : `${yellow('not installed')} ${dim(`(${runtimeDir})`)}`),
+        kv('latest:', latest ? cyan(latest) : dim('unknown')),
+        checkedAt ? kv('checked:', dim(new Date(checkedAt).toISOString())) : null,
+      ].filter(Boolean)),
+      updateAvailable ? `\n${yellow('!')} update available: ${cyan(runtimeVersion || invokerVersion || 'current')} → ${cyan(latest)}` : null,
+      updateAvailable ? `${dim('Run:')} ${cmd('hstack self update')}` : null,
+      '',
+    ]
+      .filter(Boolean)
+      .join('\n'),
+  });
+}
+
+async function cmdUpdate({ rootDir, argv }) {
+  const { flags, kv: kvArgs } = parseArgs(argv);
+  const json = wantsJson(argv, { flags });
+
+  const runtimeDir = getRuntimeDir();
+  const to = (kvArgs.get('--to') ?? '').trim();
+  const channel = parseSelfChannel({ flags, kv: kvArgs });
+  const invoker = await readJsonIfExists(join(rootDir, 'package.json'), { defaultValue: null });
+  const pkgName = resolveNpmPackageNameOverride({
+    envValue: process.env.HAPPIER_STACK_UPDATE_PACKAGE_NAME,
+    fallback: String(invoker?.name ?? '').trim(),
+  });
+  if (!pkgName) throw new Error('[self] unable to resolve package name (missing package.json name)');
+  const spec = to ? `${pkgName}@${to}` : `${pkgName}@${channel === 'preview' ? 'next' : 'latest'}`;
+
+  // Ensure runtime dir exists.
+  await mkdir(runtimeDir, { recursive: true });
+
+  // Install/update runtime package.
+  const installRes = installRuntimeFromNpm({ runtimeDir, spec, cwd: rootDir, env: process.env });
+  if (!installRes.ok) {
+    // Pre-publish dev fallback: allow updating runtime from the local checkout.
+    if (!to && !String(process.env.HAPPIER_STACK_UPDATE_PACKAGE_NAME ?? '').trim() && existsSync(join(rootDir, 'package.json'))) {
+      try {
+        const raw = await readFile(join(rootDir, 'package.json'), 'utf-8');
+        const pkg = JSON.parse(raw);
+        if (pkg?.name === pkgName) {
+          await run('npm', ['install', '--no-audit', '--no-fund', '--silent', '--prefix', runtimeDir, rootDir], { cwd: rootDir });
+        } else {
+          throw new Error(installRes.errorMessage);
+        }
+      } catch {
+        throw new Error(installRes.errorMessage);
+      }
+    } else {
+      throw new Error(installRes.errorMessage);
+    }
+  }
+
+  // Refresh cache best-effort.
+  try {
+    const latest = await fetchLatestVersion({ packageName: pkgName, distTag: channel === 'preview' ? 'next' : 'latest', cwd: rootDir });
+    const runtimeVersion = await getRuntimeInstalledVersion();
+    const invokerVersion = await getInvokerVersion({ rootDir });
+    const current = runtimeVersion || invokerVersion;
+    const updateAvailable = Boolean(current && latest && compareVersions(latest, current) > 0);
+    const { updateJson, cacheDir } = cachePaths();
+    await mkdir(cacheDir, { recursive: true });
+    await writeJsonSafe(updateJson, {
+      checkedAt: Date.now(),
+      latest,
+      current: current || null,
+      runtimeVersion: runtimeVersion || null,
+      invokerVersion: invokerVersion || null,
+      updateAvailable,
+      notifiedAt: null,
+    });
+  } catch {
+    // ignore
+  }
+
+  const runtimeVersionAfter = await getRuntimeInstalledVersion();
+  printResult({
+    json,
+    data: { ok: true, runtimeDir, version: runtimeVersionAfter ?? null, spec },
+    text: `${green('✓')} updated runtime in ${cyan(runtimeDir)} ${dim('(')}${cyan(runtimeVersionAfter ?? spec)}${dim(')')}`,
+  });
+}
+
+async function cmdCheck({ rootDir, argv }) {
+  const { flags, kv: kvArgs } = parseArgs(argv);
+  const json = wantsJson(argv, { flags });
+  const quiet = flags.has('--quiet');
+  const channel = parseSelfChannel({ flags, kv: kvArgs });
+  const distTag = channel === 'preview' ? 'next' : 'latest';
+
+  const { updateJson, cacheDir } = cachePaths();
+  const runtimeVersion = await getRuntimeInstalledVersion();
+  const invokerVersion = await getInvokerVersion({ rootDir });
+  const current = runtimeVersion || invokerVersion;
+  const invoker = await readJsonIfExists(join(rootDir, 'package.json'), { defaultValue: null });
+  const packageName = resolveNpmPackageNameOverride({
+    envValue: process.env.HAPPIER_STACK_UPDATE_PACKAGE_NAME,
+    fallback: String(invoker?.name ?? '').trim(),
+  });
+
+  let latest = null;
+  try {
+    latest = await fetchLatestVersion({ packageName, distTag, cwd: rootDir });
+  } catch {
+    latest = null;
+  }
+
+  const updateAvailable = Boolean(current && latest && compareVersions(latest, current) > 0);
+  await mkdir(cacheDir, { recursive: true });
+  await writeJsonSafe(updateJson, {
+    checkedAt: Date.now(),
+    latest,
+    current: current || null,
+    runtimeVersion: runtimeVersion || null,
+    invokerVersion: invokerVersion || null,
+    updateAvailable,
+    notifiedAt: null,
+  });
+
+  if (quiet) {
+    return;
+  }
+  printResult({
+    json,
+    data: { ok: true, current: current || null, latest, updateAvailable },
+    text: latest
+      ? updateAvailable
+        ? `${yellow('!')} update available: ${cyan(current)} → ${cyan(latest)}\n${dim('Run:')} ${cmd('hstack self update')}`
+        : `${green('✓')} up to date ${dim('(')}${cyan(current)}${dim(')')}`
+      : `${yellow('!')} unable to check latest version`,
+  });
+}
+
+function resolveCliRootCandidate({ rootDir, target }) {
+  const raw = String(target ?? '').trim();
+  if (!raw) return null;
+
+  const workspaceDir = getWorkspaceDir(rootDir, process.env);
+  if (raw === 'main') {
+    return join(getRepoDir(rootDir, process.env), 'apps', 'stack');
+  }
+  if (raw === 'dev') {
+    return join(getDevRepoDir(rootDir, process.env), 'apps', 'stack');
+  }
+
+  // Allow absolute/relative path targets. If the path is a monorepo root, accept apps/stack.
+  const expanded = expandHome(raw);
+  const abs = expanded.startsWith('/') ? expanded : resolve(process.cwd(), expanded);
+  if (existsSync(join(abs, 'bin', 'hstack.mjs'))) return abs;
+  if (existsSync(join(abs, 'apps', 'stack', 'bin', 'hstack.mjs'))) return join(abs, 'apps', 'stack');
+  if (existsSync(join(abs, 'package.json')) && existsSync(join(abs, 'bin', 'hstack.mjs'))) return abs;
+  // If user passed a workspace dir by mistake, allow selecting main/dev via keywords.
+  void workspaceDir;
+  return abs;
+}
+
+async function cmdUseCli({ rootDir, argv }) {
+  const { flags, kv } = parseArgs(argv);
+  const json = wantsJson(argv, { flags });
+
+  const positional = argv.filter((a) => !a.startsWith('--'));
+  const target = positional[1] ?? '';
+  const stackFlag = String(kv.get('--stack') ?? '').trim();
+
+  const key = 'HAPPIER_STACK_CLI_ROOT_DIR';
+  const homeEnv = getHomeEnvPath();
+  const canonicalEnv = getCanonicalHomeEnvPath();
+
+  if ((!target && !stackFlag) || wantsHelp(argv, { flags })) {
+    printResult({
+      json,
+      data: { ok: true, command: 'use-cli', targets: ['default', 'main', 'dev', '/abs/path/to/apps/stack'], flags: ['--stack=<name>'] },
+      text: [
+        banner('self use-cli', { subtitle: 'Point the hstack shim at a local checkout (or reset to runtime).' }),
+        '',
+        sectionTitle('usage:'),
+        `  ${cyan('hstack self')} use-cli default`,
+        `  ${cyan('hstack self')} use-cli main`,
+        `  ${cyan('hstack self')} use-cli dev`,
+        `  ${cyan('hstack self')} use-cli /abs/path/to/apps/stack`,
+        `  ${cyan('hstack self')} use-cli --stack=<name>`,
+        '',
+        sectionTitle('notes:'),
+        bullets([
+          `Writes ${cyan(homeEnv)} and ${cyan(canonicalEnv)}.`,
+          `Takes effect for new shells (and SwiftBar/launchd) because the ${cyan('hstack')} shim reads the canonical pointer file.`,
+        ]),
+      ].join('\n'),
+    });
+    return;
+  }
+
+  if (target === 'default' || target === 'runtime') {
+    await ensureEnvFilePruned({ envPath: homeEnv, removeKeys: [key] });
+    await ensureEnvFilePruned({ envPath: canonicalEnv, removeKeys: [key] });
+    printResult({
+      json,
+      data: { ok: true, mode: 'runtime' },
+      text: `${green('✓')} using runtime CLI (cleared ${cyan(key)})`,
+    });
+    return;
+  }
+
+  const candidate = (() => {
+    if (!stackFlag) return resolveCliRootCandidate({ rootDir, target });
+    return null;
+  })();
+
+  if (stackFlag) {
+    const { envPath } = resolveStackEnvPath(stackFlag, process.env);
+    const raw = existsSync(envPath) ? await readFile(envPath, 'utf-8') : '';
+    const parsed = raw ? parseEnvToObject(raw) : {};
+    const repoDirRaw = String(parsed.HAPPIER_STACK_REPO_DIR ?? '').trim();
+    if (!repoDirRaw) {
+      throw new Error(`[self use-cli] stack "${stackFlag}" has no HAPPIER_STACK_REPO_DIR in ${envPath}`);
+    }
+    const repoRoot = coerceHappyMonorepoRootFromPath(repoDirRaw) || repoDirRaw;
+    const fromStack = join(repoRoot, 'apps', 'stack');
+    const entry = join(fromStack, 'bin', 'hstack.mjs');
+    if (!existsSync(entry)) {
+      throw new Error(`[self use-cli] stack "${stackFlag}" repo does not contain apps/stack (${entry} missing)`);
+    }
+    await ensureHomeEnvUpdated({ updates: [{ key, value: fromStack }] });
+    await ensureCanonicalHomeEnvUpdated({ updates: [{ key, value: fromStack }] });
+    printResult({
+      json,
+      data: { ok: true, mode: 'local', stack: stackFlag, cliRootDir: fromStack },
+      text: `${green('✓')} using local CLI from stack "${stackFlag}" at ${cyan(fromStack)}`,
+    });
+    return;
+  }
+
+  const entry = candidate ? join(candidate, 'bin', 'hstack.mjs') : null;
+  if (!candidate || !entry || !existsSync(entry)) {
+    throw new Error(
+      `[self use-cli] invalid target: ${target}\n` +
+        `Expected one of: default|main|dev|/abs/path/to/apps/stack\n` +
+        `Missing: ${entry || '<path>/bin/hstack.mjs'}`
+    );
+  }
+
+  await ensureHomeEnvUpdated({ updates: [{ key, value: candidate }] });
+  await ensureCanonicalHomeEnvUpdated({ updates: [{ key, value: candidate }] });
+  printResult({
+    json,
+    data: { ok: true, mode: 'local', cliRootDir: candidate },
+    text: `${green('✓')} using local CLI at ${cyan(candidate)}`,
+  });
+}
+
+async function main() {
+  const rootDir = getRootDir(import.meta.url);
+  const argv = process.argv.slice(2);
+
+  const helpSepIdx = argv.indexOf('--');
+  const helpScopeArgv = helpSepIdx === -1 ? argv : argv.slice(0, helpSepIdx);
+  const { flags } = parseArgs(helpScopeArgv);
+  const cmd = helpScopeArgv.find((a) => a && a !== '--' && !a.startsWith('-')) ?? 'help';
+
+  const wantsHelpFlag = wantsHelp(helpScopeArgv, { flags });
+  const json = wantsJson(helpScopeArgv, { flags });
+  const usageByCmd = new Map([
+    ['status', 'hstack self status [--preview|--channel=preview] [--no-check] [--json]'],
+    ['update', 'hstack self update [--preview|--channel=preview] [--to=<version>] [--json]'],
+    ['check', 'hstack self check [--preview|--channel=preview] [--quiet] [--json]'],
+    ['use-cli', 'hstack self use-cli default|main|dev|/abs/path/to/apps/stack [--json]'],
+  ]);
+
+  if (wantsHelpFlag && cmd !== 'help') {
+    const usage = usageByCmd.get(cmd);
+    if (usage) {
+      printResult({
+        json,
+        data: { ok: true, cmd, usage },
+        text: [`[self ${cmd}] usage:`, `  ${usage}`, '', 'see also:', '  hstack self --help'].join('\n'),
+      });
+      return;
+    }
+  }
+
+  if (wantsHelpFlag || cmd === 'help') {
+    printResult({
+      json,
+      data: { commands: ['status', 'update', 'check', 'use-cli'], flags: ['--preview', '--channel=preview', '--no-check', '--to=<version>', '--quiet'] },
+      text: [
+        banner('self', { subtitle: 'Runtime install + self-update.' }),
+        '',
+        sectionTitle('usage:'),
+        `  ${cyan('hstack self')} status [--preview|--channel=preview] [--no-check] [--json]`,
+        `  ${cyan('hstack self')} update [--preview|--channel=preview] [--to=<version>] [--json]`,
+        `  ${cyan('hstack self')} check [--preview|--channel=preview] [--quiet] [--json]`,
+        `  ${cyan('hstack self')} use-cli default|main|dev|/abs/path/to/apps/stack [--json]`,
+        '',
+        sectionTitle('channels:'),
+        bullets([
+          kv('stable:', dim('npm dist-tag latest')),
+          kv('preview:', dim('npm dist-tag next')),
+        ]),
+      ].join('\n'),
+    });
+    return;
+  }
+
+  if (cmd === 'status') {
+    await cmdStatus({ rootDir, argv });
+    return;
+  }
+  if (cmd === 'update') {
+    await cmdUpdate({ rootDir, argv });
+    return;
+  }
+  if (cmd === 'check') {
+    await cmdCheck({ rootDir, argv });
+    return;
+  }
+  if (cmd === 'use-cli') {
+    await cmdUseCli({ rootDir, argv });
+    return;
+  }
+
+  throw new Error(`[self] unknown command: ${cmd}`);
+}
+
+main().catch((err) => {
+  const msg = err instanceof Error ? err.message : String(err);
+  console.error(`[self] failed: ${msg}`);
+  process.exit(1);
+});

package/scripts/self_host.mjs

@@ -0,0 +1,9 @@
+import './utils/env/env.mjs';
+
+import { runSelfHostCli } from './self_host_runtime.mjs';
+
+runSelfHostCli(process.argv.slice(2)).catch((error) => {
+  const msg = error instanceof Error ? error.message : String(error);
+  console.error(msg);
+  process.exit(1);
+});

package/scripts/self_host_binary_smoke.integration.test.mjs

@@ -0,0 +1,94 @@
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { mkdtemp, readdir } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import test from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+function formatSpawnSyncResult(result) {
+  const stdout = String(result.stdout || '').trim();
+  const stderr = String(result.stderr || '').trim();
+  const error = result.error ? String(result.error.stack || result.error.message || result.error) : '';
+  const status = typeof result.status === 'number' ? String(result.status) : '<null>';
+  const signal = result.signal ? String(result.signal) : '<null>';
+  return [
+    `status=${status}`,
+    `signal=${signal}`,
+    error ? `error=${error}` : '',
+    stdout ? `stdout:\n${stdout}` : '',
+    stderr ? `stderr:\n${stderr}` : '',
+  ]
+    .filter(Boolean)
+    .join('\n');
+}
+
+function commandExists(cmd) {
+  return spawnSync('bash', ['-lc', `command -v ${cmd} >/dev/null 2>&1`], { stdio: 'ignore' }).status === 0;
+}
+
+function currentTarget() {
+  const os = process.platform === 'linux' ? 'linux' : process.platform === 'darwin' ? 'darwin' : '';
+  const arch = process.arch === 'x64' ? 'x64' : process.arch === 'arm64' ? 'arm64' : '';
+  if (!os || !arch) return '';
+  return `${os}-${arch}`;
+}
+
+test('compiled hstack binary runs self-host help outside repo checkout', async (t) => {
+  if (!commandExists('bun')) {
+    t.skip('bun is required for compiled binary smoke tests');
+    return;
+  }
+  const target = currentTarget();
+  if (!target) {
+    t.skip(`unsupported platform for smoke test: ${process.platform}-${process.arch}`);
+    return;
+  }
+
+  const repoRoot = resolve(fileURLToPath(new URL('../../..', import.meta.url)));
+  const version = `0.0.0-smoke.${Date.now()}`;
+  const build = spawnSync(
+    process.execPath,
+    [
+      'scripts/release/build-hstack-binaries.mjs',
+      '--channel=preview',
+      `--version=${version}`,
+      `--targets=${target}`,
+    ],
+    {
+      cwd: repoRoot,
+      encoding: 'utf-8',
+      env: {
+        ...process.env,
+      },
+      // If this ever hangs on CI, fail with a clear timeout rather than blocking the entire suite.
+      timeout: 15 * 60 * 1000,
+      maxBuffer: 50 * 1024 * 1024,
+    }
+  );
+  assert.equal(build.status, 0, formatSpawnSyncResult(build));
+
+  const artifact = join(repoRoot, 'dist', 'release-assets', 'stack', `hstack-v${version}-${target}.tar.gz`);
+  const extractDir = await mkdtemp(join(tmpdir(), 'hstack-binary-smoke-'));
+  t.after(() => {
+    spawnSync('bash', ['-lc', `rm -rf "${extractDir.replaceAll('"', '\\"')}"`], { stdio: 'ignore' });
+  });
+  const untar = spawnSync('tar', ['-xzf', artifact, '-C', extractDir], { encoding: 'utf-8' });
+  assert.equal(untar.status, 0, untar.stderr);
+
+  const entries = await readdir(extractDir);
+  assert.ok(entries.length > 0, 'expected extracted artifact directory');
+  const binaryPath = join(extractDir, entries[0], 'hstack');
+
+  const help = spawnSync(binaryPath, ['self-host', '--help'], {
+    cwd: '/tmp',
+    encoding: 'utf-8',
+    env: {
+      ...process.env,
+      HAPPIER_NONINTERACTIVE: '1',
+    },
+  });
+  assert.equal(help.status, 0, help.stderr || help.stdout);
+  assert.match(help.stdout, /hstack self-host install/);
+  assert.match(help.stdout, /works without a repository checkout/);
+});