happy-stacks 0.4.0 → 0.5.0

package/scripts/stack_archive_cmd.test.mjs

@@ -0,0 +1,91 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtemp, mkdir, stat, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+function runCmd(cmd, 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(cmd, 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) => resolve({ code: code ?? 0, stdout, stderr }));
+  });
+}
+
+function runNode(args, { cwd, env }) {
+  return runCmd(process.execPath, args, { cwd, env });
+}
+
+async function runOk(cmd, args, { cwd, env }) {
+  const res = await runCmd(cmd, args, { cwd, env });
+  assert.equal(res.code, 0, `expected exit 0 for ${cmd} ${args.join(' ')}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+  return res;
+}
+
+test('happys stack archive moves the stack and archives its referenced worktrees', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-stack-archive-'));
+
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+  const workspaceDir = join(tmp, 'workspace');
+  const componentsDir = join(workspaceDir, 'components');
+
+  const baseEnv = {
+    ...Object.fromEntries(Object.entries(process.env).filter(([k]) => !k.startsWith('HAPPY_STACKS_') && !k.startsWith('HAPPY_LOCAL_'))),
+    GIT_TERMINAL_PROMPT: '0',
+    HAPPY_STACKS_HOME_DIR: homeDir,
+    HAPPY_STACKS_STORAGE_DIR: storageDir,
+    HAPPY_STACKS_WORKSPACE_DIR: workspaceDir,
+  };
+
+  // Create a minimal git repo and a worktree under components/.worktrees.
+  const repoDir = join(componentsDir, 'happy');
+  await mkdir(repoDir, { recursive: true });
+  await runOk('git', ['init', '-b', 'main'], { cwd: repoDir, env: baseEnv });
+  await runOk('git', ['config', 'user.name', 'Test'], { cwd: repoDir, env: baseEnv });
+  await runOk('git', ['config', 'user.email', 'test@example.com'], { cwd: repoDir, env: baseEnv });
+  await writeFile(join(repoDir, 'README.md'), 'hello\n', 'utf-8');
+  await runOk('git', ['add', 'README.md'], { cwd: repoDir, env: baseEnv });
+  await runOk('git', ['commit', '-m', 'init'], { cwd: repoDir, env: baseEnv });
+
+  const worktreeDir = join(componentsDir, '.worktrees', 'happy', 'slopus', 'pr', 'archived-by-stack');
+  await mkdir(dirname(worktreeDir), { recursive: true });
+  await runOk('git', ['worktree', 'add', '-b', 'slopus/pr/archived-by-stack', worktreeDir, 'main'], { cwd: repoDir, env: baseEnv });
+  await writeFile(join(worktreeDir, 'untracked.txt'), 'untracked\n', 'utf-8');
+
+  const stackName = 'exp-test';
+  const envPath = join(storageDir, stackName, 'env');
+  await mkdir(dirname(envPath), { recursive: true });
+  await writeFile(envPath, [`HAPPY_STACKS_STACK=${stackName}`, `HAPPY_STACKS_COMPONENT_DIR_HAPPY=${worktreeDir}`, ''].join('\n'), 'utf-8');
+
+  const date = '2000-01-04';
+  const nodeEnv = { ...baseEnv, PATH: '' };
+  const res = await runNode([join(rootDir, 'scripts', 'stack.mjs'), 'archive', stackName, `--date=${date}`, '--json'], {
+    cwd: rootDir,
+    env: nodeEnv,
+  });
+  assert.equal(res.code, 0, `expected stack archive exit 0\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+  const parsed = JSON.parse(res.stdout);
+  assert.equal(parsed.ok, true, `expected ok=true JSON output\n${res.stdout}`);
+
+  const archivedStackDir = join(storageDir, '.archived', date, stackName);
+  assert.equal(parsed.archivedStackDir, archivedStackDir, `expected archivedStackDir in JSON output\n${res.stdout}`);
+  await stat(join(archivedStackDir, 'env'));
+
+  const archivedWorktreeDir = join(componentsDir, '.worktrees-archive', date, 'happy', 'slopus', 'pr', 'archived-by-stack');
+  const gitStat = await stat(join(archivedWorktreeDir, '.git'));
+  assert.ok(gitStat.isDirectory(), 'expected archived worktree to be detached (standalone .git dir)');
+});

