happy-stacks 0.0.0

package/scripts/tailscale.mjs

@@ -0,0 +1,278 @@
+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';
+
+/**
+ * Manage Tailscale Serve for exposing the local UI/API over HTTPS (secure context).
+ *
+ * This wraps:
+ * - `tailscale serve --bg http://127.0.0.1:3005`
+ * - `tailscale serve status`
+ * - `tailscale serve reset`
+ *
+ * Commands:
+ * - status
+ * - enable
+ * - disable (alias: reset)
+ * - url (print the first https:// URL from status output)
+ */
+
+function getInternalServerUrl() {
+  const port = process.env.HAPPY_LOCAL_SERVER_PORT?.trim() ? Number(process.env.HAPPY_LOCAL_SERVER_PORT) : 3005;
+  return `http://127.0.0.1:${port}`;
+}
+
+function getServeConfig(internalServerUrl) {
+  const upstream = process.env.HAPPY_LOCAL_TAILSCALE_UPSTREAM?.trim()
+    ? process.env.HAPPY_LOCAL_TAILSCALE_UPSTREAM.trim()
+    : internalServerUrl;
+  const servePath = process.env.HAPPY_LOCAL_TAILSCALE_SERVE_PATH?.trim()
+    ? process.env.HAPPY_LOCAL_TAILSCALE_SERVE_PATH.trim()
+    : '/';
+  return { upstream, servePath };
+}
+
+function extractHttpsUrl(serveStatusText) {
+  const line = serveStatusText
+    .split('\n')
+    .map((l) => l.trim())
+    .find((l) => l.toLowerCase().includes('https://'));
+  if (!line) return null;
+  const m = line.match(/https:\/\/\S+/i);
+  return m ? m[0] : null;
+}
+
+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 {
+    await runCapture('tailscale', ['version']);
+    return 'tailscale';
+  } catch {
+    // fall through
+  }
+
+  // Common macOS app install path.
+  const appPath = '/Applications/Tailscale.app/Contents/MacOS/Tailscale';
+  try {
+    await runCapture(appPath, ['version']);
+    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}"`
+  );
+}
+
+export async function tailscaleServeHttpsUrl() {
+  try {
+    const status = await tailscaleServeStatus();
+    return extractHttpsUrl(status);
+  } catch {
+    return null;
+  }
+}
+
+export async function tailscaleServeStatus() {
+  const cmd = await resolveTailscaleCmd();
+  return await runCapture(cmd, ['serve', 'status']);
+}
+
+export async function tailscaleServeEnable({ internalServerUrl }) {
+  const cmd = await resolveTailscaleCmd();
+  const { upstream, servePath } = getServeConfig(internalServerUrl);
+  const args = ['serve', '--bg'];
+  if (servePath && servePath !== '/' && servePath !== '') {
+    args.push(`--set-path=${servePath}`);
+  }
+  args.push(upstream);
+  await run(cmd, args);
+  const status = await runCapture(cmd, ['serve', 'status']).catch(() => '');
+  return { status, httpsUrl: status ? extractHttpsUrl(status) : null };
+}
+
+export async function tailscaleServeReset() {
+  const cmd = await resolveTailscaleCmd();
+  await run(cmd, ['serve', 'reset']);
+}
+
+export async function maybeEnableTailscaleServe({ internalServerUrl }) {
+  const enabled = (process.env.HAPPY_LOCAL_TAILSCALE_SERVE ?? '0') === '1';
+  if (!enabled) {
+    return null;
+  }
+  try {
+    return await tailscaleServeEnable({ internalServerUrl });
+  } catch (e) {
+    throw new Error(`[local] failed to enable tailscale serve (is Tailscale running/authenticated?): ${e instanceof Error ? e.message : String(e)}`);
+  }
+}
+
+export async function maybeResetTailscaleServe() {
+  const enabled = (process.env.HAPPY_LOCAL_TAILSCALE_SERVE ?? '0') === '1';
+  const resetOnExit = (process.env.HAPPY_LOCAL_TAILSCALE_RESET_ON_EXIT ?? '0') === '1';
+  if (!enabled || !resetOnExit) {
+    return;
+  }
+  try {
+    await tailscaleServeReset();
+  } catch {
+    // ignore
+  }
+}
+
+async function sleep(ms) {
+  await new Promise((r) => setTimeout(r, ms));
+}
+
+/**
+ * Resolve the best public server URL to present to users / generate links.
+ *
+ * Priority:
+ * 1) explicit HAPPY_LOCAL_SERVER_URL override (if non-default)
+ * 2) if enabled, prefer existing https://*.ts.net from tailscale serve status
+ * 3) fallback to defaultPublicUrl
+ *
+ * If HAPPY_LOCAL_TAILSCALE_SERVE=1, this can also try to enable serve and wait briefly for Tailscale to come up.
+ */
+export async function resolvePublicServerUrl({
+  internalServerUrl,
+  defaultPublicUrl,
+  envPublicUrl,
+  allowEnable = true,
+}) {
+  const preferTailscalePublicUrl = (process.env.HAPPY_LOCAL_TAILSCALE_PREFER_PUBLIC_URL ?? '1') !== '0';
+  const userExplicitlySetPublicUrl =
+    !!envPublicUrl && envPublicUrl !== defaultPublicUrl && envPublicUrl !== internalServerUrl;
+
+  if (userExplicitlySetPublicUrl || !preferTailscalePublicUrl) {
+    return { publicServerUrl: envPublicUrl || defaultPublicUrl, source: 'env' };
+  }
+
+  // If serve is already configured, use its HTTPS URL if present.
+  const existing = await tailscaleServeHttpsUrl();
+  if (existing) {
+    return { publicServerUrl: existing, source: 'tailscale-status' };
+  }
+
+  const enableServe = (process.env.HAPPY_LOCAL_TAILSCALE_SERVE ?? '0') === '1';
+  if (!enableServe || !allowEnable) {
+    return { publicServerUrl: envPublicUrl || defaultPublicUrl, source: 'default' };
+  }
+
+  // Try enabling serve (best-effort); then wait a bit for Tailscale to be ready/configured.
+  try {
+    const res = await tailscaleServeEnable({ internalServerUrl });
+    if (res?.httpsUrl) {
+      return { publicServerUrl: res.httpsUrl, source: 'tailscale-enable' };
+    }
+  } catch {
+    // ignore and fall back to waiting/polling
+  }
+
+  const waitMs = process.env.HAPPY_LOCAL_TAILSCALE_WAIT_MS?.trim()
+    ? Number(process.env.HAPPY_LOCAL_TAILSCALE_WAIT_MS.trim())
+    : 15000;
+  const deadline = Date.now() + (Number.isFinite(waitMs) ? waitMs : 15000);
+  while (Date.now() < deadline) {
+    const url = await tailscaleServeHttpsUrl();
+    if (url) {
+      return { publicServerUrl: url, source: 'tailscale-wait' };
+    }
+    await sleep(500);
+  }
+
+  return { publicServerUrl: envPublicUrl || defaultPublicUrl, source: 'default' };
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  const { flags, kv } = 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', 'enable', 'disable', 'reset', 'url'] },
+      text: [
+        '[tailscale] usage:',
+        '  happys tailscale status [--json]',
+        '  happys tailscale enable [--json]',
+        '  happys tailscale disable [--json]',
+        '  happys tailscale url [--json]',
+        '',
+        'legacy (cloned repo):',
+        '  pnpm tailscale:status [--json]',
+        '',
+        'advanced:',
+        '  node scripts/tailscale.mjs enable --upstream=<url> --path=/ [--json]',
+      ].join('\n'),
+    });
+    return;
+  }
+
+  const internalServerUrl = getInternalServerUrl();
+  if (flags.has('--upstream') || kv.get('--upstream')) {
+    process.env.HAPPY_LOCAL_TAILSCALE_UPSTREAM = kv.get('--upstream') ?? internalServerUrl;
+  }
+  if (flags.has('--path') || kv.get('--path')) {
+    process.env.HAPPY_LOCAL_TAILSCALE_SERVE_PATH = kv.get('--path') ?? '/';
+  }
+
+  switch (cmd) {
+    case 'status': {
+      const status = await tailscaleServeStatus();
+      if (json) {
+        printResult({ json, data: { status, httpsUrl: extractHttpsUrl(status) } });
+      } else {
+      process.stdout.write(status);
+      }
+      return;
+    }
+    case 'url': {
+      const status = await tailscaleServeStatus();
+      const url = extractHttpsUrl(status);
+      if (!url) {
+        throw new Error('[local] no https:// URL found in `tailscale serve status` output');
+      }
+      printResult({ json, data: { url }, text: url });
+      return;
+    }
+    case 'enable': {
+      const res = await tailscaleServeEnable({ internalServerUrl });
+      printResult({
+        json,
+        data: { ok: true, httpsUrl: res.httpsUrl ?? null },
+        text: res.httpsUrl ? `[local] tailscale serve enabled: ${res.httpsUrl}` : '[local] tailscale serve enabled',
+      });
+      return;
+    }
+    case 'disable':
+    case 'reset': {
+      await tailscaleServeReset();
+      printResult({ json, data: { ok: true }, text: '[local] tailscale serve reset' });
+      return;
+    }
+    default:
+      throw new Error(`[local] unknown tailscale command: ${cmd}`);
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch((err) => {
+    console.error('[local] failed:', err);
+    process.exit(1);
+  });
+}

