happy-stacks 0.0.0

package/scripts/utils/cli_registry.mjs

@@ -0,0 +1,262 @@
+export function getHappysRegistry() {
+  /**
+   * Command definition shape:
+   * - name: primary token users type (e.g. "wt")
+   * - aliases: alternative tokens (e.g. ["server-flavor"])
+   * - kind: "node" | "external"
+   * - scriptRelPath: for kind==="node"
+   * - external: { cmd, argsFromRest?: (rest)=>string[] } for kind==="external"
+   * - argsFromRest: transform passed to the script (default: identity)
+   * - helpArgs: argv passed to show help (default: ["--help"])
+   * - rootUsage: optional line(s) for root usage output
+   * - description: short one-liner for root commands list
+   * - hidden: omit from root help (legacy aliases still work)
+   */
+  const commands = [
+    {
+      name: 'init',
+      kind: 'node',
+      scriptRelPath: 'scripts/init.mjs',
+      rootUsage:
+        'happys init [--home-dir=PATH] [--workspace-dir=PATH] [--runtime-dir=PATH] [--install-path] [--no-runtime] [--no-bootstrap] [--] [bootstrap args...]',
+      description: 'Initialize ~/.happy-stacks (runtime + shims)',
+    },
+    {
+      name: 'uninstall',
+      kind: 'node',
+      scriptRelPath: 'scripts/uninstall.mjs',
+      rootUsage: 'happys uninstall [--remove-workspace] [--remove-stacks] [--yes] [--json]',
+      description: 'Remove ~/.happy-stacks and related files',
+    },
+    {
+      name: 'where',
+      aliases: ['env'],
+      kind: 'node',
+      scriptRelPath: 'scripts/where.mjs',
+      rootUsage: 'happys where [--json]   (alias: env)',
+      description: 'Show resolved paths and env sources',
+    },
+    {
+      name: 'bootstrap',
+      kind: 'node',
+      scriptRelPath: 'scripts/install.mjs',
+      rootUsage: 'happys bootstrap [-- ...]',
+      description: 'Clone/install components and deps',
+    },
+    {
+      name: 'start',
+      kind: 'node',
+      scriptRelPath: 'scripts/run.mjs',
+      rootUsage: 'happys start [-- ...]',
+      description: 'Start local stack (prod-like)',
+    },
+    {
+      name: 'dev',
+      kind: 'node',
+      scriptRelPath: 'scripts/dev.mjs',
+      rootUsage: 'happys dev [-- ...]',
+      description: 'Start local stack (dev)',
+    },
+    {
+      name: 'build',
+      kind: 'node',
+      scriptRelPath: 'scripts/build.mjs',
+      rootUsage: 'happys build [-- ...]',
+      description: 'Build UI bundle',
+    },
+    {
+      name: 'mobile',
+      kind: 'node',
+      scriptRelPath: 'scripts/mobile.mjs',
+      rootUsage: 'happys mobile [-- ...]',
+      description: 'Mobile helper (iOS)',
+    },
+    {
+      name: 'doctor',
+      kind: 'node',
+      scriptRelPath: 'scripts/doctor.mjs',
+      rootUsage: 'happys doctor [--fix] [--json]',
+      description: 'Diagnose/fix local setup',
+    },
+    {
+      name: 'self',
+      kind: 'node',
+      scriptRelPath: 'scripts/self.mjs',
+      rootUsage: 'happys self status|update|check [--json]',
+      description: 'Runtime install + self-update',
+    },
+    {
+      name: 'auth',
+      kind: 'node',
+      scriptRelPath: 'scripts/auth.mjs',
+      rootUsage: 'happys auth status|login [--json]',
+      description: 'CLI auth helper',
+    },
+    {
+      name: 'happy',
+      kind: 'node',
+      scriptRelPath: 'scripts/happy.mjs',
+      rootUsage: 'happys happy <happy-cli args...>',
+      description: 'Run happy-cli against this stack',
+    },
+    {
+      name: 'wt',
+      kind: 'node',
+      scriptRelPath: 'scripts/worktrees.mjs',
+      rootUsage: 'happys wt <args...>',
+      description: 'Worktrees across components',
+    },
+    {
+      name: 'srv',
+      aliases: ['server-flavor'],
+      kind: 'node',
+      scriptRelPath: 'scripts/server_flavor.mjs',
+      rootUsage: 'happys srv <status|use ...>',
+      description: 'Select server flavor',
+    },
+    {
+      name: 'stack',
+      kind: 'node',
+      scriptRelPath: 'scripts/stack.mjs',
+      rootUsage: 'happys stack <args...>',
+      description: 'Multiple isolated stacks',
+    },
+    {
+      name: 'tailscale',
+      kind: 'node',
+      scriptRelPath: 'scripts/tailscale.mjs',
+      rootUsage: 'happys tailscale <status|enable|disable|url ...>',
+      description: 'Tailscale Serve (HTTPS secure context)',
+    },
+    {
+      name: 'service',
+      kind: 'node',
+      scriptRelPath: 'scripts/service.mjs',
+      rootUsage: 'happys service <install|uninstall|status|start|stop|restart|enable|disable|logs|tail>',
+      description: 'LaunchAgent service management',
+    },
+    {
+      name: 'menubar',
+      kind: 'node',
+      scriptRelPath: 'scripts/menubar.mjs',
+      rootUsage: 'happys menubar <install|uninstall|open>',
+      description: 'SwiftBar menu bar plugin',
+    },
+    {
+      name: 'completion',
+      kind: 'node',
+      scriptRelPath: 'scripts/completion.mjs',
+      rootUsage: 'happys completion <print|install> [--shell=zsh|bash|fish] [--json]',
+      description: 'Shell completions (optional)',
+    },
+
+    // ---- Legacy aliases (hidden) ----
+    { name: 'stack:doctor', kind: 'node', scriptRelPath: 'scripts/doctor.mjs', hidden: true },
+    { name: 'stack:fix', kind: 'node', scriptRelPath: 'scripts/doctor.mjs', argsFromRest: (rest) => ['--fix', ...rest], hidden: true },
+
+    { name: 'cli:link', kind: 'node', scriptRelPath: 'scripts/cli-link.mjs', hidden: true },
+    { name: 'logs', kind: 'node', scriptRelPath: 'scripts/service.mjs', argsFromRest: (rest) => ['logs', ...rest], hidden: true },
+    { name: 'logs:tail', kind: 'node', scriptRelPath: 'scripts/service.mjs', argsFromRest: (rest) => ['tail', ...rest], hidden: true },
+
+    {
+      name: 'service:status',
+      kind: 'node',
+      scriptRelPath: 'scripts/service.mjs',
+      argsFromRest: (rest) => ['status', ...rest],
+      hidden: true,
+    },
+    { name: 'service:start', kind: 'node', scriptRelPath: 'scripts/service.mjs', argsFromRest: (rest) => ['start', ...rest], hidden: true },
+    { name: 'service:stop', kind: 'node', scriptRelPath: 'scripts/service.mjs', argsFromRest: (rest) => ['stop', ...rest], hidden: true },
+    { name: 'service:restart', kind: 'node', scriptRelPath: 'scripts/service.mjs', argsFromRest: (rest) => ['restart', ...rest], hidden: true },
+    { name: 'service:enable', kind: 'node', scriptRelPath: 'scripts/service.mjs', argsFromRest: (rest) => ['enable', ...rest], hidden: true },
+    { name: 'service:disable', kind: 'node', scriptRelPath: 'scripts/service.mjs', argsFromRest: (rest) => ['disable', ...rest], hidden: true },
+    { name: 'service:install', kind: 'node', scriptRelPath: 'scripts/service.mjs', argsFromRest: (rest) => ['install', ...rest], hidden: true },
+    { name: 'service:uninstall', kind: 'node', scriptRelPath: 'scripts/service.mjs', argsFromRest: (rest) => ['uninstall', ...rest], hidden: true },
+
+    { name: 'tailscale:status', kind: 'node', scriptRelPath: 'scripts/tailscale.mjs', argsFromRest: (rest) => ['status', ...rest], hidden: true },
+    { name: 'tailscale:enable', kind: 'node', scriptRelPath: 'scripts/tailscale.mjs', argsFromRest: (rest) => ['enable', ...rest], hidden: true },
+    { name: 'tailscale:disable', kind: 'node', scriptRelPath: 'scripts/tailscale.mjs', argsFromRest: (rest) => ['disable', ...rest], hidden: true },
+    { name: 'tailscale:reset', kind: 'node', scriptRelPath: 'scripts/tailscale.mjs', argsFromRest: (rest) => ['reset', ...rest], hidden: true },
+    { name: 'tailscale:url', kind: 'node', scriptRelPath: 'scripts/tailscale.mjs', argsFromRest: (rest) => ['url', ...rest], hidden: true },
+
+    { name: 'menubar:install', kind: 'node', scriptRelPath: 'scripts/menubar.mjs', argsFromRest: (rest) => ['menubar:install', ...rest], hidden: true },
+    { name: 'menubar:uninstall', kind: 'node', scriptRelPath: 'scripts/menubar.mjs', argsFromRest: (rest) => ['menubar:uninstall', ...rest], hidden: true },
+    { name: 'menubar:open', kind: 'node', scriptRelPath: 'scripts/menubar.mjs', argsFromRest: (rest) => ['menubar:open', ...rest], hidden: true },
+
+    { name: 'mobile:prebuild', kind: 'node', scriptRelPath: 'scripts/mobile.mjs', argsFromRest: (rest) => ['--prebuild', '--clean', '--no-metro', ...rest], hidden: true },
+    { name: 'mobile:ios', kind: 'node', scriptRelPath: 'scripts/mobile.mjs', argsFromRest: (rest) => ['--run-ios', '--no-metro', ...rest], hidden: true },
+    {
+      name: 'mobile:ios:release',
+      kind: 'node',
+      scriptRelPath: 'scripts/mobile.mjs',
+      argsFromRest: (rest) => ['--run-ios', '--no-metro', '--configuration=Release', ...rest],
+      hidden: true,
+    },
+    {
+      name: 'mobile:install',
+      kind: 'node',
+      scriptRelPath: 'scripts/mobile.mjs',
+      argsFromRest: (rest) => ['--run-ios', '--no-metro', '--configuration=Release', ...rest],
+      hidden: true,
+    },
+    {
+      name: 'mobile:devices',
+      kind: 'external',
+      external: { cmd: 'xcrun', argsFromRest: () => ['xcdevice', 'list'] },
+      hidden: true,
+    },
+  ];
+
+  return { commands };
+}
+
+export function resolveHappysCommand(cmd) {
+  const registry = getHappysRegistry();
+  const map = new Map();
+  for (const c of registry.commands) {
+    map.set(c.name, c);
+    for (const a of c.aliases ?? []) {
+      map.set(a, c);
+    }
+  }
+  return map.get(cmd) ?? null;
+}
+
+export function commandHelpArgs(cmd) {
+  const c = resolveHappysCommand(cmd);
+  if (!c) return null;
+  return c.helpArgs ?? ['--help'];
+}
+
+export function renderHappysRootHelp() {
+  const { commands } = getHappysRegistry();
+  const visible = commands.filter((c) => !c.hidden);
+
+  const usageLines = [];
+  for (const c of visible) {
+    if (!c.rootUsage) continue;
+    if (Array.isArray(c.rootUsage)) usageLines.push(...c.rootUsage);
+    else usageLines.push(c.rootUsage);
+  }
+
+  const rows = visible
+    .filter((c) => c.description)
+    .map((c) => ({ name: c.name, desc: c.description }))
+    .sort((a, b) => a.name.localeCompare(b.name));
+
+  const pad = rows.reduce((m, r) => Math.max(m, r.name.length), 0);
+  const commandsLines = rows.map((r) => `  ${r.name.padEnd(pad)}  ${r.desc}`);
+
+  return [
+    'happys - Happy Stacks CLI',
+    '',
+    'usage:',
+    ...usageLines.map((l) => `  ${l}`),
+    '',
+    'commands:',
+    ...commandsLines,
+    '',
+    'help:',
+    '  happys help [command]',
+  ].join('\n');
+}