package/scripts/stack_editor_workspace_monorepo_root.test.mjs

@@ -0,0 +1,65 @@
+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 { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { writeStackCodeWorkspace } from './utils/stack/editor_workspace.mjs';
+
+test('stack code workspace groups monorepo components to the monorepo root', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-stack-workspace-mono-'));
+
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+  const stackName = 'exp-test';
+
+  const prevStorage = process.env.HAPPY_STACKS_STORAGE_DIR;
+  const prevHome = process.env.HAPPY_STACKS_HOME_DIR;
+  process.env.HAPPY_STACKS_STORAGE_DIR = storageDir;
+  process.env.HAPPY_STACKS_HOME_DIR = homeDir;
+
+  try {
+    const monoRoot = join(tmp, 'mono');
+    await mkdir(join(monoRoot, 'expo-app'), { recursive: true });
+    await mkdir(join(monoRoot, 'cli'), { recursive: true });
+    await mkdir(join(monoRoot, 'server'), { recursive: true });
+    await writeFile(join(monoRoot, 'expo-app', 'package.json'), '{}\n', 'utf-8');
+    await writeFile(join(monoRoot, 'cli', 'package.json'), '{}\n', 'utf-8');
+    await writeFile(join(monoRoot, 'server', 'package.json'), '{}\n', 'utf-8');
+
+    const envPath = join(storageDir, stackName, 'env');
+    await mkdir(dirname(envPath), { recursive: true });
+    await writeFile(
+      envPath,
+      [
+        'HAPPY_STACKS_SERVER_COMPONENT=happy-server',
+        `HAPPY_STACKS_COMPONENT_DIR_HAPPY=${join(monoRoot, 'expo-app')}`,
+        `HAPPY_STACKS_COMPONENT_DIR_HAPPY_CLI=${join(monoRoot, 'cli')}`,
+        `HAPPY_STACKS_COMPONENT_DIR_HAPPY_SERVER=${join(monoRoot, 'server')}`,
+        '',
+      ].join('\n'),
+      'utf-8'
+    );
+
+    const ws = await writeStackCodeWorkspace({
+      rootDir,
+      stackName,
+      includeStackDir: false,
+      includeAllComponents: false,
+      includeCliHome: false,
+    });
+
+    assert.equal(ws.folders.length, 1);
+    assert.equal(ws.folders[0].path, monoRoot);
+  } finally {
+    if (prevStorage == null) delete process.env.HAPPY_STACKS_STORAGE_DIR;
+    else process.env.HAPPY_STACKS_STORAGE_DIR = prevStorage;
+    if (prevHome == null) delete process.env.HAPPY_STACKS_HOME_DIR;
+    else process.env.HAPPY_STACKS_HOME_DIR = prevHome;
+    await rm(tmp, { recursive: true, force: true });
+  }
+});
+

package/scripts/stack_env_cmd.test.mjs