package/scripts/uninstall.mjs

@@ -0,0 +1,190 @@
+import './utils/env.mjs';
+
+import { rm } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+import { parseArgs } from './utils/args.mjs';
+import { printResult, wantsHelp, wantsJson } from './utils/cli.mjs';
+import { getHappyStacksHomeDir, getRootDir } from './utils/paths.mjs';
+import { getRuntimeDir } from './utils/runtime.mjs';
+
+function expandHome(p) {
+  return p.replace(/^~(?=\/)/, homedir());
+}
+
+function resolveWorkspaceDir({ rootDir, homeDir }) {
+  // Uninstall should never default to deleting the repo root (getWorkspaceDir() can fall back to cliRootDir).
+  const fromEnv = (process.env.HAPPY_STACKS_WORKSPACE_DIR ?? '').trim();
+  if (fromEnv) {
+    return expandHome(fromEnv);
+  }
+  void rootDir;
+  return join(homeDir, 'workspace');
+}
+
+function resolveSwiftbarPluginsDir() {
+  // Same logic as extras/swiftbar/install.sh.
+  const s =
+    'DIR="$(defaults read com.ameba.SwiftBar PluginDirectory 2>/dev/null)"; if [[ -n "$DIR" && -d "$DIR" ]]; then echo "$DIR"; exit 0; fi; D="$HOME/Library/Application Support/SwiftBar/Plugins"; if [[ -d "$D" ]]; then echo "$D"; exit 0; fi; echo ""';
+  const res = spawnSync('bash', ['-lc', s], { encoding: 'utf-8' });
+  const out = String(res.stdout ?? '').trim();
+  return out || null;
+}
+
+async function removeSwiftbarPluginFiles() {
+  if (process.platform !== 'darwin') {
+    return { ok: true, removed: 0, pluginsDir: null };
+  }
+  const pluginsDir = resolveSwiftbarPluginsDir();
+  if (!pluginsDir) {
+    return { ok: true, removed: 0, pluginsDir: null };
+  }
+
+  let removed = 0;
+  const patterns = ['happy-stacks.*.sh', 'happy-local.*.sh'];
+  for (const pat of patterns) {
+    const res = spawnSync('bash', ['-lc', `rm -f "${pluginsDir}"/${pat} 2>/dev/null || true`], { stdio: 'ignore' });
+    void res;
+    // best-effort count: if directory exists, we can scan remaining files; skip precise counts
+  }
+
+  // Count remaining matches (best-effort).
+  const check = spawnSync('bash', ['-lc', `ls -1 "${pluginsDir}"/happy-stacks.*.sh 2>/dev/null | wc -l | tr -d ' '`], {
+    encoding: 'utf-8',
+  });
+  const remaining = Number(String(check.stdout ?? '').trim());
+  if (Number.isFinite(remaining) && remaining === 0) {
+    removed = 1;
+  }
+  return { ok: true, removed, pluginsDir };
+}
+
+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: ['--remove-workspace', '--remove-stacks', '--yes'], json: true },
+      text: [
+        '[uninstall] usage:',
+        '  happys uninstall [--json]   # dry-run',
+        '  happys uninstall --yes [--json]',
+        '  happys uninstall --remove-workspace --yes',
+        '  happys uninstall --remove-stacks --yes',
+        '',
+        'notes:',
+        '  - default removes: runtime, shims, cache, SwiftBar assets + plugin files, and LaunchAgent services',
+        '  - stacks under ~/.happy/stacks are kept unless --remove-stacks is provided',
+      ].join('\n'),
+    });
+    return;
+  }
+
+  const rootDir = getRootDir(import.meta.url);
+  const homeDir = getHappyStacksHomeDir();
+  const runtimeDir = getRuntimeDir();
+  const workspaceDir = resolveWorkspaceDir({ rootDir, homeDir });
+
+  const yes = flags.has('--yes');
+  const removeWorkspace = flags.has('--remove-workspace');
+  const removeStacks = flags.has('--remove-stacks');
+
+  const dryRun = !yes;
+
+  // 1) Stop/uninstall services best-effort.
+  if (!dryRun) {
+    try {
+      spawnSync(process.execPath, [join(rootDir, 'scripts', 'service.mjs'), 'uninstall'], {
+        stdio: json ? 'ignore' : 'inherit',
+        env: process.env,
+        cwd: rootDir,
+      });
+    } catch {
+      // ignore
+    }
+  }
+
+  // 2) Remove SwiftBar plugin files best-effort.
+  const menubar = dryRun ? { ok: true, removed: 0, pluginsDir: resolveSwiftbarPluginsDir() } : await removeSwiftbarPluginFiles().catch(() => ({ ok: false, removed: 0, pluginsDir: null }));
+
+  // 3) Remove home-managed runtime + shims + extras + cache + env pointers.
+  const toRemove = [
+    join(homeDir, 'bin'),
+    join(homeDir, 'runtime'),
+    join(homeDir, 'extras'),
+    join(homeDir, 'cache'),
+    join(homeDir, '.env'),
+    join(homeDir, 'env.local'),
+  ];
+  const removedPaths = [];
+  for (const p of toRemove) {
+    try {
+      if (existsSync(p)) {
+        if (!dryRun) {
+          await rm(p, { recursive: true, force: true });
+        }
+        removedPaths.push(p);
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  // 4) Optionally remove workspace (components/worktrees).
+  if (removeWorkspace) {
+    const ws = expandHome(workspaceDir);
+    if (existsSync(ws)) {
+      if (!dryRun) {
+        await rm(ws, { recursive: true, force: true });
+      }
+      removedPaths.push(ws);
+    }
+  }
+
+  // 5) Optionally remove stacks data.
+  if (removeStacks) {
+    const stacksRoot = join(homedir(), '.happy', 'stacks');
+    if (existsSync(stacksRoot)) {
+      if (!dryRun) {
+        await rm(stacksRoot, { recursive: true, force: true });
+      }
+      removedPaths.push(stacksRoot);
+    }
+  }
+
+  printResult({
+    json,
+    data: {
+      ok: true,
+      homeDir,
+      runtimeDir,
+      workspaceDir,
+      removedPaths,
+      menubar,
+      removeWorkspace,
+      removeStacks,
+      dryRun,
+    },
+    text: [
+      dryRun ? '[uninstall] dry run (no changes made)' : '[uninstall] complete',
+      dryRun ? '[uninstall] re-run with --yes to apply removals' : null,
+      `[uninstall] home: ${homeDir}`,
+      `[uninstall] removed: ${removedPaths.length ? removedPaths.join(', ') : '(nothing)'}`,
+      menubar?.pluginsDir ? `[uninstall] SwiftBar plugins dir: ${menubar.pluginsDir}` : null,
+      removeWorkspace ? `[uninstall] workspace removed: ${workspaceDir}` : `[uninstall] workspace kept: ${workspaceDir}`,
+      removeStacks ? `[uninstall] stacks removed: ~/.happy/stacks` : `[uninstall] stacks kept: ~/.happy/stacks`,
+    ]
+      .filter(Boolean)
+      .join('\n'),
+  });
+}
+
+main().catch((err) => {
+  console.error('[uninstall] failed:', err);
+  process.exit(1);
+});

package/scripts/utils/args.mjs

@@ -0,0 +1,17 @@
+export function parseArgs(argv) {
+  const flags = new Set();
+  const kv = new Map();
+  for (const raw of argv) {
+    if (!raw.startsWith('--')) {
+      continue;
+    }
+    const [k, v] = raw.split('=', 2);
+    if (v === undefined) {
+      flags.add(k);
+    } else {
+      kv.set(k, v);
+    }
+  }
+  return { flags, kv };
+}
+

package/scripts/utils/cli.mjs

@@ -0,0 +1,24 @@
+export function wantsJson(argv, { flags = null } = {}) {
+  if (flags?.has('--json')) {
+    return true;
+  }
+  return argv.includes('--json');
+}
+
+export function wantsHelp(argv, { flags = null } = {}) {
+  if (flags?.has('--help')) {
+    return true;
+  }
+  return argv.includes('--help') || argv.includes('-h');
+}
+
+export function printResult({ json, data, text }) {
+  if (json) {
+    process.stdout.write(JSON.stringify(data ?? null, null, 2) + '\n');
+    return;
+  }
+  if (text) {
+    process.stdout.write(text.endsWith('\n') ? text : text + '\n');
+  }
+}
+