package/scripts/utils/config.mjs

@@ -0,0 +1,40 @@
+import { join } from 'node:path';
+import { ensureEnvFileUpdated } from './env_file.mjs';
+import { getHappyStacksHomeDir, resolveStackEnvPath } from './paths.mjs';
+
+export function getHomeEnvPath() {
+  return join(getHappyStacksHomeDir(), '.env');
+}
+
+export function getHomeEnvLocalPath() {
+  return join(getHappyStacksHomeDir(), 'env.local');
+}
+
+export function resolveUserConfigEnvPath({ cliRootDir }) {
+  const explicit = (process.env.HAPPY_STACKS_ENV_FILE ?? process.env.HAPPY_LOCAL_ENV_FILE ?? '').trim();
+  if (explicit) {
+    return explicit;
+  }
+
+  // By default, persist configuration to the main stack env file so config is
+  // outside the repo and consistent across install modes.
+  //
+  // This also matches the stack env precedence in scripts/utils/env.mjs.
+  void cliRootDir;
+  return resolveStackEnvPath('main').envPath;
+}
+
+export async function ensureHomeEnvUpdated({ updates }) {
+  await ensureEnvFileUpdated({ envPath: getHomeEnvPath(), updates });
+}
+
+export async function ensureHomeEnvLocalUpdated({ updates }) {
+  await ensureEnvFileUpdated({ envPath: getHomeEnvLocalPath(), updates });
+}
+
+export async function ensureUserConfigEnvUpdated({ cliRootDir, updates }) {
+  const envPath = resolveUserConfigEnvPath({ cliRootDir });
+  await ensureEnvFileUpdated({ envPath, updates });
+  return envPath;
+}
+

