@happier-dev/stack 0.1.0 → 0.2.0

package/scripts/testkit/mobile_dev_client_testkit.mjs

@@ -0,0 +1,136 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+import { buildStackHarnessEnv, writeFakeBin } from './core/fake_bin_harness.mjs';
+import { createTempFixture } from './core/temp_fixture.mjs';
+import { getStackRootFromMeta, runNodeCapture } from './auth_testkit.mjs';
+
+function toExecutableScript(body) {
+  return body.endsWith('\n') ? body : `${body}\n`;
+}
+
+export async function createMobileDevClientTestFixture(
+  t,
+  {
+    importMetaUrl,
+    prefix = 'hstack-mobile-dev-client-',
+    includeRepoDir = false,
+    includeHomeDir = false,
+    includeStorageDir = false,
+    stackName = 'main',
+  } = {},
+) {
+  const fixture = await createTempFixture(t, { prefix });
+  const rootDir = getStackRootFromMeta(importMetaUrl);
+  const devClientScript = join(rootDir, 'scripts', 'mobile_dev_client.mjs');
+  const repoDir = includeRepoDir ? fixture.path('repo') : null;
+  const homeDir = includeHomeDir ? fixture.path('home') : null;
+  const storageDir = includeStorageDir ? fixture.path('storage') : null;
+
+  if (storageDir) {
+    await mkdir(join(storageDir, stackName), { recursive: true });
+  }
+
+  async function writeBin(name, content) {
+    return writeFakeBin({
+      root: fixture.root,
+      name,
+      content: toExecutableScript(content),
+    });
+  }
+
+  return {
+    ...fixture,
+    rootDir,
+    devClientScript,
+    repoDir,
+    homeDir,
+    storageDir,
+    stackName,
+    writeBin,
+    writeNoopBin(name) {
+      return writeBin(name, '#!/bin/bash\nexit 0\n');
+    },
+    writeAdbDevicesBin({ serial = 'ABC123', hasDevice = true } = {}) {
+      const deviceLine = hasDevice ? `  printf "${serial}\\tdevice\\n"\n` : '';
+      return writeBin(
+        'adb',
+        `#!/bin/bash
+set -euo pipefail
+if [[ "\${1:-}" == "devices" ]]; then
+  echo "List of devices attached"
+${deviceLine}  echo ""
+  exit 0
+fi
+exit 0
+`,
+      );
+    },
+    writeXcrunListBin(jsonText = '[]') {
+      return writeBin(
+        'xcrun',
+        `#!/bin/bash
+set -euo pipefail
+if [[ "\${1:-}" == "xcdevice" && "\${2:-}" == "list" ]]; then
+  cat <<'JSON'
+${jsonText}
+JSON
+  exit 0
+fi
+exit 0
+`,
+      );
+    },
+    async writeExpoStub(script = `#!${process.execPath}\nprocess.exit(0);\n`) {
+      if (!repoDir) {
+        throw new Error('writeExpoStub requires includeRepoDir=true');
+      }
+      const expoBin = join(repoDir, 'apps', 'ui', 'node_modules', '.bin', 'expo');
+      await mkdir(join(repoDir, 'apps', 'ui', 'node_modules', '.bin'), { recursive: true });
+      await writeFile(expoBin, script, 'utf-8');
+      writeFakeBin({
+        root: join(repoDir, 'apps', 'ui', 'node_modules'),
+        binDirName: '.bin',
+        name: 'expo',
+        content: script,
+      });
+      return expoBin;
+    },
+    buildEnv({
+      androidHome = false,
+      expoToken,
+      extraEnv = {},
+    } = {}) {
+      const baseEnv = { ...process.env };
+      // CI runners often provide Android SDK env vars. Tests should opt in explicitly
+      // so strategy resolution stays deterministic.
+      delete baseEnv.ANDROID_HOME;
+      delete baseEnv.ANDROID_SDK_ROOT;
+
+      return buildStackHarnessEnv({
+        baseEnv,
+        extraEnv: {
+          HSTACK_MOBILE_DEV_CLIENT_TEST_STUB: '1',
+          HAPPIER_STACK_ENV_FILE: fixture.path('nonexistent-env'),
+          ...(androidHome ? { ANDROID_HOME: fixture.path('android-home') } : {}),
+          ...(expoToken ? { EXPO_TOKEN: expoToken } : {}),
+          ...(repoDir ? { HAPPIER_STACK_REPO_DIR: repoDir } : {}),
+          ...(homeDir ? { HAPPIER_STACK_HOME_DIR: homeDir } : {}),
+          ...(storageDir
+            ? {
+                HAPPIER_STACK_STORAGE_DIR: storageDir,
+                HAPPIER_STACK_STACK: stackName,
+                HAPPIER_STACK_TAILSCALE_PREFER_PUBLIC_URL: '0',
+                HAPPIER_STACK_TAILSCALE_SERVE: '0',
+              }
+            : {}),
+          ...extraEnv,
+        },
+        binDirs: [fixture.path('bin')],
+      });
+    },
+    run(args, { env } = {}) {
+      return runNodeCapture([devClientScript, ...args], { cwd: rootDir, env });
+    },
+  };
+}

