happy-stacks 0.0.0

package/scripts/utils/smoke_help.mjs

@@ -0,0 +1,45 @@
+import { spawnSync } from 'node:child_process';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+
+import { getHappysRegistry } from './cli_registry.mjs';
+
+function cliRootDir() {
+  // scripts/utils/* -> scripts -> repo root
+  return dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+}
+
+function runOrThrow(label, args) {
+  const root = cliRootDir();
+  const bin = join(root, 'bin', 'happys.mjs');
+  const res = spawnSync(process.execPath, [bin, ...args], { stdio: 'inherit', cwd: root, env: process.env });
+  if (res.status !== 0) {
+    throw new Error(`[smoke_help] failed (${label}): node bin/happys.mjs ${args.join(' ')}`);
+  }
+}
+
+function visibleCommands() {
+  const { commands } = getHappysRegistry();
+  return commands.filter((c) => !c.hidden).map((c) => c.name);
+}
+
+async function main() {
+  const cmds = visibleCommands();
+  for (const c of cmds) {
+    runOrThrow(`${c} --help`, [c, '--help']);
+  }
+
+  // Also validate delegation path for a few key groups.
+  for (const c of ['wt', 'stack', 'srv', 'service', 'tailscale', 'self', 'menubar', 'completion', 'where', 'init', 'uninstall']) {
+    runOrThrow(`help ${c}`, ['help', c]);
+  }
+
+  process.stdout.write('[smoke_help] ok\n');
+}
+
+main().catch((err) => {
+  process.stderr.write(String(err?.message ?? err) + '\n');
+  process.exit(1);
+});
+

package/scripts/utils/validate.mjs

@@ -0,0 +1,47 @@
+import { resolve, sep } from 'node:path';
+import { getComponentsDir } from './paths.mjs';
+
+function isInside(path, dir) {
+  const p = resolve(path);
+  const d = resolve(dir);
+  return p === d || p.startsWith(d.endsWith(sep) ? d : d + sep);
+}
+
+export function detectServerComponentDirMismatch({ rootDir, serverComponentName, serverDir }) {
+  const componentsDir = getComponentsDir(rootDir);
+
+  const other = serverComponentName === 'happy-server-light' ? 'happy-server' : serverComponentName === 'happy-server' ? 'happy-server-light' : null;
+  if (!other) {
+    return null;
+  }
+
+  const otherRepo = resolve(componentsDir, other);
+  const otherWts = resolve(componentsDir, '.worktrees', other);
+
+  if (isInside(serverDir, otherRepo) || isInside(serverDir, otherWts)) {
+    return { expected: serverComponentName, actual: other, serverDir };
+  }
+
+  return null;
+}
+
+export function assertServerComponentDirMatches({ rootDir, serverComponentName, serverDir }) {
+  const mismatch = detectServerComponentDirMismatch({ rootDir, serverComponentName, serverDir });
+  if (!mismatch) {
+    return;
+  }
+
+  const hint =
+    mismatch.expected === 'happy-server-light'
+      ? 'Fix: either switch flavor (`happys srv use happy-server`) or switch the active checkout for happy-server-light (`happys wt use happy-server-light default` or a worktree under .worktrees/happy-server-light/).'
+      : 'Fix: either switch flavor (`happys srv use happy-server-light`) or switch the active checkout for happy-server (`happys wt use happy-server default` or a worktree under .worktrees/happy-server/).';
+
+  throw new Error(
+    `[server] server component dir mismatch:\n` +
+      `- selected flavor: ${mismatch.expected}\n` +
+      `- but HAPPY_STACKS_COMPONENT_DIR_* points inside: ${mismatch.actual}\n` +
+      `- path: ${mismatch.serverDir}\n` +
+      `${hint}`
+  );
+}
+

package/scripts/utils/wizard.mjs