package/scripts/utils/dotenv.mjs

@@ -0,0 +1,30 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+export function parseDotenv(contents) {
+  const out = new Map();
+  for (const rawLine of contents.split('\n')) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#')) {
+      continue;
+    }
+    const idx = line.indexOf('=');
+    if (idx <= 0) {
+      continue;
+    }
+    const key = line.slice(0, idx).trim();
+    let value = line.slice(idx + 1).trim();
+    if (!key) {
+      continue;
+    }
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+    if (value.startsWith('~/')) {
+      value = join(homedir(), value.slice(2));
+    }
+    out.set(key, value);
+  }
+  return out;
+}
+

package/scripts/utils/env.mjs

@@ -0,0 +1,138 @@
+import { readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parseDotenv } from './dotenv.mjs';
+
+async function loadEnvFile(path, { override = false, overridePrefix = null } = {}) {
+  try {
+    const contents = await readFile(path, 'utf-8');
+    const parsed = parseDotenv(contents);
+    for (const [k, v] of parsed.entries()) {
+      const allowOverride = override && (!overridePrefix || k.startsWith(overridePrefix));
+      if (allowOverride || process.env[k] == null || process.env[k] === '') {
+        process.env[k] = v;
+      }
+    }
+  } catch {
+    // ignore missing/invalid env file
+  }
+}
+
+// Load happy-stacks env (optional). This is intentionally lightweight and does not require extra deps.
+// This file lives under scripts/utils/, so repo root is two directories up.
+const __utilsDir = dirname(fileURLToPath(import.meta.url));
+const __scriptsDir = dirname(__utilsDir);
+const __cliRootDir = dirname(__scriptsDir);
+
+function expandHome(p) {
+  return p.replace(/^~(?=\/)/, homedir());
+}
+
+function resolveHomeDir() {
+  const fromEnv = (process.env.HAPPY_STACKS_HOME_DIR ?? '').trim();
+  if (fromEnv) {
+    return expandHome(fromEnv);
+  }
+  return join(homedir(), '.happy-stacks');
+}
+
+function applyStacksPrefixMapping() {
+  // Canonicalize env var prefix:
+  // - prefer HAPPY_STACKS_* when set
+  // - continue supporting HAPPY_LOCAL_* (legacy) during migration
+  const keys = new Set(Object.keys(process.env));
+  const suffixes = new Set();
+  for (const k of keys) {
+    if (k.startsWith('HAPPY_STACKS_')) suffixes.add(k.slice('HAPPY_STACKS_'.length));
+    if (k.startsWith('HAPPY_LOCAL_')) suffixes.add(k.slice('HAPPY_LOCAL_'.length));
+  }
+  for (const suffix of suffixes) {
+    const stacksKey = `HAPPY_STACKS_${suffix}`;
+    const localKey = `HAPPY_LOCAL_${suffix}`;
+    const stacksVal = (process.env[stacksKey] ?? '').trim();
+    const localVal = (process.env[localKey] ?? '').trim();
+    if (stacksVal) {
+      // Stacks wins.
+      process.env[stacksKey] = stacksVal;
+      process.env[localKey] = stacksVal;
+    } else if (localVal) {
+      // Legacy -> stacks.
+      process.env[localKey] = localVal;
+      process.env[stacksKey] = localVal;
+    }
+  }
+}
+
+const __homeDir = resolveHomeDir();
+process.env.HAPPY_STACKS_HOME_DIR = process.env.HAPPY_STACKS_HOME_DIR ?? __homeDir;
+
+// Prefer canonical home config:
+//   ~/.happy-stacks/.env
+//   ~/.happy-stacks/env.local
+//
+// Backwards compatible fallback for cloned-repo usage (when home config doesn't exist yet):
+//   <repo>/.env
+//   <repo>/env.local
+const homeEnv = join(__homeDir, '.env');
+const homeLocal = join(__homeDir, 'env.local');
+const hasHomeConfig = existsSync(homeEnv) || existsSync(homeLocal);
+
+// 1) Load defaults first (lowest precedence)
+if (hasHomeConfig) {
+  await loadEnvFile(homeEnv, { override: false });
+  await loadEnvFile(homeLocal, { override: true, overridePrefix: 'HAPPY_LOCAL_' });
+  await loadEnvFile(homeLocal, { override: true, overridePrefix: 'HAPPY_STACKS_' });
+} else {
+  await loadEnvFile(join(__cliRootDir, '.env'), { override: false });
+  await loadEnvFile(join(__cliRootDir, 'env.local'), { override: true, overridePrefix: 'HAPPY_LOCAL_' });
+  await loadEnvFile(join(__cliRootDir, 'env.local'), { override: true, overridePrefix: 'HAPPY_STACKS_' });
+}
+
+// If no explicit env file is set, and we're on the default "main" stack, prefer the stack-scoped env file
+// if it exists: ~/.happy/stacks/main/env
+(() => {
+  const stacksEnv = (process.env.HAPPY_STACKS_ENV_FILE ?? '').trim();
+  const localEnv = (process.env.HAPPY_LOCAL_ENV_FILE ?? '').trim();
+  if (stacksEnv || localEnv) {
+    return;
+  }
+  const stackName = (process.env.HAPPY_STACKS_STACK ?? process.env.HAPPY_LOCAL_STACK ?? '').trim() || 'main';
+  if (stackName !== 'main') {
+    return;
+  }
+  const mainEnv = join(homedir(), '.happy', 'stacks', 'main', 'env');
+  if (!existsSync(mainEnv)) {
+    return;
+  }
+  process.env.HAPPY_STACKS_ENV_FILE = mainEnv;
+  process.env.HAPPY_LOCAL_ENV_FILE = mainEnv;
+})();
+// 3) Load explicit env file overlay (stack env, or any caller-provided env file) last (highest precedence)
+if (process.env.HAPPY_STACKS_ENV_FILE?.trim()) {
+  await loadEnvFile(process.env.HAPPY_STACKS_ENV_FILE.trim(), { override: true, overridePrefix: 'HAPPY_STACKS_' });
+}
+if (process.env.HAPPY_LOCAL_ENV_FILE?.trim()) {
+  await loadEnvFile(process.env.HAPPY_LOCAL_ENV_FILE.trim(), { override: true, overridePrefix: 'HAPPY_LOCAL_' });
+}
+
+// Make both prefixes available to the rest of the codebase.
+applyStacksPrefixMapping();
+
+// Corepack strictness can prevent running Yarn in subfolders when the repo root is pinned to pnpm.
+// We intentionally keep component repos upstream-compatible (often Yarn), so relax strictness for child processes.
+process.env.COREPACK_ENABLE_STRICT = process.env.COREPACK_ENABLE_STRICT ?? '0';
+process.env.NPM_CONFIG_PACKAGE_MANAGER_STRICT = process.env.NPM_CONFIG_PACKAGE_MANAGER_STRICT ?? 'false';
+
+// LaunchAgents often run with a very minimal PATH which won't include NVM's bin dir, so child
+// processes like `yarn` / `pnpm` can look "missing" even though Node is running from NVM.
+// Ensure the directory containing this Node binary is on PATH.
+(() => {
+  const delimiter = process.platform === 'win32' ? ';' : ':';
+  const current = (process.env.PATH ?? '').split(delimiter).filter(Boolean);
+  const nodeBinDir = dirname(process.execPath);
+  const want = [nodeBinDir, '/opt/homebrew/bin', '/opt/homebrew/sbin', '/usr/local/bin'];
+  const next = [...want.filter((p) => p && !current.includes(p)), ...current];
+  process.env.PATH = next.join(delimiter);
+})();

