happy-stacks 0.3.0 → 0.5.0

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)));
 }
@@ -26,8 +38,8 @@ export function getHappyStacksHomeDir(env = process.env) {
   return PRIMARY_HOME_DIR;
 }
 
-export function getWorkspaceDir(cliRootDir = null) {
-  const fromEnv = (process.env.HAPPY_STACKS_WORKSPACE_DIR ?? '').trim();
+export function getWorkspaceDir(cliRootDir = null, env = process.env) {
+  const fromEnv = (env.HAPPY_STACKS_WORKSPACE_DIR ?? '').trim();
   if (fromEnv) {
     return expandHome(fromEnv);
   }
@@ -41,8 +53,8 @@ export function getWorkspaceDir(cliRootDir = null) {
   return cliRootDir ? cliRootDir : defaultWorkspace;
 }
 
-export function getComponentsDir(rootDir) {
-  const workspaceDir = getWorkspaceDir(rootDir);
+export function getComponentsDir(rootDir, env = process.env) {
+  const workspaceDir = getWorkspaceDir(rootDir, env);
   return join(workspaceDir, 'components');
 }
 
@@ -50,46 +62,152 @@ export function componentDirEnvKey(name) {
   return `HAPPY_STACKS_COMPONENT_DIR_${name.toUpperCase().replace(/[^A-Z0-9]+/g, '_')}`;
 }
 
-function normalizePathForEnv(rootDir, raw) {
+function normalizePathForEnv(rootDir, raw, env = process.env) {
   const trimmed = (raw ?? '').trim();
   if (!trimmed) {
     return '';
   }
   const expanded = expandHome(trimmed);
   // If the path is relative, treat it as relative to the workspace root (default: repo root).
-  const workspaceDir = getWorkspaceDir(rootDir);
+  const workspaceDir = getWorkspaceDir(rootDir, env);
   return expanded.startsWith('/') ? expanded : resolve(workspaceDir, expanded);
 }
 
-export function getComponentDir(rootDir, name) {
+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, process.env[stacksKey] ?? process.env[legacyKey]);
-  if (fromEnv) {
+  const fromEnv = normalizePathForEnv(rootDir, env[stacksKey] ?? env[legacyKey], env);
+  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), 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() {
-  const raw = process.env.HAPPY_STACKS_STACK?.trim()
-    ? process.env.HAPPY_STACKS_STACK.trim()
-    : process.env.HAPPY_LOCAL_STACK?.trim()
-      ? process.env.HAPPY_LOCAL_STACK.trim()
+export function getStackName(env = process.env) {
+  const raw = env.HAPPY_STACKS_STACK?.trim()
+    ? env.HAPPY_STACKS_STACK.trim()
+    : env.HAPPY_LOCAL_STACK?.trim()
+      ? env.HAPPY_LOCAL_STACK.trim()
       : '';
   return raw || 'main';
 }
 
-export function getStackLabel(stackName = getStackName()) {
-  return stackName === 'main' ? PRIMARY_LABEL_BASE : `${PRIMARY_LABEL_BASE}.${stackName}`;
+export function getStackLabel(stackName = null, env = process.env) {
+  const name = (stackName ?? '').toString().trim() || getStackName(env);
+  return name === 'main' ? PRIMARY_LABEL_BASE : `${PRIMARY_LABEL_BASE}.${name}`;
 }
 
-export function getLegacyStackLabel(stackName = getStackName()) {
-  return stackName === 'main' ? LEGACY_LABEL_BASE : `${LEGACY_LABEL_BASE}.${stackName}`;
+export function getLegacyStackLabel(stackName = null, env = process.env) {
+  const name = (stackName ?? '').toString().trim() || getStackName(env);
+  return name === 'main' ? LEGACY_LABEL_BASE : `${LEGACY_LABEL_BASE}.${name}`;
 }
 
-export function getStacksStorageRoot() {
-  const fromEnv = (process.env.HAPPY_STACKS_STORAGE_DIR ?? process.env.HAPPY_LOCAL_STORAGE_DIR ?? '').trim();
+export function getStacksStorageRoot(env = process.env) {
+  const fromEnv = (env.HAPPY_STACKS_STORAGE_DIR ?? env.HAPPY_LOCAL_STORAGE_DIR ?? '').trim();
   if (fromEnv) {
     return expandHome(fromEnv);
   }
@@ -100,19 +218,20 @@ export function getLegacyStorageRoot() {
   return LEGACY_STORAGE_ROOT;
 }
 
-export function resolveStackBaseDir(stackName = getStackName()) {
-  const preferredRoot = getStacksStorageRoot();
-  const newBase = join(preferredRoot, stackName);
-  const legacyBase = stackName === 'main' ? LEGACY_STORAGE_ROOT : join(LEGACY_STORAGE_ROOT, 'stacks', stackName);
+export function resolveStackBaseDir(stackName = null, env = process.env) {
+  const name = (stackName ?? '').toString().trim() || getStackName(env);
+  const preferredRoot = getStacksStorageRoot(env);
+  const newBase = join(preferredRoot, name);
+  const legacyBase = name === 'main' ? LEGACY_STORAGE_ROOT : join(LEGACY_STORAGE_ROOT, 'stacks', name);
   const allowLegacy = !isSandboxed() || sandboxAllowsGlobalSideEffects();
 
   // Prefer the new layout by default.
   //
   // For non-main stacks, keep legacy layout if the legacy env exists and the new env does not.
   // This avoids breaking existing stacks until `happys stack migrate` is run.
-  if (allowLegacy && stackName !== 'main') {
-    const newEnv = join(preferredRoot, stackName, 'env');
-    const legacyEnv = join(LEGACY_STORAGE_ROOT, 'stacks', stackName, 'env');
+  if (allowLegacy && name !== 'main') {
+    const newEnv = join(preferredRoot, name, 'env');
+    const legacyEnv = join(LEGACY_STORAGE_ROOT, 'stacks', name, 'env');
     if (!existsSync(newEnv) && existsSync(legacyEnv)) {
       return { baseDir: legacyBase, isLegacy: true };
     }
@@ -121,30 +240,31 @@ export function resolveStackBaseDir(stackName = getStackName()) {
   return { baseDir: newBase, isLegacy: false };
 }
 
-export function resolveStackEnvPath(stackName = getStackName()) {
-  const { baseDir: activeBase, isLegacy } = resolveStackBaseDir(stackName);
+export function resolveStackEnvPath(stackName = null, env = process.env) {
+  const name = (stackName ?? '').toString().trim() || getStackName(env);
+  const { baseDir: activeBase, isLegacy } = resolveStackBaseDir(name, env);
   // New layout: ~/.happy/stacks/<name>/env
-  const newEnv = join(getStacksStorageRoot(), stackName, 'env');
+  const newEnv = join(getStacksStorageRoot(env), name, 'env');
   // Legacy layout: ~/.happy/local/stacks/<name>/env
-  const legacyEnv = join(LEGACY_STORAGE_ROOT, 'stacks', stackName, 'env');
+  const legacyEnv = join(LEGACY_STORAGE_ROOT, 'stacks', name, 'env');
   const allowLegacy = !isSandboxed() || sandboxAllowsGlobalSideEffects();
 
   if (existsSync(newEnv)) {
-    return { envPath: newEnv, isLegacy: false, baseDir: join(getStacksStorageRoot(), stackName) };
+    return { envPath: newEnv, isLegacy: false, baseDir: join(getStacksStorageRoot(env), name) };
   }
   if (allowLegacy && existsSync(legacyEnv)) {
-    return { envPath: legacyEnv, isLegacy: true, baseDir: join(LEGACY_STORAGE_ROOT, 'stacks', stackName) };
+    return { envPath: legacyEnv, isLegacy: true, baseDir: join(LEGACY_STORAGE_ROOT, 'stacks', name) };
   }
   return { envPath: newEnv, isLegacy, baseDir: activeBase };
 }
 
-export function getDefaultAutostartPaths() {
-  const stackName = getStackName();
-  const { baseDir, isLegacy } = resolveStackBaseDir(stackName);
+export function getDefaultAutostartPaths(env = process.env) {
+  const stackName = getStackName(env);
+  const { baseDir, isLegacy } = resolveStackBaseDir(stackName, env);
   const logsDir = join(baseDir, 'logs');
 
-  const primaryLabel = getStackLabel(stackName);
-  const legacyLabel = getLegacyStackLabel(stackName);
+  const primaryLabel = getStackLabel(stackName, env);
+  const legacyLabel = getLegacyStackLabel(stackName, env);
   const primaryPlistPath = join(homedir(), 'Library', 'LaunchAgents', `${primaryLabel}.plist`);
   const legacyPlistPath = join(homedir(), 'Library', 'LaunchAgents', `${legacyLabel}.plist`);
 
@@ -187,4 +307,3 @@ export function getDefaultAutostartPaths() {
     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 }));
 }
-

package/scripts/utils/proc/parallel.mjs

@@ -0,0 +1,25 @@
+export async function runWithConcurrencyLimit({ items, limit, fn }) {
+  const list = Array.isArray(items) ? items : [];
+  const max = Number(limit);
+  const concurrency = Number.isFinite(max) && max > 0 ? Math.floor(max) : 4;
+
+  const results = new Array(list.length);
+  let nextIndex = 0;
+
+  const worker = async () => {
+    while (true) {
+      const i = nextIndex;
+      nextIndex += 1;
+      if (i >= list.length) return;
+      results[i] = await fn(list[i], i);
+    }
+  };
+
+  const workers = [];
+  for (let i = 0; i < Math.min(concurrency, list.length); i++) {
+    workers.push(worker());
+  }
+  await Promise.all(workers);
+  return results;
+}
+