package/scripts/testkit/mobile_dev_client_testkit_env_sanitization.test.mjs

@@ -0,0 +1,32 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { createMobileDevClientTestFixture } from './mobile_dev_client_testkit.mjs';
+
+test('mobile dev-client testkit clears host Android SDK env vars unless explicitly requested', async (t) => {
+  const prevAndroidHome = process.env.ANDROID_HOME;
+  const prevAndroidSdkRoot = process.env.ANDROID_SDK_ROOT;
+
+  process.env.ANDROID_HOME = '/tmp/host-android-home';
+  process.env.ANDROID_SDK_ROOT = '/tmp/host-android-sdk-root';
+
+  try {
+    const fixture = await createMobileDevClientTestFixture(t, {
+      importMetaUrl: import.meta.url,
+      prefix: 'hstack-mobile-dev-client-env-sanitize-',
+    });
+
+    const envNoSdk = fixture.buildEnv();
+    assert.equal(envNoSdk.ANDROID_HOME, undefined);
+    assert.equal(envNoSdk.ANDROID_SDK_ROOT, undefined);
+
+    const envWithSdk = fixture.buildEnv({ androidHome: true });
+    assert.ok(String(envWithSdk.ANDROID_HOME || '').length > 0);
+  } finally {
+    if (prevAndroidHome == null) delete process.env.ANDROID_HOME;
+    else process.env.ANDROID_HOME = prevAndroidHome;
+    if (prevAndroidSdkRoot == null) delete process.env.ANDROID_SDK_ROOT;
+    else process.env.ANDROID_SDK_ROOT = prevAndroidSdkRoot;
+  }
+});
+

package/scripts/testkit/monorepo_port_testkit.mjs

@@ -1,31 +1,19 @@
-import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
+import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { spawn } from 'node:child_process';
 
 import { run, runCapture } from '../utils/proc/proc.mjs';