@@ -0,0 +1,87 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtemp, mkdir, readFile, 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) => resolve({ code: code ?? 0, stdout, stderr }));
+  });
+}
+
+test('happys stack env set/unset writes to stack env file', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-stack-env-'));
+
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+  const stackName = 'exp-test';
+
+  const envPath = join(storageDir, stackName, 'env');
+  await mkdir(dirname(envPath), { recursive: true });
+  await writeFile(envPath, 'FOO=bar\n', 'utf-8');
+
+  const baseEnv = {
+    ...process.env,
+    // Prevent loading the user's real ~/.happy-stacks/.env via canonical discovery.
+    HAPPY_STACKS_HOME_DIR: homeDir,
+    HAPPY_STACKS_STORAGE_DIR: storageDir,
+  };
+
+  const setRes = await runNode(
+    [join(rootDir, 'scripts', 'stack.mjs'), 'env', stackName, 'set', 'OPENAI_API_KEY=sk-test'],
+    { cwd: rootDir, env: baseEnv }
+  );
+  assert.equal(setRes.code, 0, `expected exit 0, got ${setRes.code}\nstdout:\n${setRes.stdout}\nstderr:\n${setRes.stderr}`);
+
+  const afterSet = await readFile(envPath, 'utf-8');
+  assert.ok(afterSet.includes('OPENAI_API_KEY=sk-test\n'), `expected env file to include OPENAI_API_KEY\n${afterSet}`);
+
+  const unsetRes = await runNode([join(rootDir, 'scripts', 'stack.mjs'), 'env', stackName, 'unset', 'FOO'], {
+    cwd: rootDir,
+    env: baseEnv,
+  });
+  assert.equal(
+    unsetRes.code,
+    0,
+    `expected exit 0, got ${unsetRes.code}\nstdout:\n${unsetRes.stdout}\nstderr:\n${unsetRes.stderr}`
+  );
+
+  const afterUnset = await readFile(envPath, 'utf-8');
+  assert.ok(!afterUnset.includes('FOO=bar'), `expected env file to remove FOO\n${afterUnset}`);
+});
+
+test('happys stack env <name> defaults to list', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-stack-env-'));
+
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+  const stackName = 'exp-test';
+
+  const envPath = join(storageDir, stackName, 'env');
+  await mkdir(dirname(envPath), { recursive: true });
+  await writeFile(envPath, 'FOO=bar\n', 'utf-8');
+
+  const baseEnv = {
+    ...process.env,
+    HAPPY_STACKS_HOME_DIR: homeDir,
+    HAPPY_STACKS_STORAGE_DIR: storageDir,
+  };
+
+  const res = await runNode([join(rootDir, 'scripts', 'stack.mjs'), 'env', stackName], { cwd: rootDir, env: baseEnv });
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+  assert.ok(res.stdout.includes('FOO=bar'), `expected stdout to include FOO=bar\nstdout:\n${res.stdout}`);
+});
+

package/scripts/stack_happy_cmd.test.mjs

@@ -0,0 +1,126 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtemp, mkdir, 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) => resolve({ code: code ?? 0, stdout, stderr }));
+  });
+}
+
+async function writeStubHappyCli({ root, message }) {
+  const cliDir = join(root, 'happy-cli');
+  await mkdir(join(cliDir, 'dist'), { recursive: true });
+  await writeFile(
+    join(cliDir, 'dist', 'index.mjs'),
+    [
+      `console.log(JSON.stringify({`,
+      `  message: ${JSON.stringify(message)},`,
+      `  stack: process.env.HAPPY_STACKS_STACK || process.env.HAPPY_LOCAL_STACK || null,`,
+      `  envFile: process.env.HAPPY_STACKS_ENV_FILE || process.env.HAPPY_LOCAL_ENV_FILE || null,`,
+      `  homeDir: process.env.HAPPY_HOME_DIR || null,`,
+      `  serverUrl: process.env.HAPPY_SERVER_URL || null,`,
+      `  webappUrl: process.env.HAPPY_WEBAPP_URL || null,`,
+      `}));`,
+    ].join('\n'),
+    'utf-8'
+  );
+  return cliDir;
+}
+
+test('happys stack happy <name> runs happy-cli under that stack env', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-stack-happy-'));
+
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+  const stackName = 'exp-test';
+
+  const stubRoot = join(tmp, 'stub-components');
+  const cliDir = await writeStubHappyCli({ root: stubRoot, message: 'hello' });
+
+  const stackCliHome = join(storageDir, stackName, 'cli');
+  const envPath = join(storageDir, stackName, 'env');
+  await mkdir(dirname(envPath), { recursive: true });
+  await writeFile(
+    envPath,
+    [
+      `HAPPY_STACKS_COMPONENT_DIR_HAPPY_CLI=${cliDir}`,
+      `HAPPY_STACKS_CLI_HOME_DIR=${stackCliHome}`,
+      `HAPPY_STACKS_SERVER_PORT=3999`,
+      '',
+    ].join('\n'),
+    'utf-8'
+  );
+
+  const baseEnv = {
+    ...process.env,
+    HAPPY_STACKS_HOME_DIR: homeDir,
+    HAPPY_STACKS_STORAGE_DIR: storageDir,
+    HAPPY_STACKS_CLI_ROOT_DISABLE: '1',
+  };
+
+  const res = await runNode([join(rootDir, 'bin', 'happys.mjs'), 'stack', 'happy', stackName], { cwd: rootDir, env: baseEnv });
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+
+  const out = JSON.parse(res.stdout.trim());
+  assert.equal(out.message, 'hello');
+  assert.equal(out.stack, stackName);
+  assert.ok(String(out.envFile).endsWith(`/${stackName}/env`), `expected envFile to end with /${stackName}/env, got: ${out.envFile}`);
+  assert.equal(out.homeDir, stackCliHome);
+  assert.equal(out.serverUrl, 'http://127.0.0.1:3999');
+});
+
+test('happys <stack> happy ... shorthand runs happy-cli under that stack env', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-stack-happy-'));
+
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+  const stackName = 'exp-test';
+
+  const stubRoot = join(tmp, 'stub-components');
+  const cliDir = await writeStubHappyCli({ root: stubRoot, message: 'shorthand' });
+
+  const stackCliHome = join(storageDir, stackName, 'cli');
+  const envPath = join(storageDir, stackName, 'env');
+  await mkdir(dirname(envPath), { recursive: true });
+  await writeFile(
+    envPath,
+    [
+      `HAPPY_STACKS_COMPONENT_DIR_HAPPY_CLI=${cliDir}`,
+      `HAPPY_STACKS_CLI_HOME_DIR=${stackCliHome}`,
+      `HAPPY_STACKS_SERVER_PORT=4101`,
+      '',
+    ].join('\n'),
+    'utf-8'
+  );
+
+  const baseEnv = {
+    ...process.env,
+    HAPPY_STACKS_HOME_DIR: homeDir,
+    HAPPY_STACKS_STORAGE_DIR: storageDir,
+    HAPPY_STACKS_CLI_ROOT_DISABLE: '1',
+  };
+
+  const res = await runNode([join(rootDir, 'bin', 'happys.mjs'), stackName, 'happy'], { cwd: rootDir, env: baseEnv });
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+
+  const out = JSON.parse(res.stdout.trim());
+  assert.equal(out.message, 'shorthand');
+  assert.equal(out.stack, stackName);
+  assert.equal(out.serverUrl, 'http://127.0.0.1:4101');
+});
+

