happy-stacks 0.0.0 → 0.1.2

package/scripts/stop.mjs

@@ -0,0 +1,157 @@
+import './utils/env.mjs';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+
+import { parseArgs } from './utils/args.mjs';
+import { printResult, wantsHelp, wantsJson } from './utils/cli.mjs';
+import { run, runCapture } from './utils/proc.mjs';
+import { getRootDir, resolveStackEnvPath } from './utils/paths.mjs';
+
+function usage() {
+  return [
+    '[stop] usage:',
+    '  happys stop [--except-stacks=main,exp1] [--yes] [--aggressive] [--no-docker] [--no-service] [--json]',
+    '',
+    'Stops stacks and related local processes (server, daemon, Expo, managed infra) using stack-scoped commands.',
+    '',
+    'Examples:',
+    '  happys stop --except-stacks=main --yes',
+    '  happys stop --yes --no-docker',
+    '  happys stop --except-stacks=main --yes --aggressive',
+  ].join('\n');
+}
+
+function parseCsv(raw) {
+  const s = String(raw ?? '').trim();
+  if (!s) return [];
+  return s
+    .split(',')
+    .map((p) => p.trim())
+    .filter(Boolean);
+}
+
+async function listAllStackNames() {
+  try {
+    // Reuse stack.mjs for enumeration (avoids duplicating legacy/new stack dir logic).
+    // Note: `stack list` intentionally omits `main`, so we add it back.
+    const rootDir = getRootDir(import.meta.url);
+    const out = await runCapture(process.execPath, [join(rootDir, 'scripts', 'stack.mjs'), 'list', '--json'], { cwd: rootDir });
+    const parsed = JSON.parse(out);
+    const stacks = Array.isArray(parsed?.stacks) ? parsed.stacks : [];
+    const all = ['main', ...stacks.filter((s) => s !== 'main')];
+    return all.sort();
+  } catch {
+    return ['main'];
+  }
+}
+
+async function main() {
+  const rootDir = getRootDir(import.meta.url);
+  const argv = process.argv.slice(2);
+  const { flags, kv } = parseArgs(argv);
+  const json = wantsJson(argv, { flags });
+
+  if (wantsHelp(argv, { flags })) {
+    printResult({ json, data: { ok: true }, text: usage() });
+    return;
+  }
+
+  const exceptStacks = new Set(parseCsv(kv.get('--except-stacks')));
+  const yes = flags.has('--yes');
+  const aggressive = flags.has('--aggressive');
+  const noDocker = flags.has('--no-docker');
+  const noService = flags.has('--no-service');
+
+  const stacks = await listAllStackNames();
+  const targets = stacks.filter((n) => !exceptStacks.has(n));
+
+  if (!targets.length) {
+    printResult({ json, data: { ok: true, stopped: [], skipped: stacks }, text: '[stop] nothing to do (all stacks excluded)' });
+    return;
+  }
+
+  if (!yes && !(process.stdin.isTTY && process.stdout.isTTY)) {
+    throw new Error('[stop] refusing to stop stacks without --yes in non-interactive mode');
+  }
+
+  if (!yes) {
+    // Simple confirm prompt (avoid importing wizard/rl here).
+    // eslint-disable-next-line no-console
+    console.log(`[stop] will stop stacks: ${targets.join(', ')}`);
+    // eslint-disable-next-line no-console
+    console.log('[stop] re-run with --yes to proceed');
+    process.exit(1);
+  }
+
+  const results = [];
+  const errors = [];
+  const skipped = [];
+
+  for (const stackName of targets) {
+    if (stackName !== 'main') {
+      const { envPath } = resolveStackEnvPath(stackName);
+      // Stack name might appear in directory listings, but if it has no env file, treat it as non-existent.
+      if (!existsSync(envPath)) {
+        skipped.push({ stackName, reason: 'missing_env', envPath });
+        continue;
+      }
+    }
+    try {
+      if (!noService) {
+        // Best-effort: stop autostart service for the stack so it doesn't restart what we just stopped.
+        // eslint-disable-next-line no-await-in-loop
+        await run(process.execPath, [join(rootDir, 'scripts', 'stack.mjs'), 'service', stackName, 'stop'], { cwd: rootDir }).catch(() => {});
+      }
+
+      const args = [
+        join(rootDir, 'scripts', 'stack.mjs'),
+        'stop',
+        stackName,
+        ...(aggressive ? ['--aggressive'] : []),
+        ...(noDocker ? ['--no-docker'] : []),
+      ];
+      if (json) {
+        // eslint-disable-next-line no-await-in-loop
+        const out = await runCapture(process.execPath, [...args, '--json'], { cwd: rootDir });
+        results.push({ stackName, out: JSON.parse(out) });
+      } else {
+        // eslint-disable-next-line no-await-in-loop
+        await run(process.execPath, args, { cwd: rootDir });
+        results.push({ stackName, ok: true });
+      }
+    } catch (e) {
+      errors.push({ stackName, error: e instanceof Error ? e.message : String(e) });
+    }
+  }
+
+  if (json) {
+    printResult({
+      json,
+      data: { ok: errors.length === 0, stopped: results, skipped, errors, exceptStacks: Array.from(exceptStacks) },
+    });
+    return;
+  }
+
+  // eslint-disable-next-line no-console
+  console.log(
+    `[stop] done (stopped=${results.length}${skipped.length ? ` skipped=${skipped.length}` : ''}${errors.length ? ` errors=${errors.length}` : ''})`
+  );
+  if (skipped.length) {
+    for (const s of skipped) {
+      // eslint-disable-next-line no-console
+      console.log(`[stop] skipped (${s.stackName}): ${s.reason}${s.envPath ? ` (${s.envPath})` : ''}`);
+    }
+  }
+  if (errors.length) {
+    for (const e of errors) {
+      // eslint-disable-next-line no-console
+      console.warn(`[stop] error (${e.stackName}): ${e.error}`);
+    }
+  }
+}
+
+main().catch((err) => {
+  console.error('[stop] failed:', err);
+  process.exit(1);
+});
+