+import { sanitizeDefinedEnv } from '../utils/test/test_env.mjs';
+import { ensureMinimalMonorepoLayout } from './core/minimal_monorepo_layout.mjs';
+import { buildGitIdentityEnv } from './core/env_scope.mjs';
+import { createTempFixture } from './core/temp_fixture.mjs';
 
 export async function withTempRoot(t) {
-  const dir = await mkdtemp(join(tmpdir(), 'happy-stacks-monorepo-port-'));
-  t.after(async () => {
-    await rm(dir, { recursive: true, force: true });
-  });
-  return dir;
+  return (await createTempFixture(t, { prefix: 'happy-stacks-monorepo-port-' })).root;
 }
 
 export function gitEnv() {
-  const clean = {};
-  for (const [k, v] of Object.entries(process.env)) {
-    if (k.startsWith('HAPPIER_STACK_')) continue;
-    clean[k] = v;
-  }
-  return {
-    ...clean,
-    GIT_AUTHOR_NAME: 'Test',
-    GIT_AUTHOR_EMAIL: 'test@example.com',
-    GIT_COMMITTER_NAME: 'Test',
-    GIT_COMMITTER_EMAIL: 'test@example.com',
-  };
+  return buildGitIdentityEnv();
 }
 
 export async function initMonorepoStub({ dir, env, seed = {}, layout = 'packages' }) {
@@ -34,12 +22,7 @@ export async function initMonorepoStub({ dir, env, seed = {}, layout = 'packages
   await run('git', ['checkout', '-q', '-b', 'main'], { cwd: dir, env });
 
   void layout;
-  await mkdir(join(dir, 'apps', 'ui'), { recursive: true });
-  await mkdir(join(dir, 'apps', 'cli'), { recursive: true });
-  await mkdir(join(dir, 'apps', 'server'), { recursive: true });
-  await writeFile(join(dir, 'apps', 'ui', 'package.json'), '{}\n', 'utf-8');
-  await writeFile(join(dir, 'apps', 'cli', 'package.json'), '{}\n', 'utf-8');
-  await writeFile(join(dir, 'apps', 'server', 'package.json'), '{}\n', 'utf-8');
+  await ensureMinimalMonorepoLayout(dir);
   for (const [rel, content] of Object.entries(seed)) {
     // eslint-disable-next-line no-await-in-loop
     await mkdir(join(dir, rel.split('/').slice(0, -1).join('/')), { recursive: true });
@@ -79,7 +62,7 @@ function withTimeout(task, { timeoutMs, message }) {
 }
 
 export function spawnNodeWithCapture(command, args, { cwd, env, stdio = ['pipe', 'pipe', 'pipe'] } = {}) {
-  const child = spawn(command, args, { cwd, env, stdio });
+  const child = spawn(command, args, { cwd, env: sanitizeDefinedEnv(env), stdio });
   let stdout = '';
   let stderr = '';
   const outputWaiters = new Set();

package/scripts/testkit/runtime_snapshot_start_testkit.mjs

@@ -0,0 +1,281 @@
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+
+import { resolveStackCredentialPaths } from '../utils/auth/credentials_paths.mjs';
+import { buildStackStableScopeId } from '../utils/auth/stable_scope_id.mjs';
+import { pickNextFreeTcpPort } from '../utils/net/ports.mjs';
+import { runNodeCapture } from './core/run_node_capture.mjs';
+import { writeRuntimeSnapshotLayout } from './core/runtime_snapshot_layout.mjs';
+import { createTempFixture } from './core/temp_fixture.mjs';
+
+export const runNode = runNodeCapture;
+
+export async function waitForHealth(baseUrl, { timeoutMs = 30_000, intervalMs = 250 } = {}) {
+  const startedAt = Date.now();
+  let lastError = '';
+  while (Date.now() - startedAt < timeoutMs) {
+    try {
+      const res = await fetch(`${baseUrl}/health`);
+      const body = await res.json().catch(() => null);
+      if (res.status === 200 && body?.status === 'ok') return;
+      lastError = `status=${res.status} body=${JSON.stringify(body)}`;
+    } catch (error) {
+      lastError = error instanceof Error ? error.message : String(error);
+    }
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+  throw new Error(`Timed out waiting for ${baseUrl}/health (${lastError})`);
+}
+
+function createFixtureDaemonCliScript({
+  startLogLine,
+  statusLogLine,
+  includeServerUrlInStartLog = false,
+  includeRunningInStatusLog = false,
+}) {
+  return `
+import { spawn } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+const args = process.argv.slice(2);
+const home = String(process.env.HAPPIER_HOME_DIR || process.env.HAPPIER_STACK_CLI_HOME_DIR || '').trim();
+if (!home) {
+  console.error('missing HAPPIER_HOME_DIR');
+  process.exit(2);
+}
+const statePath = join(home, 'daemon.state.json');
+const activeServerId = String(process.env.HAPPIER_ACTIVE_SERVER_ID || '').trim();
+const serverScopedStatePath = activeServerId ? join(home, 'servers', activeServerId, 'daemon.state.json') : '';
+const logPath = join(home, 'runtime-daemon.log');
+const append = (line) => {
+  writeFileSync(logPath, line + '\\n', { flag: 'a' });
+};
+const writeState = (payload) => {
+  writeFileSync(statePath, payload, 'utf8');
+  if (serverScopedStatePath) {
+    mkdirSync(dirname(serverScopedStatePath), { recursive: true });
+    writeFileSync(serverScopedStatePath, payload, 'utf8');
+  }
+};
+const removeState = () => {
+  try { rmSync(statePath); } catch {}
+  if (serverScopedStatePath) {
+    try { rmSync(serverScopedStatePath); } catch {}
+  }
+};
+if (args[0] !== 'daemon') process.exit(0);
+const sub = args[1] || '';
+if (sub === 'start') {
+  ${includeServerUrlInStartLog
+    ? "append('start:' + String(process.env.HAPPIER_SERVER_URL || ''));"
+    : `append(${JSON.stringify(startLogLine)});`}
+  append('direct_peer_bind_port=' + String(process.env.HAPPIER_MACHINE_TRANSFER_DIRECT_PEER_BIND_PORT || ''));
+  append('direct_peer_advertised_hosts=' + String(process.env.HAPPIER_MACHINE_TRANSFER_DIRECT_PEER_ADVERTISED_HOSTS || ''));
+  append('direct_peer_feature_enabled=' + String(process.env.HAPPIER_FEATURE_MACHINES_TRANSFER_DIRECT_PEER__ENABLED || ''));
+  append('direct_peer_server_enabled=' + String(process.env.HAPPIER_MACHINE_TRANSFER_DIRECT_PEER_SERVER_ENABLED || ''));
+  const child = spawn(process.execPath, ['-e', 'setInterval(() => {}, 1000)'], { detached: true, stdio: 'ignore' });
+  child.unref();
+  writeState(JSON.stringify({ pid: child.pid, httpPort: 0, startedAt: new Date().toISOString() }) + '\\n');
+  process.exit(0);
+}
+if (sub === 'stop') {
+  append('stop');
+  if (existsSync(statePath)) {
+    try {
+      const pid = Number(JSON.parse(readFileSync(statePath, 'utf8')).pid);
+      if (Number.isFinite(pid) && pid > 1) {
+        try { process.kill(pid, 'SIGTERM'); } catch {}
+      }
+    } catch {}
+  }
+  removeState();
+  process.exit(0);
+}
+if (sub === 'status') {
+  const running = existsSync(statePath);
+  ${includeRunningInStatusLog
+    ? `append(${JSON.stringify(statusLogLine)} + String(running));`
+    : `append(${JSON.stringify(statusLogLine)});`}
+  console.log(running ? 'daemon: running' : 'daemon: stopped');
+  process.exit(0);
+}
+process.exit(0);
+`;
+}
+
+export async function createStartableRuntimeSnapshotFixture(t, {
+  stackName = 'runtime-prod',
+  serverPort,
+} = {}) {
+  const preserveFixture = (process.env.HAPPIER_TEST_PRESERVE_RUNTIME_FIXTURE ?? '').toString().trim() === '1';
+  const fixture = await createTempFixture(t, {
+    prefix: 'hstack-runtime-start-fixture-',
+    registerCleanup: !preserveFixture,
+  });
+  const resolvedServerPort =
+    Number.isFinite(serverPort) && Number(serverPort) > 0
+      ? Number(serverPort)
+      : await pickNextFreeTcpPort(20_000, { host: '127.0.0.1' });
+  const root = fixture.root;
+  const storageDir = join(root, 'storage');
+  const stackDir = join(storageDir, stackName);
+  const cliHomeDir = join(stackDir, 'cli');
+  const runtimeDir = join(stackDir, 'runtime');
+  const serverEnvCapturePath = join(stackDir, 'server.runtime-env.json');
+
+  await mkdir(cliHomeDir, { recursive: true });
+  await mkdir(runtimeDir, { recursive: true });
+
+  const serverScript = `
+import { createServer } from 'node:http';
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const port = Number(process.env.PORT || process.env.HAPPIER_SERVER_PORT || 0);
+if (!Number.isFinite(port) || port <= 0) {
+  console.error('missing HAPPIER_SERVER_PORT');
+  process.exit(2);
+}
+const uiDir = String(process.env.HAPPIER_SERVER_UI_DIR || '').trim();
+const marker = String(process.env.HAPPIER_RUNTIME_SNAPSHOT_MARKER || 'runtime-snapshot');
+const envCapturePath = String(process.env.HAPPIER_RUNTIME_SERVER_ENV_CAPTURE_PATH || '').trim();
+if (envCapturePath) {
+  writeFileSync(envCapturePath, JSON.stringify({
+    DATABASE_URL: process.env.DATABASE_URL ?? null,
+    HAPPIER_SQLITE_AUTO_MIGRATE: process.env.HAPPIER_SQLITE_AUTO_MIGRATE ?? null,
+    HAPPIER_SQLITE_MIGRATIONS_DIR: process.env.HAPPIER_SQLITE_MIGRATIONS_DIR ?? null,
+    HAPPIER_SERVER_LIGHT_DATA_DIR: process.env.HAPPIER_SERVER_LIGHT_DATA_DIR ?? null,
+  }, null, 2) + '\\n', 'utf8');
+}
+const server = createServer((req, res) => {
+  const url = new URL(req.url || '/', 'http://127.0.0.1');
+  if (url.pathname === '/health') {
+    res.writeHead(200, { 'content-type': 'application/json' });
+    res.end(JSON.stringify({ status: 'ok', marker }));
+    return;
+  }
+  if (url.pathname === '/' || url.pathname === '/index.html') {
+    const html = readFileSync(join(uiDir, 'index.html'), 'utf8');
+    res.writeHead(200, { 'content-type': 'text/html; charset=utf-8' });
+    res.end(html);
+    return;
+  }
+  res.writeHead(404, { 'content-type': 'text/plain; charset=utf-8' });
+  res.end('not found');
+});
+
+server.listen(port, '127.0.0.1', () => {
+  console.log('runtime-server-ready:' + port);
+});
+
+const shutdown = () => {
+  server.close(() => process.exit(0));
+};
+process.on('SIGTERM', shutdown);
+process.on('SIGINT', shutdown);
+`;
+
+  const cliScript = createFixtureDaemonCliScript({
+    startLogLine: 'start',
+    statusLogLine: 'status:',
+    includeServerUrlInStartLog: true,
+    includeRunningInStatusLog: true,
+  });
+
+  const cliPackageDistScript = createFixtureDaemonCliScript({
+    startLogLine: 'start',
+    statusLogLine: 'status',
+  });
+
+  const { snapshotDir } = await writeRuntimeSnapshotLayout({
+    stackDir,
+    snapshotId: 'snap-startable',
+    sourceFingerprint: 'src-startable',
+    writeCurrentMirror: true,
+    currentUpdatedAt: '2026-03-07T12:00:00.000Z',
+    createdAt: '2026-03-07T12:00:00.000Z',
+    source: {
+      repoDir: root,
+      serverComponent: 'happier-server-light',
+      dbProvider: 'sqlite',
+      commitSha: 'fixture',
+      dirtyHash: 'clean',
+      sourceFingerprint: 'src-startable',
+      builtAt: '2026-03-07T12:00:00.000Z',
+    },
+    web: {
+      content: '<html><body><div data-testid="runtime-snapshot-ui">RUNTIME SNAPSHOT UI</div></body></html>\n',
+      artifactFingerprint: 'web-startable',
+    },
+    server: {
+      content: `#!/usr/bin/env node\n${serverScript.trimStart()}`,
+      artifactFingerprint: 'server-startable',
+    },
+    daemon: {
+      content: `#!/usr/bin/env node\n${cliScript.trimStart()}`,
+      artifactFingerprint: 'daemon-startable',
+      nodeEntrypoint: 'cli/package-dist/index.mjs',
+      nodeContent: cliPackageDistScript.trimStart(),
+    },
+  });
+  const sqliteMigrationsDir = join(snapshotDir, 'server', 'prisma', 'sqlite', 'migrations', '20260101000000_fixture');
+  await mkdir(sqliteMigrationsDir, { recursive: true });
+  await writeFile(join(sqliteMigrationsDir, 'migration.sql'), '-- fixture migration\n', 'utf8');
+  await mkdir(join(stackDir, 'runtime', 'current', 'server', 'prisma', 'sqlite', 'migrations', '20260101000000_fixture'), { recursive: true });
+  await writeFile(
+    join(stackDir, 'runtime', 'current', 'server', 'prisma', 'sqlite', 'migrations', '20260101000000_fixture', 'migration.sql'),
+    '-- fixture migration\n',
+    'utf8',
+  );
+
+  await writeFile(
+    join(stackDir, 'env'),
+    [
+      `HAPPIER_STACK_STACK=${stackName}`,
+      `HAPPIER_STACK_REPO_DIR=${root}`,
+      `HAPPIER_STACK_SERVER_COMPONENT=happier-server-light`,
+      `HAPPIER_STACK_SERVER_PORT=${resolvedServerPort}`,
+      `HAPPIER_STACK_CLI_HOME_DIR=${cliHomeDir}`,
+      'HAPPIER_STACK_RUNTIME_MODE=require',
+      'HAPPIER_STACK_TAILSCALE_SERVE=0',
+      'HAPPIER_STACK_TAILSCALE_PREFER_PUBLIC_URL=0',
+      'HAPPIER_STACK_SERVICE_MODE=0',
+      'HAPPIER_RUNTIME_SNAPSHOT_MARKER=snap-startable',
+      `HAPPIER_RUNTIME_SERVER_ENV_CAPTURE_PATH=${serverEnvCapturePath}`,
+      '',
+    ].join('\n'),
+    'utf8',
+  );
+
+  const activeServerId = buildStackStableScopeId({ stackName, cliIdentity: 'default' });
+  const credentialPaths = resolveStackCredentialPaths({
+    cliHomeDir,
+    serverUrl: `http://127.0.0.1:${resolvedServerPort}`,
+    env: { HAPPIER_ACTIVE_SERVER_ID: activeServerId },
+  });
+  await mkdir(dirname(credentialPaths.serverScopedPath), { recursive: true });
+  await writeFile(credentialPaths.serverScopedPath, 'dummy\n', 'utf8');
+  if (credentialPaths.hostPortServerScopedPath) {
+    await mkdir(dirname(credentialPaths.hostPortServerScopedPath), { recursive: true });
+    await writeFile(credentialPaths.hostPortServerScopedPath, 'dummy\n', 'utf8');
+  }
+  if (credentialPaths.urlHashServerScopedPath) {
+    await mkdir(dirname(credentialPaths.urlHashServerScopedPath), { recursive: true });
+    await writeFile(credentialPaths.urlHashServerScopedPath, 'dummy\n', 'utf8');
+  }
+  await writeFile(credentialPaths.legacyPath, 'dummy\n', 'utf8');
+  await writeFile(join(cliHomeDir, 'settings.json'), JSON.stringify({ machineId: 'runtime-fixture-machine' }) + '\n', 'utf8');
+
+  return {
+    root,
+    storageDir,
+    stackDir,
+    stackName,
+    snapshotDir,
+    cliHomeDir,
+    serverPort: resolvedServerPort,
+    serverEnvCapturePath,
+    baseUrl: `http://127.0.0.1:${resolvedServerPort}`,
+  };
+}

package/scripts/testkit/runtime_snapshot_testkit.mjs

@@ -0,0 +1,57 @@
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+import { runNodeCapture } from './core/run_node_capture.mjs';
+import { writeRuntimeSnapshotLayout } from './core/runtime_snapshot_layout.mjs';
+import { createTempFixture } from './core/temp_fixture.mjs';
+
+export const runNode = runNodeCapture;
+
+export async function createRuntimeSnapshotFixture(
+  t,
+  {
+    stackName = 'prod-dev',
+    cliEntrypoint = 'cli/happier',
+    cliStdout = 'SNAPSHOT CLI HELP',
+    cliSource = '',
+  } = {},
+) {
+  const fixture = await createTempFixture(t, { prefix: 'hstack-runtime-fixture-' });
+  const root = fixture.root;
+  const storageDir = join(root, 'storage');
+  const stackDir = join(storageDir, stackName);
+  const cliRuntimeSource = cliEntrypoint.endsWith('.mjs') || cliEntrypoint.endsWith('.js') || cliEntrypoint.endsWith('.cjs')
+    ? (cliSource || `process.stdout.write(${JSON.stringify(`${cliStdout}\n`)});\n`)
+    : `#!/bin/sh\necho ${cliStdout}\n`;
+  const { snapshotDir } = await writeRuntimeSnapshotLayout({
+    stackDir,
+    snapshotId: 'snap-1',
+    sourceFingerprint: 'src-1',
+    writeCurrentMirror: true,
+    web: {
+      content: '<html></html>\n',
+      artifactFingerprint: 'web-1',
+    },
+    server: {
+      content: '#!/bin/sh\nexit 0\n',
+      artifactFingerprint: 'srv-1',
+    },
+    daemon: {
+      entrypoint: cliEntrypoint,
+      content: cliRuntimeSource,
+      executable: !cliEntrypoint.endsWith('.mjs') && !cliEntrypoint.endsWith('.js') && !cliEntrypoint.endsWith('.cjs'),
+      artifactFingerprint: 'cli-1',
+      nodeEntrypoint: 'cli/package-dist/index.mjs',
+      nodeContent: 'export {};\n',
+    },
+  });
+  await writeFile(join(stackDir, 'env'), 'HAPPIER_STACK_SERVER_COMPONENT=happier-server-light\n', 'utf-8');
+
+  return {
+    root,
+    storageDir,
+    stackDir,
+    snapshotDir,
+    stackName,
+  };
+}

package/scripts/testkit/stack_archive_command_testkit.mjs

@@ -1,7 +1,9 @@
 import assert from 'node:assert/strict';
-import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
+import { mkdir, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
+
+import { buildGitIdentityEnv } from './core/env_scope.mjs';
+import { createTempFixture } from './core/temp_fixture.mjs';
 import { runCommandCapture } from './stack_script_command_testkit.mjs';
 
 async function runGitOk(args, { cwd, env }) {
@@ -10,24 +12,26 @@ async function runGitOk(args, { cwd, env }) {
   return res;
 }
 
-export async function createStackArchiveFixture(t, { stackName = 'exp-test', worktreeSlug = 'archived-by-stack' } = {}) {
-  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-stack-archive-'));
-  t.after(async () => {
-    await rm(tmp, { recursive: true, force: true });
-  });
+export async function createStackArchiveFixture(
+  t,
+  { stackName = 'exp-test', worktreeSlug = 'archived-by-stack', attachStack = true } = {},
+) {
+  const fixture = await createTempFixture(t, { prefix: 'happy-stacks-stack-archive-' });
+  const tmp = fixture.root;
 
   const storageDir = join(tmp, 'storage');
   const homeDir = join(tmp, 'home');
   const workspaceDir = join(tmp, 'workspace');
   const repoDir = join(workspaceDir, 'main');
   const worktreeDir = join(workspaceDir, 'pr', worktreeSlug);
-  const baseEnv = {
-    ...Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith('HAPPIER_STACK_'))),
-    GIT_TERMINAL_PROMPT: '0',
-    HAPPIER_STACK_HOME_DIR: homeDir,
-    HAPPIER_STACK_STORAGE_DIR: storageDir,
-    HAPPIER_STACK_WORKSPACE_DIR: workspaceDir,
-  };
+  const baseEnv = buildGitIdentityEnv({
+    extraEnv: {
+      GIT_TERMINAL_PROMPT: '0',
+      HAPPIER_STACK_HOME_DIR: homeDir,
+      HAPPIER_STACK_STORAGE_DIR: storageDir,
+      HAPPIER_STACK_WORKSPACE_DIR: workspaceDir,
+    },
+  });
 
   await mkdir(repoDir, { recursive: true });
   await runGitOk(['init', '-b', 'main'], { cwd: repoDir, env: baseEnv });
@@ -41,9 +45,11 @@ export async function createStackArchiveFixture(t, { stackName = 'exp-test', wor
   await runGitOk(['worktree', 'add', '-b', `pr/${worktreeSlug}`, worktreeDir, 'main'], { cwd: repoDir, env: baseEnv });
   await writeFile(join(worktreeDir, 'untracked.txt'), 'untracked\n', 'utf-8');
 
-  const envPath = join(storageDir, stackName, 'env');
-  await mkdir(dirname(envPath), { recursive: true });
-  await writeFile(envPath, [`HAPPIER_STACK_STACK=${stackName}`, `HAPPIER_STACK_REPO_DIR=${worktreeDir}`, ''].join('\n'), 'utf-8');
+  if (attachStack) {
+    const envPath = join(storageDir, stackName, 'env');
+    await mkdir(dirname(envPath), { recursive: true });
+    await writeFile(envPath, [`HAPPIER_STACK_STACK=${stackName}`, `HAPPIER_STACK_REPO_DIR=${worktreeDir}`, ''].join('\n'), 'utf-8');
+  }
 
   return {
     stackName,