package/scripts/utils/env_file.mjs

@@ -0,0 +1,59 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { pathExists } from './fs.mjs';
+
+export async function ensureEnvFileUpdated({ envPath, updates }) {
+  if (!updates.length) {
+    return;
+  }
+  await mkdir(dirname(envPath), { recursive: true });
+  await writeFileIfChanged(envPath, applyEnvUpdates(await readText(envPath), updates), envPath);
+}
+
+async function readText(path) {
+  try {
+    return (await pathExists(path)) ? await readFile(path, 'utf-8') : '';
+  } catch {
+    return '';
+  }
+}
+
+function applyEnvUpdates(existing, updates) {
+  const lines = existing.split('\n');
+  const next = [...lines];
+
+  const upsert = (key, value) => {
+    const line = `${key}=${value}`;
+    const idx = next.findIndex((l) => l.trim().startsWith(`${key}=`));
+    if (idx >= 0) {
+      next[idx] = line;
+    } else {
+      if (next.length && next[next.length - 1].trim() !== '') {
+        next.push('');
+      }
+      next.push(line);
+    }
+  };
+
+  for (const { key, value } of updates) {
+    upsert(key, value);
+  }
+
+  return next.join('\n');
+}
+
+async function writeFileIfChanged(existingContent, nextContent, path) {
+  const normalizedNext = nextContent.endsWith('\n') ? nextContent : nextContent + '\n';
+  const normalizedExisting = existingContent.endsWith('\n') ? existingContent : existingContent + (existingContent ? '\n' : '');
+  if (normalizedExisting === normalizedNext) {
+    return;
+  }
+  try {
+    const dir = dirname(path);
+    // if dir doesn't exist, writeFile will throw; that's fine (we only target known files).
+    void dir;
+  } catch {
+    // ignore
+  }
+  await writeFile(path, normalizedNext, 'utf-8');
+}

