happy-stacks 0.4.0 → 0.5.0

package/scripts/utils/git/worktrees.mjs

@@ -1,6 +1,12 @@
+import { existsSync } from 'node:fs';
 import { readdir } from 'node:fs/promises';
-import { isAbsolute, join, resolve } from 'node:path';
-import { getComponentsDir } from '../paths/paths.mjs';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+import {
+  coerceHappyMonorepoRootFromPath,
+  getComponentRepoDir,
+  getComponentsDir,
+  happyMonorepoSubdirForComponent,
+} from '../paths/paths.mjs';
 import { pathExists } from '../fs/fs.mjs';
 import { run, runCapture } from '../proc/proc.mjs';
 
@@ -20,14 +26,24 @@ export function getWorktreesRoot(rootDir, env = process.env) {
 }
 
 export function componentRepoDir(rootDir, component, env = process.env) {
-  return join(getComponentsDir(rootDir, env), component);
+  return getComponentRepoDir(rootDir, component, env);
+}
+
+function worktreeRepoKeyForComponent({ rootDir, component, env = process.env }) {
+  const c = String(component ?? '').trim();
+  const repoDir = componentRepoDir(rootDir, c, env);
+  const mono = coerceHappyMonorepoRootFromPath(repoDir);
+  // In monorepo mode, all worktrees live under `.worktrees/happy/` regardless of which
+  // package (expo-app/cli/server) the user is operating on.
+  return mono ? 'happy' : c;
 }
 
 export function isComponentWorktreePath({ rootDir, component, dir, env = process.env }) {
   const raw = String(dir ?? '').trim();
   if (!raw) return false;
   const abs = resolve(raw);
-  const root = resolve(join(getWorktreesRoot(rootDir, env), component)) + '/';
+  const key = worktreeRepoKeyForComponent({ rootDir, component, env });
+  const root = resolve(join(getWorktreesRoot(rootDir, env), key)) + '/';
   return abs.startsWith(root);
 }
 