package/scripts/tailscale.mjs

@@ -2,6 +2,8 @@ import './utils/env.mjs';
 import { parseArgs } from './utils/args.mjs';
 import { run, runCapture } from './utils/proc.mjs';
 import { printResult, wantsHelp, wantsJson } from './utils/cli.mjs';
+import { constants } from 'node:fs';
+import { access } from 'node:fs/promises';
 
 /**
  * Manage Tailscale Serve for exposing the local UI/API over HTTPS (secure context).
@@ -43,34 +45,123 @@ function extractHttpsUrl(serveStatusText) {
   return m ? m[0] : null;
 }
 
+function tailscaleStatusMatchesInternalServerUrl(status, internalServerUrl) {
+  const raw = (internalServerUrl ?? '').trim();
+  if (!raw) return true;
+
+  // Fast path.
+  if (status.includes(raw)) return true;
+
+  // Tailscale typically prints proxy targets like:
+  //   |-- / proxy http://127.0.0.1:3005
+  let port = '';
+  try {
+    port = new URL(raw).port;
+  } catch {
+    port = '';
+  }
+  if (!port) return false;
+
+  const re = new RegExp(String.raw`\\bproxy\\s+https?:\\/\\/(?:127\\.0\\.0\\.1|localhost|0\\.0\\.0\\.0):${port}\\b`, 'i');
+  return re.test(status);
+}
+
+export async function tailscaleServeHttpsUrlForInternalServerUrl(internalServerUrl) {
+  try {
+    const status = await tailscaleServeStatus();
+    const https = extractHttpsUrl(status);
+    if (!https) return null;
+    return tailscaleStatusMatchesInternalServerUrl(status, internalServerUrl) ? https : null;
+  } catch {
+    return null;
+  }
+}
+
+function extractServeEnableUrl(text) {
+  const m = String(text ?? '').match(/https:\/\/login\.tailscale\.com\/f\/serve\?node=\S+/i);
+  return m ? m[0] : null;
+}
+
+function parseTimeoutMs(raw, defaultMs) {
+  const s = (raw ?? '').trim();
+  if (!s) return defaultMs;
+  const n = Number(s);
+  // Allow 0 to disable timeouts for user-triggered commands.
+  if (!Number.isFinite(n)) return defaultMs;
+  return n > 0 ? n : 0;
+}
+
+function tailscaleProbeTimeoutMs() {
+  return parseTimeoutMs(process.env.HAPPY_LOCAL_TAILSCALE_CMD_TIMEOUT_MS, 2500);
+}
+
+function tailscaleUserEnableTimeoutMs() {
+  return parseTimeoutMs(process.env.HAPPY_LOCAL_TAILSCALE_ENABLE_TIMEOUT_MS, 30000);
+}
+
+function tailscaleAutoEnableTimeoutMs() {
+  return parseTimeoutMs(process.env.HAPPY_LOCAL_TAILSCALE_ENABLE_TIMEOUT_MS_AUTO, tailscaleProbeTimeoutMs());
+}
+
+function tailscaleUserResetTimeoutMs() {
+  return parseTimeoutMs(process.env.HAPPY_LOCAL_TAILSCALE_RESET_TIMEOUT_MS, 15000);
+}
+
+function tailscaleEnv() {
+  // LaunchAgents inherit `XPC_SERVICE_NAME`, which can confuse some CLI tools.
+  // In practice, we’ve seen Tailscale commands like `tailscale version` hang under
+  // this env. Strip it for any tailscale subprocesses.
+  const env = { ...process.env };
+  delete env.XPC_SERVICE_NAME;
+  return env;
+}
+
+async function isExecutable(path) {
+  try {
+    await access(path, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 async function resolveTailscaleCmd() {
   // Allow explicit override (useful for LaunchAgents where aliases don't exist).
   if (process.env.HAPPY_LOCAL_TAILSCALE_BIN?.trim()) {
     return process.env.HAPPY_LOCAL_TAILSCALE_BIN.trim();
   }
 
-  // Try PATH first.
+  // Try PATH first (without executing `tailscale`, which can hang in some environments).
   try {
-    await runCapture('tailscale', ['version']);
-    return 'tailscale';
+    const found = (await runCapture('sh', ['-lc', 'command -v tailscale 2>/dev/null || true'], { env: tailscaleEnv(), timeoutMs: tailscaleProbeTimeoutMs() })).trim();
+    if (found) {
+      return found;
+    }
   } catch {
-    // fall through
+    // ignore and fall back
+  }
+
+  // Common macOS app install paths.
+  //
+  // IMPORTANT:
+  // Prefer the lowercase `tailscale` CLI inside the app bundle. The capitalized
+  // `Tailscale` binary can behave differently under LaunchAgents (XPC env),
+  // potentially hanging instead of printing a version and exiting.
+  const appCliPath = '/Applications/Tailscale.app/Contents/MacOS/tailscale';
+  if (await isExecutable(appCliPath)) {
+    return appCliPath;
   }
 
-  // Common macOS app install path.
   const appPath = '/Applications/Tailscale.app/Contents/MacOS/Tailscale';
-  try {
-    await runCapture(appPath, ['version']);
+  if (await isExecutable(appPath)) {
     return appPath;
-  } catch {
-    // fall through
   }
 
   throw new Error(
     `[local] tailscale CLI not found.\n` +
     `- Install Tailscale, or\n` +
     `- Put 'tailscale' on PATH, or\n` +
-    `- Set HAPPY_LOCAL_TAILSCALE_BIN="${appPath}"`
+    `- Set HAPPY_LOCAL_TAILSCALE_BIN="${appCliPath}"`
   );
 }
 
@@ -85,10 +176,10 @@ export async function tailscaleServeHttpsUrl() {
 
 export async function tailscaleServeStatus() {
   const cmd = await resolveTailscaleCmd();
-  return await runCapture(cmd, ['serve', 'status']);
+  return await runCapture(cmd, ['serve', 'status'], { env: tailscaleEnv(), timeoutMs: tailscaleProbeTimeoutMs() });
 }
 
-export async function tailscaleServeEnable({ internalServerUrl }) {
+export async function tailscaleServeEnable({ internalServerUrl, timeoutMs } = {}) {
   const cmd = await resolveTailscaleCmd();
   const { upstream, servePath } = getServeConfig(internalServerUrl);
   const args = ['serve', '--bg'];
@@ -96,14 +187,39 @@ export async function tailscaleServeEnable({ internalServerUrl }) {
     args.push(`--set-path=${servePath}`);
   }
   args.push(upstream);
-  await run(cmd, args);
-  const status = await runCapture(cmd, ['serve', 'status']).catch(() => '');
+  const env = tailscaleEnv();
+  const timeout = Number.isFinite(timeoutMs) ? (timeoutMs > 0 ? timeoutMs : 0) : tailscaleUserEnableTimeoutMs();
+
+  try {
+    // `tailscale serve --bg` can hang in some environments (and should never block stack startup).
+    // Use a short, best-effort timeout; if it prints an enable URL, open it and return a helpful result.
+    await runCapture(cmd, args, { env, timeoutMs: timeout });
+  } catch (e) {
+    const out = e && typeof e === 'object' && 'out' in e ? e.out : '';
+    const err = e && typeof e === 'object' && 'err' in e ? e.err : '';
+    const msg = e instanceof Error ? e.message : String(e);
+    const combined = `${out ?? ''}\n${err ?? ''}\n${msg ?? ''}`.trim();
+    const enableUrl = extractServeEnableUrl(combined);
+    if (enableUrl) {
+      // User-initiated action (CLI / menubar): open the enable page.
+      try {
+        await run('open', [enableUrl]);
+      } catch {
+        // ignore (headless / restricted environment)
+      }
+      return { status: combined || String(e), httpsUrl: null, enableUrl };
+    }
+    throw e;
+  }
+
+  const status = await runCapture(cmd, ['serve', 'status'], { env, timeoutMs: tailscaleProbeTimeoutMs() }).catch(() => '');
   return { status, httpsUrl: status ? extractHttpsUrl(status) : null };
 }
 
-export async function tailscaleServeReset() {
+export async function tailscaleServeReset({ timeoutMs } = {}) {
   const cmd = await resolveTailscaleCmd();
-  await run(cmd, ['serve', 'reset']);
+  const timeout = Number.isFinite(timeoutMs) ? (timeoutMs > 0 ? timeoutMs : 0) : tailscaleUserResetTimeoutMs();
+  await run(cmd, ['serve', 'reset'], { env: tailscaleEnv(), timeoutMs: timeout });
 }
 
 export async function maybeEnableTailscaleServe({ internalServerUrl }) {
@@ -112,7 +228,8 @@ export async function maybeEnableTailscaleServe({ internalServerUrl }) {
     return null;
   }
   try {
-    return await tailscaleServeEnable({ internalServerUrl });
+    // This is called from automation; it must not hang for long.
+    return await tailscaleServeEnable({ internalServerUrl, timeoutMs: tailscaleAutoEnableTimeoutMs() });
   } catch (e) {
     throw new Error(`[local] failed to enable tailscale serve (is Tailscale running/authenticated?): ${e instanceof Error ? e.message : String(e)}`);
   }
@@ -125,7 +242,8 @@ export async function maybeResetTailscaleServe() {
     return;
   }
   try {
-    await tailscaleServeReset();
+    // Shutdown path: never block for long.
+    await tailscaleServeReset({ timeoutMs: tailscaleProbeTimeoutMs() });
   } catch {
     // ignore
   }
@@ -160,7 +278,7 @@ export async function resolvePublicServerUrl({
   }
 
   // If serve is already configured, use its HTTPS URL if present.
-  const existing = await tailscaleServeHttpsUrl();
+  const existing = await tailscaleServeHttpsUrlForInternalServerUrl(internalServerUrl);
   if (existing) {
     return { publicServerUrl: existing, source: 'tailscale-status' };
   }
@@ -172,7 +290,7 @@ export async function resolvePublicServerUrl({
 
   // Try enabling serve (best-effort); then wait a bit for Tailscale to be ready/configured.
   try {
-    const res = await tailscaleServeEnable({ internalServerUrl });
+    const res = await tailscaleServeEnable({ internalServerUrl, timeoutMs: tailscaleAutoEnableTimeoutMs() });
     if (res?.httpsUrl) {
       return { publicServerUrl: res.httpsUrl, source: 'tailscale-enable' };
     }
@@ -185,7 +303,7 @@ export async function resolvePublicServerUrl({
     : 15000;
   const deadline = Date.now() + (Number.isFinite(waitMs) ? waitMs : 15000);
   while (Date.now() < deadline) {
-    const url = await tailscaleServeHttpsUrl();
+    const url = await tailscaleServeHttpsUrlForInternalServerUrl(internalServerUrl);
     if (url) {
       return { publicServerUrl: url, source: 'tailscale-wait' };
     }
@@ -252,6 +370,14 @@ async function main() {
     }
     case 'enable': {
       const res = await tailscaleServeEnable({ internalServerUrl });
+      if (res?.enableUrl && !res?.httpsUrl) {
+        printResult({
+          json,
+          data: { ok: true, httpsUrl: null, enableUrl: res.enableUrl },
+          text: `[local] tailscale serve is not enabled for this tailnet. Opened:\n${res.enableUrl}`,
+        });
+        return;
+      }
       printResult({
         json,
         data: { ok: true, httpsUrl: res.httpsUrl ?? null },

package/scripts/typecheck.mjs

@@ -0,0 +1,145 @@
+import './utils/env.mjs';
+import { parseArgs } from './utils/args.mjs';
+import { printResult, wantsHelp, wantsJson } from './utils/cli.mjs';
+import { getComponentDir, getRootDir } from './utils/paths.mjs';
+import { ensureDepsInstalled, requirePnpm } from './utils/pm.mjs';
+import { pathExists } from './utils/fs.mjs';
+import { run } from './utils/proc.mjs';
+import { join } from 'node:path';
+import { readFile } from 'node:fs/promises';
+
+const DEFAULT_COMPONENTS = ['happy', 'happy-cli', 'happy-server-light', 'happy-server'];
+
+async function detectPackageManagerCmd(dir) {
+  if (await pathExists(join(dir, 'yarn.lock'))) {
+    return { name: 'yarn', cmd: 'yarn', argsForScript: (script) => ['-s', script] };
+  }
+  await requirePnpm();
+  return { name: 'pnpm', cmd: 'pnpm', argsForScript: (script) => ['--silent', script] };
+}
+
+async function readScripts(dir) {
+  try {
+    const raw = await readFile(join(dir, 'package.json'), 'utf-8');
+    const pkg = JSON.parse(raw);
+    const scripts = pkg?.scripts && typeof pkg.scripts === 'object' ? pkg.scripts : {};
+    return scripts;
+  } catch {
+    return null;
+  }
+}
+
+function pickTypecheckScript(scripts) {
+  if (!scripts) return null;
+  const candidates = [
+    'typecheck',
+    'type-check',
+    'check-types',
+    'check:types',
+    'tsc',
+    'typescript',
+  ];
+  return candidates.find((k) => typeof scripts[k] === 'string' && scripts[k].trim()) ?? null;
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  const { flags } = parseArgs(argv);
+  const json = wantsJson(argv, { flags });
+
+  if (wantsHelp(argv, { flags })) {
+    printResult({
+      json,
+      data: { components: DEFAULT_COMPONENTS, flags: ['--json'] },
+      text: [
+        '[typecheck] usage:',
+        '  happys typecheck [component...] [--json]',
+        '',
+        'components:',
+        `  ${DEFAULT_COMPONENTS.join(' | ')}`,
+        '',
+        'examples:',
+        '  happys typecheck',
+        '  happys typecheck happy happy-cli',
+      ].join('\n'),
+    });
+    return;
+  }
+
+  const positionals = argv.filter((a) => !a.startsWith('--'));
+  const requested = positionals.length ? positionals : ['all'];
+  const wantAll = requested.includes('all');
+  const components = wantAll ? DEFAULT_COMPONENTS : requested;
+
+  const rootDir = getRootDir(import.meta.url);
+
+  const results = [];
+  for (const component of components) {
+    if (!DEFAULT_COMPONENTS.includes(component)) {
+      results.push({ component, ok: false, skipped: false, error: `unknown component (expected one of: ${DEFAULT_COMPONENTS.join(', ')})` });
+      continue;
+    }
+
+    const dir = getComponentDir(rootDir, component);
+    if (!(await pathExists(dir))) {
+      results.push({ component, ok: false, skipped: false, dir, error: `missing component dir: ${dir}` });
+      continue;
+    }
+
+    const scripts = await readScripts(dir);
+    if (!scripts) {
+      results.push({ component, ok: true, skipped: true, dir, reason: 'no package.json' });
+      continue;
+    }
+
+    const script = pickTypecheckScript(scripts);
+    if (!script) {
+      results.push({ component, ok: true, skipped: true, dir, reason: 'no typecheck script found in package.json' });
+      continue;
+    }
+
+    await ensureDepsInstalled(dir, component);
+    const pm = await detectPackageManagerCmd(dir);
+
+    try {
+      // eslint-disable-next-line no-console
+      console.log(`[typecheck] ${component}: running ${pm.name} ${script}`);
+      await run(pm.cmd, pm.argsForScript(script), { cwd: dir, env: process.env });
+      results.push({ component, ok: true, skipped: false, dir, pm: pm.name, script });
+    } catch (e) {
+      results.push({ component, ok: false, skipped: false, dir, pm: pm.name, script, error: String(e?.message ?? e) });
+    }
+  }
+
+  const ok = results.every((r) => r.ok);
+  if (json) {
+    printResult({ json, data: { ok, results } });
+    return;
+  }
+
+  const lines = ['[typecheck] results:'];
+  for (const r of results) {
+    if (r.ok && r.skipped) {
+      lines.push(`- ↪ ${r.component}: skipped (${r.reason})`);
+    } else if (r.ok) {
+      lines.push(`- ✅ ${r.component}: ok (${r.pm} ${r.script})`);
+    } else {
+      lines.push(`- ❌ ${r.component}: failed (${r.pm ?? 'unknown'} ${r.script ?? ''})`);
+      if (r.error) lines.push(`  - ${r.error}`);
+    }
+  }
+  if (!ok) {
+    lines.push('');
+    lines.push('[typecheck] failed');
+  }
+  printResult({ json: false, text: lines.join('\n') });
+  if (!ok) {
+    process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error('[typecheck] failed:', err);
+  process.exit(1);
+});
+