package/scripts/utils/env_local.mjs

@@ -0,0 +1,25 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { ensureEnvFileUpdated } from './env_file.mjs';
+import { ensureUserConfigEnvUpdated, getHomeEnvLocalPath, getHomeEnvPath } from './config.mjs';
+
+export async function ensureEnvLocalUpdated({ rootDir, updates }) {
+  // Behavior:
+  // - If a stack env file is explicitly set, write there (stack-scoped).
+  // - If the user has run `happys init` (home config exists), write to the main stack env file (user config).
+  // - If no home config exists (legacy cloned-repo usage), write to <repo>/env.local for repo-local behavior.
+  const explicit = (process.env.HAPPY_STACKS_ENV_FILE ?? process.env.HAPPY_LOCAL_ENV_FILE ?? '').trim();
+  if (explicit) {
+    await ensureEnvFileUpdated({ envPath: explicit, updates });
+    return;
+  }
+
+  const hasHomeConfig = existsSync(getHomeEnvPath()) || existsSync(getHomeEnvLocalPath());
+  if (hasHomeConfig) {
+    await ensureUserConfigEnvUpdated({ cliRootDir: rootDir, updates });
+    return;
+  }
+
+  await ensureEnvFileUpdated({ envPath: join(rootDir, 'env.local'), updates });
+}

package/scripts/utils/fs.mjs

@@ -0,0 +1,11 @@
+import { access } from 'node:fs/promises';
+
+export async function pathExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+