package/scripts/stack_interactive_monorepo_group.test.mjs

@@ -0,0 +1,71 @@
+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 { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { interactiveNew } from './utils/stack/interactive_stack_config.mjs';
+
+function mkRl() {
+  return { question: async () => '' };
+}
+
+test('interactive stack new in monorepo mode does not prompt for happy-server-light worktree', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-interactive-new-mono-'));
+
+  const prevWorkspace = process.env.HAPPY_STACKS_WORKSPACE_DIR;
+  try {
+    const workspaceDir = join(tmp, 'workspace');
+    process.env.HAPPY_STACKS_WORKSPACE_DIR = workspaceDir;
+
+    const monoRoot = join(workspaceDir, 'components', '.worktrees', 'happy', 'slopus', 'tmp', 'mono-wt');
+    await mkdir(join(monoRoot, 'expo-app'), { recursive: true });
+    await mkdir(join(monoRoot, 'cli'), { recursive: true });
+    await mkdir(join(monoRoot, 'server'), { recursive: true });
+    await writeFile(join(monoRoot, '.git'), 'gitdir: dummy\n', 'utf-8');
+    await writeFile(join(monoRoot, 'expo-app', 'package.json'), '{}\n', 'utf-8');
+    await writeFile(join(monoRoot, 'cli', 'package.json'), '{}\n', 'utf-8');
+    await writeFile(join(monoRoot, 'server', 'package.json'), '{}\n', 'utf-8');
+
+    const prompted = [];
+    const out = await interactiveNew({
+      rootDir,
+      rl: mkRl(),
+      defaults: {
+        stackName: 'exp-mono-int',
+        port: 1,
+        serverComponent: 'happy-server-light',
+        createRemote: 'upstream',
+        components: { happy: null, 'happy-cli': null, 'happy-server-light': null, 'happy-server': null },
+      },
+      deps: {
+        prompt: async (_rl, question, { defaultValue } = {}) => {
+          if (question.includes('Derive happy-cli + happy-server')) return 'y';
+          return defaultValue ?? '';
+        },
+        promptWorktreeSource: async ({ component }) => {
+          prompted.push(component);
+          if (component === 'happy') return 'slopus/tmp/mono-wt';
+          throw new Error(`unexpected promptWorktreeSource call: ${component}`);
+        },
+      },
+    });
+
+    assert.deepEqual(prompted, ['happy']);
+    assert.equal(out.components.happy, 'slopus/tmp/mono-wt');
+    assert.equal(out.components['happy-cli'], null);
+    assert.equal(out.components['happy-server'], null);
+    assert.equal(out.components['happy-server-light'], null);
+  } finally {
+    if (prevWorkspace == null) {
+      delete process.env.HAPPY_STACKS_WORKSPACE_DIR;
+    } else {
+      process.env.HAPPY_STACKS_WORKSPACE_DIR = prevWorkspace;
+    }
+    await rm(tmp, { recursive: true, force: true });
+  }
+});
+

