happy-stacks 0.4.0 → 0.5.0

package/scripts/stack_shorthand_cmd.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, 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> <cmd> ... rewrites to happys stack <cmd> <stack> ... when stack exists', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-shorthand-'));
+
+  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 mkdir(homeDir, { recursive: true });
+  await writeFile(envPath, 'FOO=bar\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, 'env', 'path', '--json'], {
+    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 || '{}');
+  assert.equal(out.ok, true);
+  assert.ok(
+    typeof out.envPath === 'string' && out.envPath.endsWith(`/${stackName}/env`),
+    `expected envPath to end with /${stackName}/env, got: ${out.envPath}`
+  );
+});
+

package/scripts/stack_wt_list.test.mjs

@@ -0,0 +1,128 @@
+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 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) => resolve({ code: code ?? 0, stdout, stderr }));
+  });
+}
+
+async function touchWorktree(dir) {
+  await mkdir(dir, { recursive: true });
+  // In a git worktree, ".git" is often a file; our detection treats either file or dir as truthy.
+  await writeFile(join(dir, '.git'), 'gitdir: /dev/null\n', 'utf-8');
+}
+
+test('happys stack wt <stack> -- list defaults to active-only (no exhaustive enumeration)', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-stack-wt-list-'));
+
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+  const workspaceDir = join(tmp, 'workspace');
+  const componentsDir = join(workspaceDir, 'components');
+  const stackName = 'exp-test';
+
+  // Create isolated worktrees on disk (inside our temp workspace).
+  const wtRoot = join(componentsDir, '.worktrees');
+  const happyActive = join(wtRoot, 'happy', 'slopus', 'pr', 'active-branch');
+  const happyOther = join(wtRoot, 'happy', 'slopus', 'pr', 'other-branch');
+  const cliActive = join(wtRoot, 'happy-cli', 'slopus', 'pr', 'cli-active');
+  const cliOther = join(wtRoot, 'happy-cli', 'slopus', 'pr', 'cli-other');
+  await touchWorktree(happyActive);
+  await touchWorktree(happyOther);
+  await touchWorktree(cliActive);
+  await touchWorktree(cliOther);
+
+  // Stack env selects the active worktrees.
+  const envPath = join(storageDir, stackName, 'env');
+  await mkdir(dirname(envPath), { recursive: true });
+  await writeFile(
+    envPath,
+    [
+      `HAPPY_STACKS_STACK=${stackName}`,
+      `HAPPY_STACKS_COMPONENT_DIR_HAPPY=${happyActive}`,
+      `HAPPY_STACKS_COMPONENT_DIR_HAPPY_CLI=${cliActive}`,
+      '',
+    ].join('\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,
+    HAPPY_STACKS_WORKSPACE_DIR: workspaceDir,
+  };
+
+  const res = await runNode([join(rootDir, 'scripts', 'stack.mjs'), 'wt', stackName, '--', 'list'], { 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(`- active: ${happyActive}`), `expected happy active in output\n${res.stdout}`);
+  assert.ok(res.stdout.includes(`- active: ${cliActive}`), `expected happy-cli active in output\n${res.stdout}`);
+
+  // Should NOT enumerate other worktrees unless --all was passed.
+  assert.ok(!res.stdout.includes(`- ${happyOther}`), `expected happy other to be omitted\n${res.stdout}`);
+  assert.ok(!res.stdout.includes(`- ${cliOther}`), `expected happy-cli other to be omitted\n${res.stdout}`);
+});
+
+test('happys stack wt <stack> -- list --all shows all worktrees (opt-in)', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-stacks-stack-wt-list-'));
+
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+  const workspaceDir = join(tmp, 'workspace');
+  const componentsDir = join(workspaceDir, 'components');
+  const stackName = 'exp-test';
+
+  const wtRoot = join(componentsDir, '.worktrees');
+  const happyActive = join(wtRoot, 'happy', 'slopus', 'pr', 'active-branch');
+  const happyOther = join(wtRoot, 'happy', 'slopus', 'pr', 'other-branch');
+  await touchWorktree(happyActive);
+  await touchWorktree(happyOther);
+
+  const envPath = join(storageDir, stackName, 'env');
+  await mkdir(dirname(envPath), { recursive: true });
+  await writeFile(
+    envPath,
+    [`HAPPY_STACKS_STACK=${stackName}`, `HAPPY_STACKS_COMPONENT_DIR_HAPPY=${happyActive}`, ''].join('\n'),
+    'utf-8'
+  );
+
+  const baseEnv = {
+    ...process.env,
+    HAPPY_STACKS_HOME_DIR: homeDir,
+    HAPPY_STACKS_STORAGE_DIR: storageDir,
+    HAPPY_STACKS_WORKSPACE_DIR: workspaceDir,
+  };
+
+  const res = await runNode([join(rootDir, 'scripts', 'stack.mjs'), 'wt', stackName, '--', 'list', '--all'], {
+    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(`- active: ${happyActive}`), `expected happy active in output\n${res.stdout}`);
+  assert.ok(res.stdout.includes(`- ${happyOther}`), `expected happy other to be listed with --all\n${res.stdout}`);
+});
+

package/scripts/tui.mjs

@@ -1,5 +1,6 @@
 import './utils/env/env.mjs';
 import { spawn } from 'node:child_process';
+import { mkdir } from 'node:fs/promises';
 import { join, resolve, sep } from 'node:path';
 
 import { printResult } from './utils/cli/cli.mjs';
@@ -115,6 +116,76 @@ function inferStackNameFromForwardedArgs(args) {
 
 const readEnvObject = readEnvObjectFromFile;
 
+async function preflightCorepackYarnForStack({ envPath }) {
+  // Corepack caches (and therefore "download yarn?" prompts) are tied to XDG/HOME.
+  // In stack mode we isolate HOME/XDG caches per stack, which can cause Corepack to prompt
+  // the first time a stack runs Yarn.
+  //
+  // In `happys tui`, the child runs under a pseudo-TTY (via `script`) and the TUI consumes
+  // all keyboard input, so Corepack's interactive prompt deadlocks.
+  //
+  // Fix: pre-download Yarn in a *non-tty* subprocess using the stack's isolated HOME/XDG,
+  // so later pty runs don't prompt.
+  if (!envPath) return;
+  const baseDir = resolve(join(envPath, '..'));
+  const stackHome = join(baseDir, 'home');
+  const cacheBase = join(baseDir, 'cache');
+  const env = {
+    ...process.env,
+    HOME: stackHome,
+    USERPROFILE: stackHome,
+    XDG_CACHE_HOME: join(cacheBase, 'xdg'),
+    YARN_CACHE_FOLDER: join(cacheBase, 'yarn'),
+    npm_config_cache: join(cacheBase, 'npm'),
+    // Avoid Corepack mutating package.json automatically.
+    COREPACK_ENABLE_AUTO_PIN: '0',
+    // Best-effort: disable download prompts (may not be honored by all Corepack versions).
+    COREPACK_ENABLE_DOWNLOAD_PROMPT: '0',
+    // Treat this as non-interactive (helps some tooling).
+    CI: process.env.CI ?? '1',
+  };
+
+  await mkdir(stackHome, { recursive: true }).catch(() => {});
+  await mkdir(env.XDG_CACHE_HOME, { recursive: true }).catch(() => {});
+  await mkdir(env.YARN_CACHE_FOLDER, { recursive: true }).catch(() => {});
+  await mkdir(env.npm_config_cache, { recursive: true }).catch(() => {});
+  await mkdir(env.COREPACK_HOME, { recursive: true }).catch(() => {});
+
+  await new Promise((resolvePromise) => {
+    const proc = spawn('yarn', ['--version'], {
+      env,
+      cwd: baseDir,
+      // Non-tty stdio: Corepack typically won't prompt; if it does, we still provide "y\n".
+      stdio: ['pipe', 'ignore', 'ignore'],
+      shell: false,
+    });
+    try {
+      proc.stdin?.write('y\n');
+      proc.stdin?.end();
+    } catch {
+      // ignore
+    }
+
+    const t = setTimeout(() => {
+      try {
+        proc.kill('SIGKILL');
+      } catch {
+        // ignore
+      }
+      resolvePromise();
+    }, 60_000);
+
+    proc.on('exit', () => {
+      clearTimeout(t);
+      resolvePromise();
+    });
+    proc.on('error', () => {
+      clearTimeout(t);
+      resolvePromise();
+    });
+  });
+}
+
 function getEnvVal(env, key, legacyKey) {
   return getEnvValueAny(env, [key, legacyKey]) || '';
 }
@@ -294,6 +365,7 @@ async function main() {
   const forwarded = argv;
 
   const stackName = inferStackNameFromForwardedArgs(forwarded);
+  const { envPath: stackEnvPath } = resolveStackEnvPath(stackName);
 
   const panes = [
     mkPane('orch', 'orchestration', { visible: true, kind: 'log' }),
@@ -334,24 +406,38 @@ async function main() {
     pushLine(panes[paneIndexById.get('orch')], `[${nowTs()}] ${msg}`);
   };
 
+  // Preflight Yarn/Corepack for this stack before spawning the pty child.
+  // This prevents Corepack "download yarn? [Y/n]" prompts from deadlocking the TUI.
+  await preflightCorepackYarnForStack({ envPath: stackEnvPath });
+
   let layout = 'columns'; // single | split | columns
   let focused = paneIndexById.get('local'); // default focus
   let paused = false;
   let renderScheduled = false;
 
   const wantsPty = process.platform !== 'win32' && (await commandExists('script', { cwd: rootDir }));
+  // In TUI mode, we intentionally do not forward keyboard input to the child process (stdin is ignored),
+  // so any interactive prompts inside the child would deadlock.
+  // Mark the child env so dependency installers can auto-approve safe prompts (Corepack yarn downloads).
+  const childEnv = {
+    ...process.env,
+    HAPPY_STACKS_TUI: '1',
+    HAPPY_LOCAL_TUI: '1',
+    // Avoid Corepack mutating package.json automatically.
+    COREPACK_ENABLE_AUTO_PIN: '0',
+  };
   const child = wantsPty
     ? // Use a pseudo-terminal so tools like Expo print QR/status output that they hide in non-TTY mode.
       // `script` is available by default on macOS (and common on Linux).
       spawn('script', ['-q', '/dev/null', process.execPath, happysBin, ...forwarded], {
         cwd: rootDir,
-        env: { ...process.env },
+        env: childEnv,
         stdio: ['ignore', 'pipe', 'pipe'],
         detached: process.platform !== 'win32',
       })
     : spawn(process.execPath, [happysBin, ...forwarded], {
         cwd: rootDir,
-        env: { ...process.env },
+        env: childEnv,
         stdio: ['ignore', 'pipe', 'pipe'],
         detached: process.platform !== 'win32',
       });

package/scripts/utils/cli/cli_registry.mjs

@@ -34,7 +34,7 @@ export function getHappysRegistry() {
       aliases: ['setupPR', 'setuppr'],
       kind: 'node',
       scriptRelPath: 'scripts/setup_pr.mjs',
-      rootUsage: 'happys setup-pr --happy=<pr-url|number> [--happy-cli=<pr-url|number>] [--dev]',
+      rootUsage: 'happys setup-pr --happy=<pr-url|number> [--happy-server-light=<pr-url|number>] [--dev|--start] [--json] [-- ...]',
       description: 'One-shot: set up + run a PR stack (maintainer-friendly)',
     },
     {
@@ -42,7 +42,7 @@ export function getHappysRegistry() {
       aliases: ['reviewPR', 'reviewpr'],
       kind: 'node',
       scriptRelPath: 'scripts/review_pr.mjs',
-      rootUsage: 'happys review-pr --happy=<pr-url|number> [--happy-cli=<pr-url|number>] [--dev]',
+      rootUsage: 'happys review-pr --happy=<pr-url|number> [--happy-server-light=<pr-url|number>] [--dev|--start] [--json] [-- ...]',
       description: 'Run setup-pr in a temporary sandbox (auto-cleaned)',
     },
     {
@@ -54,12 +54,18 @@ export function getHappysRegistry() {
     },
     {
       name: 'where',
-      aliases: ['env'],
       kind: 'node',
       scriptRelPath: 'scripts/where.mjs',
-      rootUsage: 'happys where [--json]   (alias: env)',
+      rootUsage: 'happys where [--json]',
       description: 'Show resolved paths and env sources',
     },
+    {
+      name: 'env',
+      kind: 'node',
+      scriptRelPath: 'scripts/env.mjs',
+      rootUsage: 'happys env set KEY=VALUE [KEY2=VALUE2...]   (defaults to main stack)',
+      description: 'Set per-stack env vars (defaults to main)',
+    },
     {
       name: 'bootstrap',
       kind: 'node',
@@ -140,6 +146,13 @@ export function getHappysRegistry() {
       rootUsage: 'happys migrate light-to-server --from-stack=<name> --to-stack=<name> [--include-files] [--force] [--json]',
       description: 'Migrate data between server flavors (experimental)',
     },
+    {
+      name: 'monorepo',
+      kind: 'node',
+      scriptRelPath: 'scripts/monorepo.mjs',
+      rootUsage: 'happys monorepo port --target=/abs/path/to/monorepo [--branch=port/<name>] [--dry-run] [--3way] [--json]',
+      description: 'Port split-repo commits into monorepo (experimental)',
+    },
     {
       name: 'mobile',
       kind: 'node',
@@ -347,6 +360,9 @@ export function renderHappysRootHelp() {
     'usage:',
     ...usageLines.map((l) => `  ${l}`),
     '',
+    'stack shorthand:',
+    '  happys <stack> <command> ...   (equivalent to: happys stack <command> <stack> ...)',
+    '',
     'commands:',
     ...commandsLines,
     '',
@@ -354,4 +370,3 @@ export function renderHappysRootHelp() {
     '  happys help [command]',
   ].join('\n');
 }
-

package/scripts/utils/cli/cwd_scope.mjs

@@ -2,7 +2,7 @@ import { existsSync } from 'node:fs';
 import { dirname, join, resolve, sep } from 'node:path';
 
 import { getWorktreesRoot } from '../git/worktrees.mjs';
-import { getComponentsDir } from '../paths/paths.mjs';
+import { getComponentsDir, isHappyMonorepoRoot } from '../paths/paths.mjs';
 
 export function getInvokedCwd(env = process.env) {
   return String(env.HAPPY_STACKS_INVOKED_CWD ?? env.HAPPY_LOCAL_INVOKED_CWD ?? env.PWD ?? '').trim();
@@ -45,6 +45,24 @@ function findGitRoot(startDir, stopAtDir) {
   }
 }
 
+function resolveHappyMonorepoComponentFromPath({ monorepoRoot, absPath }) {
+  const root = resolve(monorepoRoot);
+  const abs = resolve(absPath);
+  const map = [
+    { component: 'happy', dir: join(root, 'expo-app') },
+    { component: 'happy-cli', dir: join(root, 'cli') },
+    { component: 'happy-server', dir: join(root, 'server') },
+  ];
+  for (const m of map) {
+    if (isPathInside(abs, m.dir)) {
+      // We return the shared git root so callers can safely use it as an env override
+      // for any of the monorepo components.
+      return { component: m.component, repoDir: root };
+    }
+  }
+  return null;
+}
+
 export function inferComponentFromCwd({ rootDir, invokedCwd, components }) {
   const cwd = String(invokedCwd ?? '').trim();
   const list = Array.isArray(components) ? components : [];
@@ -56,6 +74,43 @@ export function inferComponentFromCwd({ rootDir, invokedCwd, components }) {
   const componentsDir = getComponentsDir(rootDir);
   const worktreesRoot = getWorktreesRoot(rootDir);
 
+  // Monorepo-aware inference:
+  // If we're inside a happy monorepo checkout/worktree, infer which "logical component"
+  // (expo-app/cli/server) the user is working in and return that package dir.
+  //
+  // This enables workflows like:
+  // - running `happys dev` from inside components/happy/cli (should infer happy-cli)
+  // - running from inside components/.worktrees/happy/<owner>/<branch>/server (should infer happy-server)
+  {
+    const monorepoScopes = [
+      resolve(join(componentsDir, 'happy')),
+      resolve(join(worktreesRoot, 'happy')),
+    ];
+    for (const scope of monorepoScopes) {
+      if (!isPathInside(abs, scope)) continue;
+      const repoRoot = findGitRoot(abs, scope);
+      if (!repoRoot) continue;
+      if (!isHappyMonorepoRoot(repoRoot)) continue;
+
+      const inferred = resolveHappyMonorepoComponentFromPath({ monorepoRoot: repoRoot, absPath: abs });
+      if (inferred) {
+        // Only return components the caller asked us to consider.
+        if (list.includes(inferred.component)) {
+          return inferred;
+        }
+        return null;
+      }
+
+      // If we are inside the monorepo root but not inside a known package dir, default to `happy`
+      // (the UI) when the caller allows it. This keeps legacy behavior where running from the
+      // repo root still "belongs" to the UI component.
+      if (list.includes('happy')) {
+        return { component: 'happy', repoDir: repoRoot };
+      }
+      return null;
+    }
+  }
+
   for (const component of list) {
     const c = String(component ?? '').trim();
     if (!c) continue;
@@ -79,4 +134,3 @@ export function inferComponentFromCwd({ rootDir, invokedCwd, components }) {
 
   return null;
 }
-

package/scripts/utils/cli/cwd_scope.test.mjs

@@ -35,7 +35,37 @@ test('inferComponentFromCwd resolves components/<component> repo root', async (t
   assert.deepEqual(inferred, { component: 'happy', repoDir: repoRoot });
 });
 
-test('inferComponentFromCwd resolves components/.worktrees/<component>/<owner>/<branch> repo root', async (t) => {
+test('inferComponentFromCwd resolves happy monorepo subpackages under components/happy', async (t) => {
+  const rootDir = await withTempRoot(t);
+  const prevWorkspace = process.env.HAPPY_STACKS_WORKSPACE_DIR;
+  process.env.HAPPY_STACKS_WORKSPACE_DIR = rootDir;
+  t.after(() => {
+    if (prevWorkspace == null) {
+      delete process.env.HAPPY_STACKS_WORKSPACE_DIR;
+    } else {
+      process.env.HAPPY_STACKS_WORKSPACE_DIR = prevWorkspace;
+    }
+  });
+
+  const monoRoot = join(rootDir, 'components', 'happy');
+  await mkdir(join(monoRoot, 'expo-app'), { recursive: true });
+  await mkdir(join(monoRoot, 'cli', 'src'), { 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');
+  await writeFile(join(monoRoot, '.git'), 'gitdir: /tmp/fake\n', 'utf-8');
+
+  const invokedCwd = join(monoRoot, 'cli', 'src');
+  const inferred = inferComponentFromCwd({
+    rootDir,
+    invokedCwd,
+    components: ['happy', 'happy-cli', 'happy-server'],
+  });
+  assert.deepEqual(inferred, { component: 'happy-cli', repoDir: monoRoot });
+});
+
+test('inferComponentFromCwd resolves happy monorepo worktree roots under components/.worktrees/happy', async (t) => {
   const rootDir = await withTempRoot(t);
   const prevWorkspace = process.env.HAPPY_STACKS_WORKSPACE_DIR;
   process.env.HAPPY_STACKS_WORKSPACE_DIR = rootDir;
@@ -47,14 +77,18 @@ test('inferComponentFromCwd resolves components/.worktrees/<component>/<owner>/<
     }
   });
 
-  const wtRoot = join(rootDir, 'components', '.worktrees', 'happy', 'slopus', 'pr', '123-fix', 'nested');
-  await mkdir(wtRoot, { recursive: true });
   const repoRoot = join(rootDir, 'components', '.worktrees', 'happy', 'slopus', 'pr', '123-fix');
+  await mkdir(join(repoRoot, 'expo-app'), { recursive: true });
+  await mkdir(join(repoRoot, 'cli', 'nested'), { recursive: true });
+  await mkdir(join(repoRoot, 'server'), { recursive: true });
+  await writeFile(join(repoRoot, 'expo-app', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(repoRoot, 'cli', 'package.json'), '{}\n', 'utf-8');
+  await writeFile(join(repoRoot, 'server', 'package.json'), '{}\n', 'utf-8');
   await writeFile(join(repoRoot, '.git'), 'gitdir: /tmp/fake\n', 'utf-8');
 
-  const invokedCwd = join(repoRoot, 'nested');
-  const inferred = inferComponentFromCwd({ rootDir, invokedCwd, components: ['happy'] });
-  assert.deepEqual(inferred, { component: 'happy', repoDir: repoRoot });
+  const invokedCwd = join(repoRoot, 'cli', 'nested');
+  const inferred = inferComponentFromCwd({ rootDir, invokedCwd, components: ['happy', 'happy-cli', 'happy-server'] });
+  assert.deepEqual(inferred, { component: 'happy-cli', repoDir: repoRoot });
 });
 
 test('inferComponentFromCwd returns null outside known component roots', async (t) => {
@@ -74,4 +108,3 @@ test('inferComponentFromCwd returns null outside known component roots', async (
   const inferred = inferComponentFromCwd({ rootDir, invokedCwd, components: ['happy'] });
   assert.equal(inferred, null);
 });
-

package/scripts/utils/cli/prereqs.mjs

@@ -24,11 +24,15 @@ export async function assertCliPrereqs({ git = false, pnpm = false, codex = fals
 
   if (pnpm) {
     const hasPnpm = await commandExists('pnpm');
-    if (!hasPnpm) {
+    const hasYarn = await commandExists('yarn');
+    if (!hasPnpm && !hasYarn) {
       missing.push({
-        name: 'pnpm',
-        why: 'required to install dependencies for Happy Stacks components',
-        install: ['Install it via Corepack: `corepack enable && corepack prepare pnpm@latest --activate`'],
+        name: 'yarn/pnpm',
+        why: 'required to install dependencies for Happy Stacks components (varies per component)',
+        install: [
+          'Enable Corepack (recommended): `corepack enable`',
+          'Or install pnpm: `corepack prepare pnpm@latest --activate`',
+        ],
       });
     }
   }
@@ -69,4 +73,3 @@ export async function assertCliPrereqs({ git = false, pnpm = false, codex = fals
       `[prereqs] After installing, re-run the command.`
   );
 }
-

package/scripts/utils/cli/prereqs.test.mjs

@@ -0,0 +1,34 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { chmod, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { assertCliPrereqs } from './prereqs.mjs';
+
+test('assertCliPrereqs({pnpm:true}) accepts yarn when pnpm is missing', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'hs-prereqs-yarn-'));
+  const oldPath = process.env.PATH;
+  try {
+    const yarnBin = join(root, 'yarn');
+    await writeFile(yarnBin, '#!/bin/sh\nexit 0\n', 'utf-8');
+    await chmod(yarnBin, 0o755);
+    process.env.PATH = `/bin:${root}`;
+
+    await assertCliPrereqs({ pnpm: true });
+  } finally {
+    process.env.PATH = oldPath;
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('assertCliPrereqs({pnpm:true}) throws when neither pnpm nor yarn is available', async () => {
+  const oldPath = process.env.PATH;
+  try {
+    process.env.PATH = '/bin';
+    await assert.rejects(() => assertCliPrereqs({ pnpm: true }), /pnpm|yarn/i);
+  } finally {
+    process.env.PATH = oldPath;
+  }
+});
+

package/scripts/utils/cli/wizard.mjs

@@ -2,6 +2,9 @@ import { createInterface } from 'node:readline/promises';
 import { listWorktreeSpecs } from '../git/worktrees.mjs';
 
 export function isTty() {
+  if (process.env.HAPPY_STACKS_TEST_TTY === '1') {
+    return true;
+  }
   return Boolean(process.stdin.isTTY && process.stdout.isTTY);
 }
 
@@ -24,6 +27,8 @@ export async function promptSelect(rl, { title, options, defaultIndex = 0 }) {
     throw new Error('[wizard] no options to select from');
   }
   // eslint-disable-next-line no-console
+  console.log('');
+  // eslint-disable-next-line no-console
   console.log(title);
   for (let i = 0; i < options.length; i++) {
     // eslint-disable-next-line no-console
@@ -35,22 +40,26 @@ export async function promptSelect(rl, { title, options, defaultIndex = 0 }) {
   return options[idx].value;
 }
 
-export async function promptWorktreeSource({ rl, rootDir, component, stackName, createRemote = 'upstream' }) {
-  const specs = await listWorktreeSpecs({ rootDir, component });
+export async function promptWorktreeSource({ rl, rootDir, component, stackName, createRemote = 'upstream', deps = {} }) {
+  const promptFn = deps.prompt ?? prompt;
+  const promptSelectFn = deps.promptSelect ?? promptSelect;
+  const listWorktreeSpecsFn = deps.listWorktreeSpecs ?? listWorktreeSpecs;
 
   const baseOptions = [{ label: `default (components/${component})`, value: 'default' }];
-  if (specs.length) {
-    baseOptions.push({ label: 'pick existing worktree', value: 'pick' });
-  }
+  baseOptions.push({ label: 'pick existing worktree', value: 'pick' });
   baseOptions.push({ label: `create new worktree (${createRemote})`, value: 'create' });
 
-  const kind = await promptSelect(rl, { title: `Select ${component}:`, options: baseOptions, defaultIndex: 0 });
+  const kind = await promptSelectFn(rl, { title: `Select ${component}:`, options: baseOptions, defaultIndex: 0 });
 
   if (kind === 'default') {
     return 'default';
   }
   if (kind === 'pick') {
-    const picked = await promptSelect(rl, {
+    const specs = await listWorktreeSpecsFn({ rootDir, component });
+    if (!specs.length) {
+      return 'default';
+    }
+    const picked = await promptSelectFn(rl, {
       title: `Available ${component} worktrees:`,
       options: specs.map((s) => ({ label: s, value: s })),
       defaultIndex: 0,
@@ -58,7 +67,7 @@ export async function promptWorktreeSource({ rl, rootDir, component, stackName,
     return picked;
   }
 
-  const slug = await prompt(rl, `New worktree slug for ${component} (example: pr/${stackName}/${component}): `, {
+  const slug = await promptFn(rl, `New worktree slug for ${component} (example: pr/${stackName}/${component}): `, {
     defaultValue: '',
   });
   if (!slug) {
@@ -66,4 +75,3 @@ export async function promptWorktreeSource({ rl, rootDir, component, stackName,
   }
   return { create: true, slug, remote: createRemote };
 }
-