@@ -36,10 +52,24 @@ export function worktreeSpecFromDir({ rootDir, component, dir, env = process.env
   if (!raw) return null;
   if (!isComponentWorktreePath({ rootDir, component, dir: raw, env })) return null;
   const abs = resolve(raw);
-  const root = resolve(join(getWorktreesRoot(rootDir, env), component)) + '/';
-  const rel = abs.slice(root.length).split('/').filter(Boolean);
+  const key = worktreeRepoKeyForComponent({ rootDir, component, env });
+  const base = resolve(join(getWorktreesRoot(rootDir, env), key));
+
+  // Normalize to the actual worktree root directory (the one containing `.git`) so
+  // package subdirectories like `.../cli` don't corrupt the computed spec.
+  let cur = abs;
+  while (cur && cur !== base && cur !== dirname(cur)) {
+    if (existsSync(join(cur, '.git'))) {
+      break;
+    }
+    cur = dirname(cur);
+  }
+  if (!cur || cur === base || cur === dirname(cur)) return null;
+
+  const root = base + '/';
+  if (!cur.startsWith(root)) return null;
+  const rel = cur.slice(root.length).split('/').filter(Boolean);
   if (rel.length < 2) return null;
-  // rel = [owner, ...branchParts]
   return rel.join('/');
 }
 
@@ -77,7 +107,11 @@ export async function createWorktreeFromBaseWorktree({
 
   const repoDir = componentRepoDir(rootDir, component, env);
   const owner = await getRemoteOwner({ repoDir, remoteName });
-  return join(getWorktreesRoot(rootDir, env), component, owner, ...slug.split('/'));
+  const key = worktreeRepoKeyForComponent({ rootDir, component, env });
+  const wtRoot = join(getWorktreesRoot(rootDir, env), key, owner, ...slug.split('/'));
+  const sub = happyMonorepoSubdirForComponent(component);
+  const monoRoot = sub ? coerceHappyMonorepoRootFromPath(wtRoot) : null;
+  return sub && monoRoot ? join(monoRoot, sub) : wtRoot;
 }
 
 export function resolveComponentSpecToDir({ rootDir, component, spec, env = process.env }) {
@@ -86,14 +120,24 @@ export function resolveComponentSpecToDir({ rootDir, component, spec, env = proc
     return null;
   }
   if (isAbsolute(raw)) {
+    const monoRoot = coerceHappyMonorepoRootFromPath(raw);
+    const sub = happyMonorepoSubdirForComponent(component);
+    if (monoRoot && sub) {
+      return join(monoRoot, sub);
+    }
     return raw;
   }
-  // Treat as <owner>/<branch...> under components/.worktrees/<component>/...
-  return join(getWorktreesRoot(rootDir, env), component, ...raw.split('/'));
+  // Treat as <owner>/<branch...> under components/.worktrees/<repoKey>/...
+  const key = worktreeRepoKeyForComponent({ rootDir, component, env });
+  const wtRoot = join(getWorktreesRoot(rootDir, env), key, ...raw.split('/'));
+  const sub = happyMonorepoSubdirForComponent(component);
+  const monoRoot = sub ? coerceHappyMonorepoRootFromPath(wtRoot) : null;
+  return sub && monoRoot ? join(monoRoot, sub) : wtRoot;
 }
 
 export async function listWorktreeSpecs({ rootDir, component, env = process.env }) {
-  const dir = join(getWorktreesRoot(rootDir, env), component);
+  const key = worktreeRepoKeyForComponent({ rootDir, component, env });
+  const dir = join(getWorktreesRoot(rootDir, env), key);
   const specs = [];
   try {
     const walk = async (d, prefixParts) => {
@@ -104,6 +148,9 @@ export async function listWorktreeSpecs({ rootDir, component, env = process.env
         const nextPrefix = [...prefixParts, e.name];
         if (await pathExists(join(p, '.git'))) {
           specs.push(nextPrefix.join('/'));
+          // IMPORTANT: do not recurse into worktree roots (they contain full repos and can be huge).
+          // Worktrees are leaf nodes for our purposes.
+          continue;
         }
         await walk(p, nextPrefix);
       }
@@ -134,5 +181,9 @@ export async function createWorktree({ rootDir, component, slug, remoteName = 'u
   });
   const repoDir = componentRepoDir(rootDir, component, env);
   const owner = await getRemoteOwner({ repoDir, remoteName });
-  return join(getWorktreesRoot(rootDir, env), component, owner, ...slug.split('/'));
+  const key = worktreeRepoKeyForComponent({ rootDir, component, env });
+  const wtRoot = join(getWorktreesRoot(rootDir, env), key, owner, ...slug.split('/'));
+  const sub = happyMonorepoSubdirForComponent(component);
+  const monoRoot = sub ? coerceHappyMonorepoRootFromPath(wtRoot) : null;
+  return sub && monoRoot ? join(monoRoot, sub) : wtRoot;
 }

package/scripts/utils/git/worktrees_monorepo.test.mjs

@@ -0,0 +1,54 @@
+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 { join } from 'node:path';
+
+import { worktreeSpecFromDir } from './worktrees.mjs';
+
+async function withTempRoot(t) {
+  const dir = await mkdtemp(join(tmpdir(), 'happy-stacks-worktrees-monorepo-'));
+  t.after(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+  return dir;
+}
+
+async function writeHappyMonorepoStub({ rootDir, worktreeRoot }) {
+  const monoRoot = join(rootDir, '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');
+
+  // Also stub a monorepo worktree root (same structure) for spec parsing.
+  await mkdir(join(worktreeRoot, 'expo-app'), { recursive: true });
+  await mkdir(join(worktreeRoot, 'cli'), { recursive: true });
+  await mkdir(join(worktreeRoot, 'server'), { recursive: true });
+  await writeFile(join(worktreeRoot, '.git'), 'gitdir: /tmp/fake\n', 'utf-8');
+  return { monoRoot };
+}
+
+test('worktreeSpecFromDir normalizes monorepo package dirs to the worktree spec', async (t) => {
+  const rootDir = await withTempRoot(t);
+  const env = { HAPPY_STACKS_WORKSPACE_DIR: rootDir };
+
+  const wtRoot = join(rootDir, 'components', '.worktrees', 'happy', 'slopus', 'pr', '123-fix-monorepo');
+  await mkdir(wtRoot, { recursive: true });
+  await writeHappyMonorepoStub({ rootDir, worktreeRoot: wtRoot });
+
+  assert.equal(
+    worktreeSpecFromDir({ rootDir, component: 'happy', dir: join(wtRoot, 'expo-app'), env }),
+    'slopus/pr/123-fix-monorepo'
+  );
+  assert.equal(
+    worktreeSpecFromDir({ rootDir, component: 'happy-cli', dir: join(wtRoot, 'cli'), env }),
+    'slopus/pr/123-fix-monorepo'
+  );
+  assert.equal(
+    worktreeSpecFromDir({ rootDir, component: 'happy-server', dir: join(wtRoot, 'server'), env }),
+    'slopus/pr/123-fix-monorepo'
+  );
+});

package/scripts/utils/net/tcp_forward.mjs

@@ -0,0 +1,162 @@
+/**
+ * Lightweight TCP port forwarder using Node.js built-in `net` module.
+ *
+ * Used to expose Expo dev server (which binds to LAN IP) on the Tailscale interface,
+ * enabling remote device access over Tailscale without modifying Expo's binding behavior.
+ *
+ * Can be run standalone:
+ *   node tcp_forward.mjs --listen-host=100.x.y.z --listen-port=8081 --target-host=192.168.1.50 --target-port=8081
+ *
+ * Or imported and spawned as a managed child process.
+ */
+
+import net from 'node:net';
+
+/**
+ * Create a TCP forwarding server.
+ *
+ * @param {Object} options
+ * @param {string} options.listenHost - Host/IP to listen on (e.g., Tailscale IP)
+ * @param {number} options.listenPort - Port to listen on
+ * @param {string} options.targetHost - Host/IP to forward to (e.g., LAN IP or 127.0.0.1)
+ * @param {number} options.targetPort - Port to forward to
+ * @param {string} [options.label] - Label for logging (default: 'tcp-forward')
+ * @returns {net.Server}
+ */
+export function createTcpForwarder({ listenHost, listenPort, targetHost, targetPort, label = 'tcp-forward' }) {
+  const server = net.createServer((clientSocket) => {
+    const targetSocket = net.createConnection({ host: targetHost, port: targetPort }, () => {
+      // Connection established, pipe data both ways
+      clientSocket.pipe(targetSocket);
+      targetSocket.pipe(clientSocket);
+    });
+
+    // Handle errors on both sockets
+    clientSocket.on('error', (err) => {
+      if (err.code !== 'ECONNRESET') {
+        process.stderr.write(`[${label}] client error: ${err.message}\n`);
+      }
+      targetSocket.destroy();
+    });
+
+    targetSocket.on('error', (err) => {
+      if (err.code !== 'ECONNRESET' && err.code !== 'ECONNREFUSED') {
+        process.stderr.write(`[${label}] target error: ${err.message}\n`);
+      }
+      clientSocket.destroy();
+    });
+
+    // Clean up on close
+    clientSocket.on('close', () => targetSocket.destroy());
+    targetSocket.on('close', () => clientSocket.destroy());
+  });
+
+  server.on('error', (err) => {
+    process.stderr.write(`[${label}] server error: ${err.message}\n`);
+  });
+
+  return server;
+}
+
+/**
+ * Start a TCP forwarder and return a promise that resolves when listening.
+ *
+ * @param {Object} options - Same as createTcpForwarder
+ * @returns {Promise<{ server: net.Server, address: string, port: number }>}
+ */
+export async function startTcpForwarder(options) {
+  const { listenHost, listenPort, label = 'tcp-forward' } = options;
+  const server = createTcpForwarder(options);
+
+  return new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(listenPort, listenHost, () => {
+      server.removeListener('error', reject);
+      const addr = server.address();
+      const address = typeof addr === 'object' ? addr.address : listenHost;
+      const port = typeof addr === 'object' ? addr.port : listenPort;
+      process.stdout.write(`[${label}] forwarding ${address}:${port} -> ${options.targetHost}:${options.targetPort}\n`);
+      resolve({ server, address, port });
+    });
+  });
+}
+
+function trySendIpc(msg) {
+  try {
+    if (typeof process.send === 'function') {
+      process.send(msg);
+    }
+  } catch {
+    // ignore
+  }
+}
+
+/**
+ * Gracefully stop a TCP forwarder server.
+ *
+ * @param {net.Server} server
+ * @param {string} [label]
+ * @returns {Promise<void>}
+ */
+export async function stopTcpForwarder(server, label = 'tcp-forward') {
+  if (!server) return;
+  return new Promise((resolve) => {
+    server.close(() => {
+      process.stdout.write(`[${label}] stopped\n`);
+      resolve();
+    });
+    // Force-close after timeout
+    setTimeout(() => {
+      resolve();
+    }, 2000);
+  });
+}
+
+// Standalone CLI mode
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const args = process.argv.slice(2);
+  const kv = new Map();
+  for (const arg of args) {
+    const m = arg.match(/^--([^=]+)=(.*)$/);
+    if (m) kv.set(m[1], m[2]);
+  }
+
+  const listenHost = kv.get('listen-host') || kv.get('listenHost');
+  const listenPort = Number(kv.get('listen-port') || kv.get('listenPort'));
+  const targetHost = kv.get('target-host') || kv.get('targetHost') || '127.0.0.1';
+  const targetPort = Number(kv.get('target-port') || kv.get('targetPort'));
+  const label = kv.get('label') || 'tcp-forward';
+
+  if (!listenHost || !listenPort || !targetPort) {
+    console.error('Usage: node tcp_forward.mjs --listen-host=<ip> --listen-port=<port> --target-host=<ip> --target-port=<port> [--label=<label>]');
+    process.exit(1);
+  }
+
+  const shutdown = () => {
+    process.stdout.write(`\n[${label}] shutting down...\n`);
+    process.exit(0);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+
+  startTcpForwarder({ listenHost, listenPort, targetHost, targetPort, label })
+    .then(() => {
+      trySendIpc({ type: 'ready', listenHost, listenPort, targetHost, targetPort, label });
+      // Keep running until signal
+    })
+    .catch((err) => {
+      trySendIpc({
+        type: 'error',
+        code: err && typeof err === 'object' ? err.code : null,
+        message: err instanceof Error ? err.message : String(err ?? 'unknown error'),
+        listenHost,
+        listenPort,
+        targetHost,
+        targetPort,
+        label,
+      });
+      console.error(`[${label}] failed to start: ${err.message}`);
+      process.exit(1);
+    });
+}

package/scripts/utils/paths/paths.mjs

@@ -14,6 +14,18 @@ const PRIMARY_STORAGE_ROOT = join(homedir(), '.happy', 'stacks');
 const LEGACY_STORAGE_ROOT = join(homedir(), '.happy', 'local');
 const PRIMARY_HOME_DIR = join(homedir(), '.happy-stacks');
 
+// Upstream monorepo layout (slopus/happy):
+// - expo-app/ (Happy UI)
+// - cli/      (happy-cli)
+// - server/   (happy-server)
+const HAPPY_MONOREPO_COMPONENT_SUBDIR = {
+  happy: 'expo-app',
+  'happy-cli': 'cli',
+  'happy-server': 'server',
+  // Server flavors share a single server package in the monorepo.
+  'happy-server-light': 'server',
+};
+
 export function getRootDir(importMetaUrl) {
   return dirname(dirname(fileURLToPath(importMetaUrl)));
 }
@@ -61,14 +73,118 @@ function normalizePathForEnv(rootDir, raw, env = process.env) {
   return expanded.startsWith('/') ? expanded : resolve(workspaceDir, expanded);
 }
 
+export function isHappyMonorepoComponentName(name) {
+  return Object.prototype.hasOwnProperty.call(HAPPY_MONOREPO_COMPONENT_SUBDIR, String(name ?? '').trim());
+}
+
+export function happyMonorepoSubdirForComponent(name) {
+  return HAPPY_MONOREPO_COMPONENT_SUBDIR[String(name ?? '').trim()] ?? null;
+}
+
+export function isHappyMonorepoRoot(dir) {
+  const d = String(dir ?? '').trim();
+  if (!d) return false;
+  try {
+    return (
+      existsSync(join(d, 'expo-app', 'package.json')) &&
+      existsSync(join(d, 'cli', 'package.json')) &&
+      existsSync(join(d, 'server', 'package.json'))
+    );
+  } catch {
+    return false;
+  }
+}
+
+export function coerceHappyMonorepoRootFromPath(path) {
+  const p = String(path ?? '').trim();
+  if (!p) return null;
+  let cur = resolve(p);
+  while (true) {
+    if (isHappyMonorepoRoot(cur)) return cur;
+    const parent = dirname(cur);
+    if (parent === cur) return null;
+    cur = parent;
+  }
+}
+
+function resolveHappyMonorepoPackageDir({ monorepoRoot, component }) {
+  const sub = happyMonorepoSubdirForComponent(component);
+  if (!sub) return null;
+  return join(monorepoRoot, sub);
+}
+
+export function getComponentRepoDir(rootDir, name, env = process.env) {
+  const componentDir = getComponentDir(rootDir, name, env);
+  const n = String(name ?? '').trim();
+  if (isHappyMonorepoComponentName(n)) {
+    const root = coerceHappyMonorepoRootFromPath(componentDir);
+    if (root) return root;
+  }
+  return componentDir;
+}
+
 export function getComponentDir(rootDir, name, env = process.env) {
   const stacksKey = componentDirEnvKey(name);
   const legacyKey = stacksKey.replace(/^HAPPY_STACKS_/, 'HAPPY_LOCAL_');
   const fromEnv = normalizePathForEnv(rootDir, env[stacksKey] ?? env[legacyKey], env);
-  if (fromEnv) {
+  const n = String(name ?? '').trim();
+
+  // If the component is part of the happy monorepo, allow pointing the env var at either:
+  // - the monorepo root, OR
+  // - the package directory (expo-app/cli/server), OR
+  // - any path inside those (we normalize to the package dir).
+  if (fromEnv && isHappyMonorepoComponentName(n)) {
+    const root = coerceHappyMonorepoRootFromPath(fromEnv);
+    if (root) {
+      const pkg = resolveHappyMonorepoPackageDir({ monorepoRoot: root, component: n });
+      return pkg || fromEnv;
+    }
     return fromEnv;
   }
-  return join(getComponentsDir(rootDir, env), name);
+
+  if (fromEnv) return fromEnv;
+
+  const componentsDir = getComponentsDir(rootDir, env);
+  const defaultDir = join(componentsDir, n);
+
+  // Unified server flavors:
+  // If happy-server-light isn't explicitly configured, allow it to reuse the happy-server checkout
+  // when that checkout contains the sqlite schema (new: prisma/sqlite/schema.prisma; legacy: prisma/schema.sqlite.prisma).
+  if (n === 'happy-server-light') {
+    const fullServerDir = getComponentDir(rootDir, 'happy-server', env);
+    try {
+      if (
+        fullServerDir &&
+        (existsSync(join(fullServerDir, 'prisma', 'sqlite', 'schema.prisma')) ||
+          existsSync(join(fullServerDir, 'prisma', 'schema.sqlite.prisma')))
+      ) {
+        return fullServerDir;
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  // Monorepo default behavior:
+  // - If components/happy is a monorepo checkout, derive all monorepo component dirs from it.
+  // - This allows a single checkout at components/happy to satisfy happy, happy-cli, and happy-server.
+  if (isHappyMonorepoComponentName(n)) {
+    // If the defaultDir is itself a monorepo root (common for "happy"), map to its package dir.
+    if (existsSync(defaultDir) && isHappyMonorepoRoot(defaultDir)) {
+      return resolveHappyMonorepoPackageDir({ monorepoRoot: defaultDir, component: n }) || defaultDir;
+    }
+    // If the legacy defaultDir exists (multi-repo), keep it.
+    if (existsSync(defaultDir) && existsSync(join(defaultDir, 'package.json'))) {
+      return defaultDir;
+    }
+    // Fallback: derive from the monorepo root at components/happy if present.
+    const monorepoRoot = join(componentsDir, 'happy');
+    if (existsSync(monorepoRoot) && isHappyMonorepoRoot(monorepoRoot)) {
+      return resolveHappyMonorepoPackageDir({ monorepoRoot, component: n }) || defaultDir;
+    }
+  }
+
+  return defaultDir;
 }
 
 export function getStackName(env = process.env) {
@@ -191,4 +307,3 @@ export function getDefaultAutostartPaths(env = process.env) {
     legacyStderrPath,
   };
 }
-

package/scripts/utils/paths/paths_monorepo.test.mjs

@@ -0,0 +1,58 @@
+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 { join } from 'node:path';
+
+import { getComponentDir, getComponentRepoDir } from './paths.mjs';
+
+async function withTempRoot(t) {
+  const dir = await mkdtemp(join(tmpdir(), 'happy-stacks-paths-monorepo-'));
+  t.after(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+  return dir;
+}
+
+async function writeHappyMonorepoStub({ rootDir }) {
+  const monoRoot = join(rootDir, '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');
+  return monoRoot;
+}
+
+test('getComponentDir derives monorepo component package dirs from components/happy', async (t) => {
+  const rootDir = await withTempRoot(t);
+  const env = { HAPPY_STACKS_WORKSPACE_DIR: rootDir };
+
+  const monoRoot = await writeHappyMonorepoStub({ rootDir });
+  assert.equal(getComponentDir(rootDir, 'happy', env), join(monoRoot, 'expo-app'));
+  assert.equal(getComponentDir(rootDir, 'happy-cli', env), join(monoRoot, 'cli'));
+  assert.equal(getComponentDir(rootDir, 'happy-server', env), join(monoRoot, 'server'));
+  assert.equal(getComponentDir(rootDir, 'happy-server-light', env), join(monoRoot, 'server'));
+});
+
+test('getComponentRepoDir returns the shared monorepo root for monorepo components', async (t) => {
+  const rootDir = await withTempRoot(t);
+  const env = { HAPPY_STACKS_WORKSPACE_DIR: rootDir };
+
+  const monoRoot = await writeHappyMonorepoStub({ rootDir });
+  assert.equal(getComponentRepoDir(rootDir, 'happy', env), monoRoot);
+  assert.equal(getComponentRepoDir(rootDir, 'happy-cli', env), monoRoot);
+  assert.equal(getComponentRepoDir(rootDir, 'happy-server', env), monoRoot);
+  assert.equal(getComponentRepoDir(rootDir, 'happy-server-light', env), monoRoot);
+});
+
+test('getComponentDir normalizes monorepo env overrides that point inside the repo', async (t) => {
+  const rootDir = await withTempRoot(t);
+  const env = { HAPPY_STACKS_WORKSPACE_DIR: rootDir };
+
+  const monoRoot = await writeHappyMonorepoStub({ rootDir });
+
+  env.HAPPY_STACKS_COMPONENT_DIR_HAPPY_CLI = join(monoRoot, 'cli', 'src');
+  assert.equal(getComponentDir(rootDir, 'happy-cli', env), join(monoRoot, 'cli'));
+});

package/scripts/utils/paths/paths_server_flavors.test.mjs

@@ -0,0 +1,45 @@
+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 { join } from 'node:path';
+
+import { getComponentDir } from './paths.mjs';
+
+test('getComponentDir prefers happy-server for happy-server-light when unified schema exists', async (t) => {
+  const rootDir = await mkdtemp(join(tmpdir(), 'happy-stacks-paths-server-flavors-'));
+  t.after(async () => {
+    await rm(rootDir, { recursive: true, force: true });
+  });
+
+  const env = { HAPPY_STACKS_WORKSPACE_DIR: rootDir };
+  const fullDir = join(rootDir, 'components', 'happy-server');
+  await mkdir(join(fullDir, 'prisma', 'sqlite'), { recursive: true });
+  await writeFile(join(fullDir, 'prisma', 'sqlite', 'schema.prisma'), 'datasource db { provider = "sqlite" }\n', 'utf-8');
+
+  assert.equal(getComponentDir(rootDir, 'happy-server-light', env), fullDir);
+});
+
+test('getComponentDir falls back to components/happy-server-light when unified schema is missing', async (t) => {
+  const rootDir = await mkdtemp(join(tmpdir(), 'happy-stacks-paths-server-flavors-'));
+  t.after(async () => {
+    await rm(rootDir, { recursive: true, force: true });
+  });
+
+  const env = { HAPPY_STACKS_WORKSPACE_DIR: rootDir };
+  const expected = join(rootDir, 'components', 'happy-server-light');
+  assert.equal(getComponentDir(rootDir, 'happy-server-light', env), expected);
+});
+
+test('getComponentDir does not alias when HAPPY_STACKS_COMPONENT_DIR_HAPPY_SERVER_LIGHT is set', async (t) => {
+  const rootDir = await mkdtemp(join(tmpdir(), 'happy-stacks-paths-server-flavors-'));
+  t.after(async () => {
+    await rm(rootDir, { recursive: true, force: true });
+  });
+
+  const env = {
+    HAPPY_STACKS_WORKSPACE_DIR: rootDir,
+    HAPPY_STACKS_COMPONENT_DIR_HAPPY_SERVER_LIGHT: '/tmp/custom/server-light',
+  };
+  assert.equal(getComponentDir(rootDir, 'happy-server-light', env), '/tmp/custom/server-light');
+});

package/scripts/utils/proc/commands.mjs

@@ -28,7 +28,6 @@ export async function runCaptureIfCommandExists(cmd, args, { cwd, env, timeoutMs
   }
 }
 
-export async function commandExists(cmd, { cwd } = {}) {
-  return Boolean(await resolveCommandPath(cmd, { cwd }));
+export async function commandExists(cmd, { cwd, env, timeoutMs } = {}) {
+  return Boolean(await resolveCommandPath(cmd, { cwd, env, timeoutMs }));
 }
-