@@ -0,0 +1,69 @@
+import { createInterface } from 'node:readline/promises';
+import { listWorktreeSpecs } from './worktrees.mjs';
+
+export function isTty() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+
+export async function withRl(fn) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return await fn(rl);
+  } finally {
+    rl.close();
+  }
+}
+
+export async function prompt(rl, question, { defaultValue = '' } = {}) {
+  const raw = (await rl.question(question)).trim();
+  return raw || defaultValue;
+}
+
+export async function promptSelect(rl, { title, options, defaultIndex = 0 }) {
+  if (!options.length) {
+    throw new Error('[wizard] no options to select from');
+  }
+  // eslint-disable-next-line no-console
+  console.log(title);
+  for (let i = 0; i < options.length; i++) {
+    // eslint-disable-next-line no-console
+    console.log(`  ${i + 1}) ${options[i].label}`);
+  }
+  const answer = (await rl.question(`Pick [1-${options.length}] (default: ${defaultIndex + 1}): `)).trim();
+  const n = answer ? Number(answer) : defaultIndex + 1;
+  const idx = Math.max(1, Math.min(options.length, Number.isFinite(n) ? n : defaultIndex + 1)) - 1;
+  return options[idx].value;
+}
+
+export async function promptWorktreeSource({ rl, rootDir, component, stackName, createRemote = 'upstream' }) {
+  const specs = await listWorktreeSpecs({ rootDir, component });
+
+  const baseOptions = [{ label: `default (components/${component})`, value: 'default' }];
+  if (specs.length) {
+    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 });
+
+  if (kind === 'default') {
+    return 'default';
+  }
+  if (kind === 'pick') {
+    const picked = await promptSelect(rl, {
+      title: `Available ${component} worktrees:`,
+      options: specs.map((s) => ({ label: s, value: s })),
+      defaultIndex: 0,
+    });
+    return picked;
+  }
+
+  const slug = await prompt(rl, `New worktree slug for ${component} (example: pr/${stackName}/${component}): `, {
+    defaultValue: '',
+  });
+  if (!slug) {
+    return 'default';
+  }
+  return { create: true, slug, remote: createRemote };
+}
+

package/scripts/utils/worktrees.mjs

@@ -0,0 +1,78 @@
+import { readdir } from 'node:fs/promises';
+import { isAbsolute, join } from 'node:path';
+import { getComponentsDir } from './paths.mjs';
+import { pathExists } from './fs.mjs';
+import { run, runCapture } from './proc.mjs';
+
+export function parseGithubOwner(remoteUrl) {
+  const raw = (remoteUrl ?? '').trim();
+  if (!raw) {
+    return null;
+  }
+  // https://github.com/<owner>/<repo>.git
+  // git@github.com:<owner>/<repo>.git
+  const m = raw.match(/github\.com[:/](?<owner>[^/]+)\/(?<repo>[^/]+?)(?:\.git)?$/);
+  return m?.groups?.owner ?? null;
+}
+
+export function getWorktreesRoot(rootDir) {
+  return join(getComponentsDir(rootDir), '.worktrees');
+}
+
+export function componentRepoDir(rootDir, component) {
+  return join(getComponentsDir(rootDir), component);
+}
+
+export function resolveComponentSpecToDir({ rootDir, component, spec }) {
+  const raw = (spec ?? '').trim();
+  if (!raw || raw === 'default') {
+    return null;
+  }
+  if (isAbsolute(raw)) {
+    return raw;
+  }
+  // Treat as <owner>/<branch...> under components/.worktrees/<component>/...
+  return join(getWorktreesRoot(rootDir), component, ...raw.split('/'));
+}
+
+export async function listWorktreeSpecs({ rootDir, component }) {
+  const dir = join(getWorktreesRoot(rootDir), component);
+  const specs = [];
+  try {
+    const walk = async (d, prefixParts) => {
+      const entries = await readdir(d, { withFileTypes: true });
+      for (const e of entries) {
+        if (!e.isDirectory()) continue;
+        const p = join(d, e.name);
+        const nextPrefix = [...prefixParts, e.name];
+        if (await pathExists(join(p, '.git'))) {
+          specs.push(nextPrefix.join('/'));
+        }
+        await walk(p, nextPrefix);
+      }
+    };
+    if (await pathExists(dir)) {
+      await walk(dir, []);
+    }
+  } catch {
+    // ignore
+  }
+  return specs.sort();
+}
+
+export async function getRemoteOwner({ repoDir, remoteName = 'upstream' }) {
+  const url = (await runCapture('git', ['remote', 'get-url', remoteName], { cwd: repoDir })).trim();
+  const owner = parseGithubOwner(url);
+  if (!owner) {
+    throw new Error(`[worktrees] unable to parse owner for ${repoDir} remote ${remoteName} (${url})`);
+  }
+  return owner;
+}
+
+export async function createWorktree({ rootDir, component, slug, remoteName = 'upstream' }) {
+  // Create without modifying env.local (unless caller passes --use elsewhere).
+  await run(process.execPath, [join(rootDir, 'bin', 'happys.mjs'), 'wt', 'new', component, slug, `--remote=${remoteName}`], { cwd: rootDir });
+  const repoDir = componentRepoDir(rootDir, component);
+  const owner = await getRemoteOwner({ repoDir, remoteName });
+  return join(getWorktreesRoot(rootDir), component, owner, ...slug.split('/'));
+}