package/scripts/stack_monorepo_defaults.test.mjs

@@ -0,0 +1,62 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtemp, mkdir, readFile, 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) => resolve({ code: code ?? 0, stdout, stderr }));
+  });
+}
+
+test('happys stack new defaults to monorepo package dirs when happy is a monorepo', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-stack-monorepo-defaults-'));
+
+  const workspaceDir = join(tmp, 'workspace');
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+  const sandboxDir = join(tmp, 'sandbox');
+  const stackName = 'exp-test';
+
+  const monoRoot = join(workspaceDir, 'components', 'happy');
+  await mkdir(join(monoRoot, 'expo-app'), { recursive: true });
+  await mkdir(join(monoRoot, 'cli'), { recursive: true });
+  await mkdir(join(monoRoot, 'server'), { recursive: true });
+  await writeFile(join(monoRoot, 'expo-app', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(monoRoot, 'cli', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(monoRoot, 'server', 'package.json'), '{}\n', 'utf-8');
+  // Monorepo server-light support: sqlite schema lives under prisma/sqlite/.
+  await mkdir(join(monoRoot, 'server', 'prisma', 'sqlite'), { recursive: true });
+  await writeFile(join(monoRoot, 'server', 'prisma', 'sqlite', 'schema.prisma'), 'datasource db { provider = "sqlite" }\n', 'utf-8');
+
+  const env = {
+    ...process.env,
+    HAPPY_STACKS_HOME_DIR: homeDir,
+    HAPPY_STACKS_WORKSPACE_DIR: workspaceDir,
+    HAPPY_STACKS_STORAGE_DIR: storageDir,
+    HAPPY_STACKS_SANDBOX_DIR: sandboxDir,
+  };
+
+  const res = await runNode([join(rootDir, 'scripts', 'stack.mjs'), 'new', stackName, '--json'], { cwd: rootDir, env });
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+
+  const envPath = join(storageDir, stackName, 'env');
+  const contents = await readFile(envPath, 'utf-8');
+  assert.ok(contents.includes(`HAPPY_STACKS_COMPONENT_DIR_HAPPY=${join(monoRoot, 'expo-app')}\n`), contents);
+  assert.ok(contents.includes(`HAPPY_STACKS_COMPONENT_DIR_HAPPY_CLI=${join(monoRoot, 'cli')}\n`), contents);
+  assert.ok(contents.includes(`HAPPY_STACKS_COMPONENT_DIR_HAPPY_SERVER=${join(monoRoot, 'server')}\n`), contents);
+  assert.ok(contents.includes(`HAPPY_STACKS_COMPONENT_DIR_HAPPY_SERVER_LIGHT=${join(monoRoot, 'server')}\n`), contents);
+
+  await rm(tmp, { recursive: true, force: true });
+});

package/scripts/stack_monorepo_server_light_from_happy_spec.test.mjs

@@ -0,0 +1,66 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtemp, mkdir, readFile, 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) => resolve({ code: code ?? 0, stdout, stderr }));
+  });
+}
+
+test('happys stack new derives monorepo server-light dirs from --happy spec', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-stack-monorepo-spec-'));
+
+  const workspaceDir = join(tmp, 'workspace');
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+  const sandboxDir = join(tmp, 'sandbox');
+  const stackName = 'exp-mono-spec';
+
+  // Create a monorepo worktree somewhere other than components/happy to simulate a new stack
+  // created from a --happy spec when the default checkout isn't a monorepo.
+  const monoRoot = join(workspaceDir, 'components', '.worktrees', 'happy', 'slopus', 'tmp', 'leeroy-wip');
+  await mkdir(join(monoRoot, 'expo-app'), { recursive: true });
+  await mkdir(join(monoRoot, 'cli'), { recursive: true });
+  await mkdir(join(monoRoot, 'server', 'prisma', 'sqlite'), { recursive: true });
+  await writeFile(join(monoRoot, 'expo-app', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(monoRoot, 'cli', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(monoRoot, 'server', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(monoRoot, 'server', 'prisma', 'schema.prisma'), 'datasource db { provider = "postgresql" }\n', 'utf-8');
+  await writeFile(join(monoRoot, 'server', 'prisma', 'sqlite', 'schema.prisma'), 'datasource db { provider = "sqlite" }\n', 'utf-8');
+
+  const env = {
+    ...process.env,
+    HAPPY_STACKS_HOME_DIR: homeDir,
+    HAPPY_STACKS_WORKSPACE_DIR: workspaceDir,
+    HAPPY_STACKS_STORAGE_DIR: storageDir,
+    HAPPY_STACKS_SANDBOX_DIR: sandboxDir,
+  };
+
+  const res = await runNode(
+    [join(rootDir, 'scripts', 'stack.mjs'), 'new', stackName, `--happy=${monoRoot}`, '--server=happy-server-light', '--no-copy-auth', '--json'],
+    { cwd: rootDir, env },
+  );
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+
+  const envPath = join(storageDir, stackName, 'env');
+  const contents = await readFile(envPath, 'utf-8');
+  assert.ok(contents.includes(`HAPPY_STACKS_COMPONENT_DIR_HAPPY=${join(monoRoot, 'expo-app')}\n`), contents);
+  assert.ok(contents.includes(`HAPPY_STACKS_COMPONENT_DIR_HAPPY_CLI=${join(monoRoot, 'cli')}\n`), contents);
+  assert.ok(contents.includes(`HAPPY_STACKS_COMPONENT_DIR_HAPPY_SERVER=${join(monoRoot, 'server')}\n`), contents);
+  assert.ok(contents.includes(`HAPPY_STACKS_COMPONENT_DIR_HAPPY_SERVER_LIGHT=${join(monoRoot, 'server')}\n`), contents);
+
+  await rm(tmp, { recursive: true, force: true });
+});

package/scripts/stack_server_flavors_defaults.test.mjs

@@ -0,0 +1,55 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtemp, mkdir, readFile, 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) => resolve({ code: code ?? 0, stdout, stderr }));
+  });
+}
+
+test('happys stack new pins happy-server-light dir to happy-server when unified schema exists', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-stack-server-flavors-'));
+
+  const workspaceDir = join(tmp, 'workspace');
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+  const sandboxDir = join(tmp, 'sandbox');
+  const stackName = 'exp-flavors';
+
+  const fullDir = join(workspaceDir, 'components', 'happy-server');
+  await mkdir(join(fullDir, 'prisma'), { recursive: true });
+  await writeFile(join(fullDir, 'prisma', 'schema.sqlite.prisma'), 'datasource db { provider = "sqlite" }\n', 'utf-8');
+  await writeFile(join(fullDir, 'package.json'), '{}\n', 'utf-8');
+
+  const env = {
+    ...process.env,
+    HAPPY_STACKS_HOME_DIR: homeDir,
+    HAPPY_STACKS_WORKSPACE_DIR: workspaceDir,
+    HAPPY_STACKS_STORAGE_DIR: storageDir,
+    HAPPY_STACKS_SANDBOX_DIR: sandboxDir,
+  };
+
+  const res = await runNode([join(rootDir, 'scripts', 'stack.mjs'), 'new', stackName, '--json'], { cwd: rootDir, env });
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+
+  const envPath = join(storageDir, stackName, 'env');
+  const contents = await readFile(envPath, 'utf-8');
+  assert.ok(contents.includes(`HAPPY_STACKS_COMPONENT_DIR_HAPPY_SERVER=${fullDir}\n`), contents);
+  assert.ok(contents.includes(`HAPPY_STACKS_COMPONENT_DIR_HAPPY_SERVER_LIGHT=${fullDir}\n`), contents);
+
+  await rm(tmp, { recursive: true, force: true });
+});
+