happy-stacks 0.0.0

package/scripts/self.mjs

@@ -0,0 +1,298 @@
+import './utils/env.mjs';
+
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+import { parseArgs } from './utils/args.mjs';
+import { pathExists } from './utils/fs.mjs';
+import { run, runCapture } from './utils/proc.mjs';
+import { getHappyStacksHomeDir, getRootDir } 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 cachePaths() {
+  const home = getHappyStacksHomeDir();
+  return {
+    home,
+    cacheDir: join(home, 'cache'),
+    updateJson: join(home, 'cache', 'update.json'),
+  };
+}
+
+async function readJsonSafe(path) {
+  try {
+    const raw = await readFile(path, 'utf-8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+async function writeJsonSafe(path, obj) {
+  try {
+    await mkdir(join(path, '..'), { recursive: true });
+  } catch {
+    // ignore
+  }
+  try {
+    await writeFile(path, JSON.stringify(obj, null, 2) + '\n', 'utf-8');
+  } catch {
+    // ignore
+  }
+}
+
+async function readPkgVersion(pkgJsonPath) {
+  try {
+    const raw = await readFile(pkgJsonPath, 'utf-8');
+    const pkg = JSON.parse(raw);
+    const v = String(pkg.version ?? '').trim();
+    return v || null;
+  } catch {
+    return null;
+  }
+}
+
+async function getRuntimeInstalledVersion() {
+  const runtimeDir = getRuntimeDir();
+  const pkgJson = join(runtimeDir, 'node_modules', 'happy-stacks', 'package.json');
+  return await readPkgVersion(pkgJson);
+}
+
+async function getInvokerVersion({ rootDir }) {
+  return await readPkgVersion(join(rootDir, 'package.json'));
+}
+
+async function fetchLatestVersion() {
+  // Prefer npm (available on most systems with Node).
+  // Keep it simple: `npm view happy-stacks version` prints a single version.
+  try {
+    const out = (await runCapture('npm', ['view', 'happy-stacks', 'version'])).trim();
+    return out || null;
+  } catch {
+    return null;
+  }
+}
+
+function compareVersions(a, b) {
+  // Very small semver-ish compare (supports x.y.z); falls back to string compare.
+  const pa = String(a ?? '').trim().split('.').map((n) => Number(n));
+  const pb = String(b ?? '').trim().split('.').map((n) => Number(n));
+  if (pa.length >= 2 && pb.length >= 2 && pa.every((n) => Number.isFinite(n)) && pb.every((n) => Number.isFinite(n))) {
+    const len = Math.max(pa.length, pb.length);
+    for (let i = 0; i < len; i++) {
+      const da = pa[i] ?? 0;
+      const db = pb[i] ?? 0;
+      if (da > db) return 1;
+      if (da < db) return -1;
+    }
+    return 0;
+  }
+  return String(a).localeCompare(String(b));
+}
+
+async function cmdStatus({ rootDir, argv }) {
+  const { flags } = parseArgs(argv);
+  const json = wantsJson(argv, { flags });
+  const doCheck = !flags.has('--no-check');
+
+  const { updateJson, cacheDir } = cachePaths();
+  const invokerVersion = await getInvokerVersion({ rootDir });
+  const runtimeDir = getRuntimeDir();
+  const runtimeVersion = await getRuntimeInstalledVersion();
+
+  const cached = await readJsonSafe(updateJson);
+
+  let latest = cached?.latest ?? null;
+  let checkedAt = cached?.checkedAt ?? null;
+  let updateAvailable = Boolean(cached?.updateAvailable);
+
+  if (doCheck) {
+    try {
+      latest = await fetchLatestVersion();
+      checkedAt = Date.now();
+      const current = runtimeVersion || invokerVersion;
+      updateAvailable = Boolean(current && latest && compareVersions(latest, current) > 0);
+      await mkdir(cacheDir, { recursive: true });
+      await writeJsonSafe(updateJson, {
+        checkedAt,
+        latest,
+        current: current || null,
+        runtimeVersion: runtimeVersion || null,
+        invokerVersion: invokerVersion || null,
+        updateAvailable,
+        notifiedAt: cached?.notifiedAt ?? null,
+      });
+    } catch {
+      // ignore network/npm failures; keep cached values
+    }
+  }
+
+  printResult({
+    json,
+    data: {
+      ok: true,
+      invoker: { version: invokerVersion, rootDir },
+      runtime: { dir: runtimeDir, installed: Boolean(runtimeVersion), version: runtimeVersion },
+      update: { cachedLatest: cached?.latest ?? null, latest, checkedAt, updateAvailable },
+    },
+    text: [
+      `[self] invoker: ${invokerVersion ?? 'unknown'} (${rootDir})`,
+      `[self] runtime: ${runtimeVersion ? runtimeVersion : 'not installed'} (${runtimeDir})`,
+      latest ? `[self] latest:  ${latest}${updateAvailable ? ' (update available)' : ''}` : `[self] latest:  unknown`,
+      checkedAt ? `[self] checked: ${new Date(checkedAt).toISOString()}` : null,
+    ]
+      .filter(Boolean)
+      .join('\n'),
+  });
+}
+
+async function cmdUpdate({ rootDir, argv }) {
+  const { flags, kv } = parseArgs(argv);
+  const json = wantsJson(argv, { flags });
+
+  const runtimeDir = getRuntimeDir();
+  const to = (kv.get('--to') ?? '').trim();
+  const spec = to ? `happy-stacks@${to}` : 'happy-stacks@latest';
+
+  // Ensure runtime dir exists.
+  await mkdir(runtimeDir, { recursive: true });
+
+  // Install/update runtime package.
+  try {
+    await run('npm', ['install', '--no-audit', '--no-fund', '--silent', '--prefix', runtimeDir, spec], { cwd: rootDir });
+  } catch (err) {
+    // Pre-publish dev fallback: allow updating runtime from the local checkout.
+    if (!to && existsSync(join(rootDir, 'package.json'))) {
+      try {
+        const raw = await readFile(join(rootDir, 'package.json'), 'utf-8');
+        const pkg = JSON.parse(raw);
+        if (pkg?.name === 'happy-stacks') {
+          await run('npm', ['install', '--no-audit', '--no-fund', '--silent', '--prefix', runtimeDir, rootDir], { cwd: rootDir });
+        } else {
+          throw err;
+        }
+      } catch {
+        throw err;
+      }
+    } else {
+      throw err;
+    }
+  }
+
+  // Refresh cache best-effort.
+  try {
+    const latest = await fetchLatestVersion();
+    const runtimeVersion = await getRuntimeInstalledVersion();
+    const invokerVersion = await getInvokerVersion({ rootDir });
+    const current = runtimeVersion || invokerVersion;
+    const updateAvailable = Boolean(current && latest && compareVersions(latest, current) > 0);
+    const { updateJson, cacheDir } = cachePaths();
+    await mkdir(cacheDir, { recursive: true });
+    await writeJsonSafe(updateJson, {
+      checkedAt: Date.now(),
+      latest,
+      current: current || null,
+      runtimeVersion: runtimeVersion || null,
+      invokerVersion: invokerVersion || null,
+      updateAvailable,
+      notifiedAt: null,
+    });
+  } catch {
+    // ignore
+  }
+
+  const runtimeVersionAfter = await getRuntimeInstalledVersion();
+  printResult({
+    json,
+    data: { ok: true, runtimeDir, version: runtimeVersionAfter ?? null, spec },
+    text: `[self] updated runtime in ${runtimeDir} (${runtimeVersionAfter ?? spec})`,
+  });
+}
+
+async function cmdCheck({ rootDir, argv }) {
+  const { flags } = parseArgs(argv);
+  const json = wantsJson(argv, { flags });
+  const quiet = flags.has('--quiet');
+
+  const { updateJson, cacheDir } = cachePaths();
+  const runtimeVersion = await getRuntimeInstalledVersion();
+  const invokerVersion = await getInvokerVersion({ rootDir });
+  const current = runtimeVersion || invokerVersion;
+
+  let latest = null;
+  try {
+    latest = await fetchLatestVersion();
+  } catch {
+    latest = null;
+  }
+
+  const updateAvailable = Boolean(current && latest && compareVersions(latest, current) > 0);
+  await mkdir(cacheDir, { recursive: true });
+  await writeJsonSafe(updateJson, {
+    checkedAt: Date.now(),
+    latest,
+    current: current || null,
+    runtimeVersion: runtimeVersion || null,
+    invokerVersion: invokerVersion || null,
+    updateAvailable,
+    notifiedAt: null,
+  });
+
+  if (quiet) {
+    return;
+  }
+  printResult({
+    json,
+    data: { ok: true, current: current || null, latest, updateAvailable },
+    text: latest ? (updateAvailable ? `[self] update available: ${current} -> ${latest}` : `[self] up to date (${current})`) : '[self] unable to check latest version',
+  });
+}
+
+async function main() {
+  const rootDir = getRootDir(import.meta.url);
+  const argv = process.argv.slice(2);
+
+  const { flags } = parseArgs(argv);
+  const cmd = argv.find((a) => !a.startsWith('--')) ?? 'help';
+
+  if (wantsHelp(argv, { flags }) || cmd === 'help') {
+    const json = wantsJson(argv, { flags });
+    printResult({
+      json,
+      data: { commands: ['status', 'update', 'check'], flags: ['--no-check', '--to=<version>', '--quiet'] },
+      text: [
+        '[self] usage:',
+        '  happys self status [--no-check] [--json]',
+        '  happys self update [--to=<version>] [--json]',
+        '  happys self check [--quiet] [--json]',
+      ].join('\n'),
+    });
+    return;
+  }
+
+  if (cmd === 'status') {
+    await cmdStatus({ rootDir, argv });
+    return;
+  }
+  if (cmd === 'update') {
+    await cmdUpdate({ rootDir, argv });
+    return;
+  }
+  if (cmd === 'check') {
+    await cmdCheck({ rootDir, argv });
+    return;
+  }
+
+  throw new Error(`[self] unknown command: ${cmd}`);
+}
+
+main().catch((err) => {
+  console.error('[self] failed:', err);
+  process.exit(1);
+});

package/scripts/server_flavor.mjs

@@ -0,0 +1,125 @@
+import './utils/env.mjs';
+import { parseArgs } from './utils/args.mjs';
+import { getRootDir } from './utils/paths.mjs';
+import { ensureEnvFileUpdated } from './utils/env_file.mjs';
+import { resolveUserConfigEnvPath } from './utils/config.mjs';
+import { isTty, promptSelect, withRl } from './utils/wizard.mjs';
+import { printResult, wantsHelp, wantsJson } from './utils/cli.mjs';
+
+const FLAVORS = [
+  { label: 'happy-server-light (recommended default, serves UI)', value: 'happy-server-light' },
+  { label: 'happy-server (full server, no UI serving)', value: 'happy-server' },
+];
+
+function normalizeFlavor(raw) {
+  const v = (raw ?? '').trim().toLowerCase();
+  if (!v) return '';
+  if (v === 'light' || v === 'server-light' || v === 'happy-server-light') return 'happy-server-light';
+  if (v === 'server' || v === 'full' || v === 'happy-server') return 'happy-server';
+  return raw.trim();
+}
+
+async function cmdUse({ rootDir, argv }) {
+  const { flags } = parseArgs(argv);
+  const positionals = argv.filter((a) => !a.startsWith('--'));
+  const flavorRaw = positionals[1] ?? '';
+  const flavor = normalizeFlavor(flavorRaw);
+  if (!flavor) {
+    throw new Error('[server-flavor] usage: happys srv use <happy-server-light|happy-server> [--json]');
+  }
+  if (!['happy-server-light', 'happy-server'].includes(flavor)) {
+    throw new Error(`[server-flavor] unknown flavor: ${flavor}`);
+  }
+
+  const envPath = resolveUserConfigEnvPath({ cliRootDir: rootDir });
+  await ensureEnvFileUpdated({
+    envPath,
+    updates: [
+      { key: 'HAPPY_STACKS_SERVER_COMPONENT', value: flavor },
+      { key: 'HAPPY_LOCAL_SERVER_COMPONENT', value: flavor }, // legacy alias
+    ],
+  });
+
+  const json = wantsJson(argv, { flags });
+  printResult({
+    json,
+    data: { ok: true, flavor },
+    text: `[server-flavor] set HAPPY_STACKS_SERVER_COMPONENT=${flavor} (saved to ${envPath})`,
+  });
+}
+
+async function cmdUseInteractive({ rootDir, argv }) {
+  const { flags } = parseArgs(argv);
+  const json = wantsJson(argv, { flags });
+
+  await withRl(async (rl) => {
+    const flavor = await promptSelect(rl, { title: 'Select server flavor:', options: FLAVORS, defaultIndex: 0 });
+    const envPath = resolveUserConfigEnvPath({ cliRootDir: rootDir });
+    await ensureEnvFileUpdated({
+      envPath,
+      updates: [
+        { key: 'HAPPY_STACKS_SERVER_COMPONENT', value: flavor },
+        { key: 'HAPPY_LOCAL_SERVER_COMPONENT', value: flavor }, // legacy alias
+      ],
+    });
+    printResult({
+      json,
+      data: { ok: true, flavor },
+      text: `[server-flavor] set HAPPY_STACKS_SERVER_COMPONENT=${flavor} (saved to ${envPath})`,
+    });
+  });
+}
+
+async function cmdStatus({ argv }) {
+  const { flags } = parseArgs(argv);
+  const json = wantsJson(argv, { flags });
+  const flavor = process.env.HAPPY_STACKS_SERVER_COMPONENT?.trim() || process.env.HAPPY_LOCAL_SERVER_COMPONENT?.trim() || 'happy-server-light';
+  printResult({ json, data: { flavor }, text: `[server-flavor] current: ${flavor}` });
+}
+
+async function main() {
+  const rootDir = getRootDir(import.meta.url);
+  const argv = process.argv.slice(2);
+  const { flags } = parseArgs(argv);
+  const positionals = argv.filter((a) => !a.startsWith('--'));
+  const cmd = positionals[0] ?? 'help';
+  const json = wantsJson(argv, { flags });
+
+  if (wantsHelp(argv, { flags }) || cmd === 'help') {
+    printResult({
+      json,
+      data: { commands: ['status', 'use'] },
+      text: [
+        '[server-flavor] usage:',
+        '  happys srv status [--json]',
+        '  happys srv use <happy-server-light|happy-server> [--json]',
+        '  happys srv use --interactive [--json]',
+        '',
+        'notes:',
+        '  - `pnpm srv -- ...` still works inside a cloned repo (legacy).',
+      ].join('\n'),
+    });
+    return;
+  }
+
+  if (cmd === 'status') {
+    await cmdStatus({ argv });
+    return;
+  }
+  if (cmd === 'use') {
+    const interactive = argv.includes('--interactive') || argv.includes('-i');
+    if (interactive && isTty()) {
+      await cmdUseInteractive({ rootDir, argv });
+    } else {
+      await cmdUse({ rootDir, argv });
+    }
+    return;
+  }
+
+  throw new Error(`[server-flavor] unknown command: ${cmd}`);
+}
+
+main().catch((err) => {
+  console.error('[server-flavor] failed:', err);
+  process.exit(1);
+});