package/scripts/where.mjs

@@ -0,0 +1,105 @@
+import './utils/env.mjs';
+
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+import { parseArgs } from './utils/args.mjs';
+import { getComponentsDir, getComponentDir, getHappyStacksHomeDir, getRootDir, getStackLabel, getStackName, getWorkspaceDir, resolveStackEnvPath } from './utils/paths.mjs';
+import { printResult, wantsHelp, wantsJson } from './utils/cli.mjs';
+import { getRuntimeDir } from './utils/runtime.mjs';
+
+function expandHome(p) {
+  return p.replace(/^~(?=\/)/, homedir());
+}
+
+function getHomeEnvPaths() {
+  const homeDir = getHappyStacksHomeDir();
+  return {
+    homeEnv: join(homeDir, '.env'),
+    homeLocal: join(homeDir, 'env.local'),
+  };
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  const { flags } = parseArgs(argv);
+  const json = wantsJson(argv, { flags });
+  if (wantsHelp(argv, { flags }) || argv.includes('help')) {
+    printResult({
+      json,
+      data: { flags: ['--json'], commands: ['where', 'env'] },
+      text: ['[where] usage:', '  happys where [--json]', '  happys env [--json]'].join('\n'),
+    });
+    return;
+  }
+
+  const rootDir = getRootDir(import.meta.url);
+  const homeDir = getHappyStacksHomeDir();
+  const runtimeDir = getRuntimeDir();
+  const workspaceDir = getWorkspaceDir(rootDir);
+  const componentsDir = getComponentsDir(rootDir);
+
+  const stackName = getStackName();
+  const stackLabel = getStackLabel(stackName);
+  const resolvedMainEnv = resolveStackEnvPath('main');
+  const resolvedActiveEnv = process.env.HAPPY_STACKS_ENV_FILE?.trim()
+    ? { envPath: expandHome(process.env.HAPPY_STACKS_ENV_FILE.trim()) }
+    : process.env.HAPPY_LOCAL_ENV_FILE?.trim()
+      ? { envPath: expandHome(process.env.HAPPY_LOCAL_ENV_FILE.trim()) }
+      : null;
+
+  const { homeEnv, homeLocal } = getHomeEnvPaths();
+  const updateCachePath = join(homeDir, 'cache', 'update.json');
+
+  const componentNames = ['happy', 'happy-cli', 'happy-server-light', 'happy-server'];
+  const componentDirs = Object.fromEntries(componentNames.map((name) => [name, getComponentDir(rootDir, name)]));
+
+  printResult({
+    json,
+    data: {
+      ok: true,
+      rootDir,
+      homeDir,
+      runtimeDir,
+      workspaceDir,
+      componentsDir,
+      stack: { name: stackName, label: stackLabel },
+      envFiles: {
+        homeEnv: { path: homeEnv, exists: existsSync(homeEnv) },
+        homeLocal: { path: homeLocal, exists: existsSync(homeLocal) },
+        active: resolvedActiveEnv ? { path: resolvedActiveEnv.envPath, exists: existsSync(resolvedActiveEnv.envPath) } : null,
+        main: { path: resolvedMainEnv.envPath, exists: existsSync(resolvedMainEnv.envPath) },
+      },
+      components: componentDirs,
+      update: {
+        enabled: (process.env.HAPPY_STACKS_UPDATE_CHECK ?? '1') !== '0',
+        cachePath: updateCachePath,
+        cacheExists: existsSync(updateCachePath),
+      },
+    },
+    text: [
+      `[where] root:      ${rootDir}`,
+      `[where] home:      ${homeDir}`,
+      `[where] runtime:   ${runtimeDir}`,
+      `[where] workspace: ${workspaceDir}`,
+      `[where] components:${componentsDir}`,
+      '',
+      `[where] stack:     ${stackName} (${stackLabel})`,
+      `[where] env (home defaults): ${existsSync(homeEnv) ? homeEnv : `${homeEnv} (missing)`}`,
+      `[where] env (home overrides): ${existsSync(homeLocal) ? homeLocal : `${homeLocal} (missing)`}`,
+      `[where] env (active): ${resolvedActiveEnv?.envPath ? resolvedActiveEnv.envPath : '(none)'}`,
+      `[where] env (main):   ${resolvedMainEnv.envPath}`,
+      '',
+      ...componentNames.map((n) => `[where] component ${n}: ${componentDirs[n]}`),
+      '',
+      `[where] update cache: ${updateCachePath}`,
+    ].join('\n'),
+  });
+}
+
+main().catch((err) => {
+  console.error('[where] failed:', err);
+  process.exit(1);
+});
+