happy-stacks 0.1.2 → 0.3.0

package/scripts/utils/proc/pm.mjs

@@ -0,0 +1,317 @@
+import { homedir } from 'node:os';
+import { dirname, join, resolve, sep } from 'node:path';
+import { existsSync } from 'node:fs';
+import { chmod, mkdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+
+import { pathExists } from '../fs/fs.mjs';
+import { readJsonIfExists, writeJsonAtomic } from '../fs/json.mjs';
+import { run, runCapture, spawnProc } from './proc.mjs';
+import { commandExists } from './commands.mjs';
+import { getDefaultAutostartPaths, getHappyStacksHomeDir } from '../paths/paths.mjs';
+import { resolveInstalledPath, resolveInstalledCliRoot } from '../paths/runtime.mjs';
+
+function sha256Hex(s) {
+  return createHash('sha256').update(String(s ?? ''), 'utf-8').digest('hex');
+}
+
+function resolveBuildStatePath({ label, dir }) {
+  const homeDir = getHappyStacksHomeDir();
+  const key = sha256Hex(resolve(dir));
+  return join(homeDir, 'cache', 'build', label, `${key}.json`);
+}
+
+async function computeGitWorktreeSignature(dir) {
+  try {
+    // Fast path: only if this is a git worktree.
+    const inside = (await runCapture('git', ['-C', dir, 'rev-parse', '--is-inside-work-tree'])).trim();
+    if (inside !== 'true') return null;
+    const head = (await runCapture('git', ['-C', dir, 'rev-parse', 'HEAD'])).trim();
+    // Includes staged + unstaged + untracked changes; captures “dirty” vs “clean”.
+    const status = await runCapture('git', ['-C', dir, 'status', '--porcelain=v1']);
+    return {
+      kind: 'git',
+      head,
+      statusHash: sha256Hex(status),
+      signature: sha256Hex(`${head}\n${status}`),
+    };
+  } catch {
+    return null;
+  }
+}
+
+export async function requirePnpm() {
+  if (await commandExists('pnpm')) {
+    return;
+  }
+  throw new Error(
+    '[local] pnpm is required to install dependencies for Happy Stacks.\n' +
+      'Install it via Corepack: `corepack enable && corepack prepare pnpm@latest --activate`'
+  );
+}
+
+async function getComponentPm(dir) {
+  const yarnLock = join(dir, 'yarn.lock');
+  if (await pathExists(yarnLock)) {
+    // IMPORTANT: when happy-stacks itself is pinned to pnpm via Corepack, running `yarn`
+    // from the happy-stacks cwd can be blocked. Always probe yarn with cwd=componentDir.
+    if (!(await commandExists('yarn', { cwd: dir }))) {
+      throw new Error(`[local] yarn is required for component at ${dir} (yarn.lock present). Install it via Corepack: \`corepack enable\``);
+    }
+    return { name: 'yarn', cmd: 'yarn' };
+  }
+
+  // Default fallback if no yarn.lock: use pnpm.
+  await requirePnpm();
+  return { name: 'pnpm', cmd: 'pnpm' };
+}
+
+export async function requireDir(label, dir) {
+  if (await pathExists(dir)) {
+    return;
+  }
+  throw new Error(
+    `[local] missing ${label} at ${dir}\n` +
+      `Run: happys bootstrap (auto-clones missing components), or place the repo under components/`
+  );
+}
+
+export async function ensureDepsInstalled(dir, label, { quiet = false } = {}) {
+  const pkgJson = join(dir, 'package.json');
+  if (!(await pathExists(pkgJson))) {
+    return;
+  }
+
+  const nodeModules = join(dir, 'node_modules');
+  const pnpmModulesMeta = join(dir, 'node_modules', '.modules.yaml');
+  const pm = await getComponentPm(dir);
+  const stdio = quiet ? 'ignore' : 'inherit';
+
+  if (await pathExists(nodeModules)) {
+    const yarnLock = join(dir, 'yarn.lock');
+    const yarnIntegrity = join(nodeModules, '.yarn-integrity');
+    const pnpmLock = join(dir, 'pnpm-lock.yaml');
+
+    // If this repo is Yarn-managed (yarn.lock present) but node_modules was created by pnpm,
+    // reinstall with Yarn to restore upstream-locked dependency versions.
+    if (pm.name === 'yarn' && (await pathExists(pnpmModulesMeta))) {
+      if (!quiet) {
+        // eslint-disable-next-line no-console
+        console.log(`[local] converting ${label} dependencies back to yarn (reinstalling node_modules)...`);
+      }
+      await rm(nodeModules, { recursive: true, force: true });
+      await run(pm.cmd, ['install'], { cwd: dir, stdio });
+    }
+
+    // If dependencies changed since the last install, re-run install even if node_modules exists.
+    const mtimeMs = async (p) => {
+      try {
+        const s = await stat(p);
+        return s.mtimeMs ?? 0;
+      } catch {
+        return 0;
+      }
+    };
+
+    if (pm.name === 'yarn' && (await pathExists(yarnLock))) {
+      const lockM = await mtimeMs(yarnLock);
+      const pkgM = await mtimeMs(pkgJson);
+      const intM = await mtimeMs(yarnIntegrity);
+      if (!intM || lockM > intM || pkgM > intM) {
+        if (!quiet) {
+          // eslint-disable-next-line no-console
+          console.log(`[local] refreshing ${label} dependencies (yarn.lock/package.json changed)...`);
+        }
+        await run(pm.cmd, ['install'], { cwd: dir, stdio });
+      }
+    }
+
+    if (pm.name === 'pnpm' && (await pathExists(pnpmLock))) {
+      const lockM = await mtimeMs(pnpmLock);
+      const metaM = await mtimeMs(pnpmModulesMeta);
+      if (!metaM || lockM > metaM) {
+        if (!quiet) {
+          // eslint-disable-next-line no-console
+          console.log(`[local] refreshing ${label} dependencies (pnpm-lock changed)...`);
+        }
+        await run(pm.cmd, ['install'], { cwd: dir, stdio });
+      }
+    }
+
+    return;
+  }
+
+  if (!quiet) {
+    // eslint-disable-next-line no-console
+    console.log(`[local] installing ${label} dependencies (first run)...`);
+  }
+  await run(pm.cmd, ['install'], { cwd: dir, stdio });
+}
+
+export async function ensureCliBuilt(cliDir, { buildCli }) {
+  await ensureDepsInstalled(cliDir, 'happy-cli');
+  if (!buildCli) {
+    return { built: false, reason: 'disabled' };
+  }
+  // Default: build only when needed (fast + reliable for worktrees that haven't been built yet).
+  //
+  // You can force always-build by setting:
+  // - HAPPY_STACKS_CLI_BUILD_MODE=always (legacy: HAPPY_LOCAL_CLI_BUILD_MODE=always)
+  // Or disable via:
+  // - HAPPY_STACKS_CLI_BUILD=0 (legacy: HAPPY_LOCAL_CLI_BUILD=0)
+  const modeRaw = (process.env.HAPPY_STACKS_CLI_BUILD_MODE ?? process.env.HAPPY_LOCAL_CLI_BUILD_MODE ?? 'auto').trim().toLowerCase();
+  const mode = modeRaw === 'always' || modeRaw === 'auto' || modeRaw === 'never' ? modeRaw : 'auto';
+  if (mode === 'never') {
+    return { built: false, reason: 'mode_never' };
+  }
+  const distEntrypoint = join(cliDir, 'dist', 'index.mjs');
+  const buildStatePath = resolveBuildStatePath({ label: 'happy-cli', dir: cliDir });
+  const gitSig = await computeGitWorktreeSignature(cliDir);
+  const prev = await readJsonIfExists(buildStatePath);
+
+  if (mode === 'auto') {
+    // If dist doesn't exist, we must build.
+    if (!(await pathExists(distEntrypoint))) {
+      // fallthrough to build
+    } else if (gitSig && prev?.signature && prev.signature === gitSig.signature) {
+      return { built: false, reason: 'up_to_date' };
+    } else if (!gitSig) {
+      // No git info: best-effort skip if dist exists (keeps this fast outside git worktrees).
+      return { built: false, reason: 'no_git_info' };
+    }
+  }
+
+  // eslint-disable-next-line no-console
+  console.log('[local] building happy-cli...');
+  const pm = await getComponentPm(cliDir);
+  await run(pm.cmd, ['build'], { cwd: cliDir });
+
+  // Persist new build state (best-effort).
+  const nowSig = gitSig ?? (await computeGitWorktreeSignature(cliDir));
+  if (nowSig) {
+    await writeJsonAtomic(buildStatePath, {
+      label: 'happy-cli',
+      dir: resolve(cliDir),
+      signature: nowSig.signature,
+      head: nowSig.head,
+      statusHash: nowSig.statusHash,
+      builtAt: new Date().toISOString(),
+    }).catch(() => {});
+  }
+  return { built: true, reason: mode === 'always' ? 'mode_always' : 'changed' };
+}
+
+function getPathEntries() {
+  const raw = process.env.PATH ?? '';
+  const delimiter = process.platform === 'win32' ? ';' : ':';
+  return raw.split(delimiter).filter(Boolean);
+}
+
+function isPathInside(path, dir) {
+  const p = resolve(path);
+  const d = resolve(dir);
+  return p === d || p.startsWith(d.endsWith(sep) ? d : d + sep);
+}
+
+export async function ensureHappyCliLocalNpmLinked(rootDir, { npmLinkCli }) {
+  if (!npmLinkCli) {
+    return;
+  }
+
+  const homeDir = getHappyStacksHomeDir();
+  const binDir = join(homeDir, 'bin');
+  await mkdir(binDir, { recursive: true });
+
+  const happysShim = join(binDir, 'happys');
+  const happyShim = join(binDir, 'happy');
+
+  const shim = `#!/bin/bash
+set -euo pipefail
+# Prefer the sibling happys shim (works for sandbox installs too).
+BIN_DIR="$(cd "$(dirname "$0")" && pwd)"
+HAPPYS="$BIN_DIR/happys"
+if [[ -x "$HAPPYS" ]]; then
+  exec "$HAPPYS" happy "$@"
+fi
+
+# Fallback: run happy-stacks from runtime install if present.
+HOME_DIR="\${HAPPY_STACKS_HOME_DIR:-\${HAPPY_LOCAL_HOME_DIR:-$HOME/.happy-stacks}}"
+RUNTIME="$HOME_DIR/runtime/node_modules/happy-stacks/bin/happys.mjs"
+if [[ -f "$RUNTIME" ]]; then
+  exec node "$RUNTIME" happy "$@"
+fi
+
+echo "error: cannot find happys shim or runtime install" >&2
+exit 1
+`;
+
+  const writeIfChanged = async (path, text) => {
+    let existing = '';
+    try {
+      existing = await readFile(path, 'utf-8');
+    } catch {
+      existing = '';
+    }
+    if (existing === text) return false;
+    await writeFile(path, text, 'utf-8');
+    return true;
+  };
+
+  await writeIfChanged(happyShim, shim);
+  await chmod(happyShim, 0o755).catch(() => {});
+
+  // happys shim: use node + CLI root; if runtime install exists, prefer it.
+  const cliRoot = resolveInstalledCliRoot(rootDir);
+  const happysShimText = `#!/bin/bash
+set -euo pipefail
+exec node "${resolveInstalledPath(rootDir, 'bin/happys.mjs')}" "$@"
+`;
+  await writeIfChanged(happysShim, happysShimText);
+  await chmod(happysShim, 0o755).catch(() => {});
+
+  // If user’s PATH points at a legacy install path, try to make it sane (best-effort).
+  const entries = getPathEntries();
+  const legacyBin = join(homedir(), '.happy-stacks', 'bin');
+  const newBin = join(getDefaultAutostartPaths().baseDir, 'bin');
+  if (entries.some((p) => isPathInside(p, legacyBin)) && !entries.some((p) => isPathInside(p, newBin))) {
+    // eslint-disable-next-line no-console
+    console.log(`[local] note: your PATH includes ${legacyBin}; recommended path is ${newBin}`);
+  }
+
+  return { ok: true, cliRoot, binDir, happyShim, happysShim };
+}
+
+export async function pmExecBin(dirOrOpts, binArg, argsArg, optsArg) {
+  const usesObjectStyle = typeof dirOrOpts === 'object' && dirOrOpts !== null;
+
+  const dir = usesObjectStyle ? dirOrOpts.dir : dirOrOpts;
+  const bin = usesObjectStyle ? dirOrOpts.bin : binArg;
+  const args = usesObjectStyle ? (dirOrOpts.args ?? []) : (argsArg ?? []);
+
+  const env = usesObjectStyle ? (dirOrOpts.env ?? process.env) : (optsArg?.env ?? process.env);
+  const quiet = usesObjectStyle ? Boolean(dirOrOpts.quiet) : Boolean(optsArg?.quiet);
+  const stdio = quiet ? 'ignore' : 'inherit';
+
+  const pm = await getComponentPm(dir);
+  if (pm.name === 'yarn') {
+    await run(pm.cmd, ['run', bin, ...args], { cwd: dir, env, stdio });
+    return;
+  }
+  await run(pm.cmd, ['exec', bin, ...args], { cwd: dir, env, stdio });
+}
+
+export async function pmSpawnBin(dir, label, bin, args, { env = process.env } = {}) {
+  const pm = await getComponentPm(dir);
+  if (pm.name === 'yarn') {
+    return spawnProc(label, pm.cmd, ['run', bin, ...args], env, { cwd: dir });
+  }
+  return spawnProc(label, pm.cmd, ['exec', bin, ...args], env, { cwd: dir });
+}
+
+export async function pmSpawnScript(dir, label, script, args, { env = process.env } = {}) {
+  const pm = await getComponentPm(dir);
+  if (pm.name === 'yarn') {
+    return spawnProc(label, pm.cmd, ['run', script, ...args], env, { cwd: dir });
+  }
+  return spawnProc(label, pm.cmd, ['run', script, ...args], env, { cwd: dir });
+}

package/scripts/utils/{proc.mjs → proc/proc.mjs}

@@ -1,5 +1,23 @@
 import { spawn } from 'node:child_process';
 
+function writeWithPrefix(stream, prefix, bufState, chunk) {
+  const s = chunk.toString();
+  bufState.buf += s;
+  while (true) {
+    const idx = bufState.buf.indexOf('\n');
+    if (idx < 0) break;
+    const line = bufState.buf.slice(0, idx);
+    bufState.buf = bufState.buf.slice(idx + 1);
+    stream.write(`${prefix}${line}\n`);
+  }
+}
+
+function flushPrefixed(stream, prefix, bufState) {
+  if (!bufState.buf) return;
+  stream.write(`${prefix}${bufState.buf}\n`);
+  bufState.buf = '';
+}
+
 export function spawnProc(label, cmd, args, env, options = {}) {
   const child = spawn(cmd, args, {
     env,
@@ -10,8 +28,17 @@ export function spawnProc(label, cmd, args, env, options = {}) {
     ...options,
   });
 
-  child.stdout?.on('data', (d) => process.stdout.write(`[${label}] ${d.toString()}`));
-  child.stderr?.on('data', (d) => process.stderr.write(`[${label}] ${d.toString()}`));
+  const outState = { buf: '' };
+  const errState = { buf: '' };
+  const outPrefix = `[${label}] `;
+  const errPrefix = `[${label}] `;
+
+  child.stdout?.on('data', (d) => writeWithPrefix(process.stdout, outPrefix, outState, d));
+  child.stderr?.on('data', (d) => writeWithPrefix(process.stderr, errPrefix, errState, d));
+  child.on('close', () => {
+    flushPrefixed(process.stdout, outPrefix, outState);
+    flushPrefixed(process.stderr, errPrefix, errState);
+  });
   child.on('exit', (code, sig) => {
     if (code !== 0) {
       process.stderr.write(`[${label}] exited (code=${code}, sig=${sig})\n`);
@@ -105,3 +132,4 @@ export async function runCapture(cmd, args, options = {}) {
     });
   });
 }
+

package/scripts/utils/proc/watch.mjs

@@ -0,0 +1,63 @@
+import { watch } from 'node:fs';
+
+function safeWatch(path, handler) {
+  try {
+    // Node supports recursive watching on macOS and Windows. On Linux this may throw; we fail closed by returning null.
+    return watch(path, { recursive: true }, handler);
+  } catch {
+    try {
+      return watch(path, {}, handler);
+    } catch {
+      return null;
+    }
+  }
+}
+
+/**
+ * Very small, dependency-free debounced watcher.
+ * Intended for dev ergonomics (rebuild/restart), not for correctness-critical logic.
+ */
+export function watchDebounced({ paths, debounceMs = 500, onChange } = {}) {
+  const list = Array.isArray(paths) ? paths.filter(Boolean) : [];
+  if (!list.length) return null;
+  if (typeof onChange !== 'function') return null;
+
+  let closed = false;
+  let t = null;
+  const watchers = [];
+
+  const trigger = (eventType, filename) => {
+    if (closed) return;
+    if (t) clearTimeout(t);
+    t = setTimeout(() => {
+      t = null;
+      try {
+        onChange({ eventType, filename });
+      } catch {
+        // ignore
+      }
+    }, debounceMs);
+  };
+
+  for (const p of list) {
+    const w = safeWatch(p, trigger);
+    if (w) watchers.push(w);
+  }
+
+  if (!watchers.length) return null;
+
+  return {
+    close() {
+      closed = true;
+      if (t) clearTimeout(t);
+      for (const w of watchers) {
+        try {
+          w.close();
+        } catch {
+          // ignore
+        }
+      }
+    },
+  };
+}
+