happy-stacks 0.0.0 → 0.1.2

package/scripts/ui_gateway.mjs

@@ -0,0 +1,248 @@
+import './utils/env.mjs';
+import http from 'node:http';
+import net from 'node:net';
+import { extname, resolve, sep } from 'node:path';
+import { readFile, stat } from 'node:fs/promises';
+
+import { parseArgs } from './utils/args.mjs';
+import { printResult, wantsHelp, wantsJson } from './utils/cli.mjs';
+
+function usage() {
+  return [
+    '[ui-gateway] usage:',
+    '  node scripts/ui_gateway.mjs --port=<port> --backend-url=<url> --minio-port=<port> --bucket=<name> [--ui-dir=<path>] [--no-ui]',
+    '',
+    'Reverse-proxy gateway that can optionally serve the built Happy web UI at /.',
+    '',
+    'Always proxies:',
+    '- /v1/* and /health to backend-url',
+    '- /v1/updates websocket upgrades to backend-url (socket.io)',
+    '- /files/* to local Minio (http://127.0.0.1:<minio-port>/<bucket>/...)',
+  ].join('\n');
+}
+
+function normalizePublicPath(path) {
+  const p = String(path ?? '').replace(/\\/g, '/').replace(/^\/+/, '');
+  const parts = p.split('/').filter(Boolean);
+  if (parts.some((part) => part === '..')) {
+    throw new Error('Invalid path');
+  }
+  if (p.includes(':') || p.startsWith('/')) {
+    throw new Error('Invalid path');
+  }
+  return parts.join('/');
+}
+
+function contentTypeForExt(ext) {
+  const e = ext.toLowerCase();
+  if (e === '.html') return 'text/html; charset=utf-8';
+  if (e === '.js') return 'text/javascript; charset=utf-8';
+  if (e === '.css') return 'text/css; charset=utf-8';
+  if (e === '.json') return 'application/json; charset=utf-8';
+  if (e === '.svg') return 'image/svg+xml';
+  if (e === '.ico') return 'image/x-icon';
+  if (e === '.wasm') return 'application/wasm';
+  if (e === '.ttf') return 'font/ttf';
+  if (e === '.woff') return 'font/woff';
+  if (e === '.woff2') return 'font/woff2';
+  if (e === '.png') return 'image/png';
+  if (e === '.jpg' || e === '.jpeg') return 'image/jpeg';
+  if (e === '.webp') return 'image/webp';
+  if (e === '.gif') return 'image/gif';
+  return 'application/octet-stream';
+}
+
+async function sendUiFile({ uiRoot, relPath, res }) {
+  const candidate = resolve(uiRoot, relPath);
+  if (!(candidate === uiRoot || candidate.startsWith(uiRoot + sep))) {
+    res.writeHead(404, { 'content-type': 'text/plain; charset=utf-8' });
+    res.end('Not found');
+    return;
+  }
+  const bytes = await readFile(candidate);
+  const ext = extname(candidate);
+  const isHtml = ext.toLowerCase() === '.html';
+  res.setHeader('content-type', contentTypeForExt(ext));
+  if (isHtml) {
+    res.setHeader('cache-control', 'no-cache');
+  } else {
+    res.setHeader('cache-control', 'public, max-age=31536000, immutable');
+  }
+  res.end(bytes);
+}
+
+async function sendIndex({ uiRoot, res }) {
+  const indexPath = resolve(uiRoot, 'index.html');
+  const html = (await readFile(indexPath, 'utf-8')) + '\n<!-- Welcome to Happy Server! -->\n';
+  res.writeHead(200, { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-cache' });
+  res.end(html);
+}
+
+function proxyHttp({ target, req, res, rewritePath = (p) => p }) {
+  const url = new URL(target);
+  const method = req.method || 'GET';
+  const headers = { ...req.headers };
+  // Let Node compute correct host
+  delete headers.host;
+
+  const upstream = http.request(
+    {
+      protocol: url.protocol,
+      hostname: url.hostname,
+      port: url.port,
+      method,
+      path: rewritePath(req.url || '/'),
+      headers,
+    },
+    (up) => {
+      res.writeHead(up.statusCode || 502, up.headers);
+      up.pipe(res);
+    }
+  );
+  upstream.on('error', () => {
+    res.writeHead(502, { 'content-type': 'text/plain; charset=utf-8' });
+    res.end('Bad gateway');
+  });
+  req.pipe(upstream);
+}
+
+function proxyUpgrade({ target, req, socket, head }) {
+  const url = new URL(target);
+  const port = url.port ? Number(url.port) : url.protocol === 'https:' ? 443 : 80;
+
+  const upstream = net.connect(port, url.hostname, () => {
+    const lines = [`${req.method} ${req.url} HTTP/${req.httpVersion}`];
+    for (let i = 0; i < req.rawHeaders.length; i += 2) {
+      lines.push(`${req.rawHeaders[i]}: ${req.rawHeaders[i + 1]}`);
+    }
+    lines.push('', '');
+    upstream.write(lines.join('\r\n'));
+    if (head?.length) upstream.write(head);
+    socket.pipe(upstream).pipe(socket);
+  });
+  upstream.on('error', () => {
+    try {
+      socket.destroy();
+    } catch {
+      // ignore
+    }
+  });
+}
+
+async function main() {
+  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 portRaw = (kv.get('--port') ?? '').trim();
+  const backendUrl = (kv.get('--backend-url') ?? '').trim();
+  const minioPortRaw = (kv.get('--minio-port') ?? '').trim();
+  const bucket = (kv.get('--bucket') ?? '').trim();
+  const serveUi = !flags.has('--no-ui') && (process.env.HAPPY_LOCAL_SERVE_UI ?? '1') !== '0';
+  const uiDir = serveUi ? (kv.get('--ui-dir') ?? '').trim() : '';
+
+  const port = portRaw ? Number(portRaw) : NaN;
+  const minioPort = minioPortRaw ? Number(minioPortRaw) : NaN;
+
+  if (!backendUrl || !bucket || !Number.isFinite(port) || port <= 0 || !Number.isFinite(minioPort) || minioPort <= 0) {
+    throw new Error(usage());
+  }
+
+  const uiRoot = uiDir ? resolve(uiDir) : '';
+
+  const server = http.createServer(async (req, res) => {
+    try {
+      const url = req.url || '/';
+
+      // API + health proxy
+      if (url.startsWith('/v1/') || url === '/health' || url === '/metrics' || url.startsWith('/v2/')) {
+        proxyHttp({ target: backendUrl, req, res });
+        return;
+      }
+
+      // Public files proxy (Minio path-style)
+      if (url.startsWith('/files/')) {
+        proxyHttp({
+          target: `http://127.0.0.1:${minioPort}`,
+          req,
+          res,
+          rewritePath: (p) => {
+            const raw = p.replace(/^\/files\/?/, '');
+            const safe = normalizePublicPath(raw);
+            return `/${encodeURIComponent(bucket)}/${safe}`;
+          },
+        });
+        return;
+      }
+
+      // UI static
+      if (url === '/' || url === '/ui' || url === '/ui/') {
+        if (uiRoot) {
+          await sendIndex({ uiRoot, res });
+          return;
+        }
+        res.writeHead(200, { 'content-type': 'text/plain; charset=utf-8', 'cache-control': 'no-cache' });
+        res.end('Welcome to Happy Server!');
+        return;
+      }
+      if (url.startsWith('/ui/')) {
+        res.writeHead(302, { location: '/' });
+        res.end();
+        return;
+      }
+
+      if (uiRoot) {
+        const rel = normalizePublicPath(decodeURIComponent(url));
+        const candidate = resolve(uiRoot, rel);
+        const exists = candidate === uiRoot || candidate.startsWith(uiRoot + sep) ? await stat(candidate).then(() => true).catch(() => false) : false;
+        if (exists) {
+          await sendUiFile({ uiRoot, relPath: rel, res });
+          return;
+        }
+
+        // SPA fallback
+        await sendIndex({ uiRoot, res });
+        return;
+      }
+
+      res.writeHead(404, { 'content-type': 'text/plain; charset=utf-8' });
+      res.end('Not found');
+    } catch {
+      res.writeHead(500, { 'content-type': 'text/plain; charset=utf-8' });
+      res.end('Internal error');
+    }
+  });
+
+  server.on('upgrade', (req, socket, head) => {
+    try {
+      const url = req.url || '';
+      // socket.io upgrades for realtime updates
+      if (url.startsWith('/v1/updates')) {
+        proxyUpgrade({ target: backendUrl, req, socket, head });
+        return;
+      }
+      socket.destroy();
+    } catch {
+      try {
+        socket.destroy();
+      } catch {
+        // ignore
+      }
+    }
+  });
+
+  await new Promise((resolvePromise) => server.listen({ port, host: '0.0.0.0' }, resolvePromise));
+  // eslint-disable-next-line no-console
+  console.log(`[ui-gateway] ready on http://127.0.0.1:${port}`);
+}
+
+main().catch((err) => {
+  // eslint-disable-next-line no-console
+  console.error(err);
+  process.exit(1);
+});
+

package/scripts/uninstall.mjs

@@ -8,7 +8,7 @@ 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 { getHappyStacksHomeDir, getRootDir, getStacksStorageRoot } from './utils/paths.mjs';
 import { getRuntimeDir } from './utils/runtime.mjs';
 
 function expandHome(p) {
@@ -148,7 +148,7 @@ async function main() {
 
   // 5) Optionally remove stacks data.
   if (removeStacks) {
-    const stacksRoot = join(homedir(), '.happy', 'stacks');
+    const stacksRoot = getStacksStorageRoot();
     if (existsSync(stacksRoot)) {
       if (!dryRun) {
         await rm(stacksRoot, { recursive: true, force: true });
@@ -177,7 +177,7 @@ async function main() {
       `[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`,
+      removeStacks ? `[uninstall] stacks removed: ${getStacksStorageRoot()}` : `[uninstall] stacks kept: ${getStacksStorageRoot()}`,
     ]
       .filter(Boolean)
       .join('\n'),

package/scripts/utils/cli_registry.mjs

@@ -57,6 +57,13 @@ export function getHappysRegistry() {
       rootUsage: 'happys dev [-- ...]',
       description: 'Start local stack (dev)',
     },
+    {
+      name: 'stop',
+      kind: 'node',
+      scriptRelPath: 'scripts/stop.mjs',
+      rootUsage: 'happys stop [--except-stacks=main,exp1] [--yes] [--aggressive] [--no-docker] [--no-service] [--json]',
+      description: 'Stop stacks and related local processes',
+    },
     {
       name: 'build',
       kind: 'node',
@@ -64,6 +71,21 @@ export function getHappysRegistry() {
       rootUsage: 'happys build [-- ...]',
       description: 'Build UI bundle',
     },
+    {
+      name: 'typecheck',
+      aliases: ['type-check', 'check-types'],
+      kind: 'node',
+      scriptRelPath: 'scripts/typecheck.mjs',
+      rootUsage: 'happys typecheck [component...] [--json]',
+      description: 'Run TypeScript typechecks for components',
+    },
+    {
+      name: 'migrate',
+      kind: 'node',
+      scriptRelPath: 'scripts/migrate.mjs',
+      rootUsage: 'happys migrate light-to-server --from-stack=<name> --to-stack=<name> [--include-files] [--force] [--json]',
+      description: 'Migrate data between server flavors (experimental)',
+    },
     {
       name: 'mobile',
       kind: 'node',
@@ -260,3 +282,4 @@ export function renderHappysRootHelp() {
     '  happys help [command]',
   ].join('\n');
 }
+

package/scripts/utils/config.mjs

@@ -1,4 +1,5 @@
 import { join } from 'node:path';
+import { homedir } from 'node:os';
 import { ensureEnvFileUpdated } from './env_file.mjs';
 import { getHappyStacksHomeDir, resolveStackEnvPath } from './paths.mjs';
 
@@ -6,6 +7,10 @@ export function getHomeEnvPath() {
   return join(getHappyStacksHomeDir(), '.env');
 }
 
+export function getCanonicalHomeEnvPath() {
+  return join(homedir(), '.happy-stacks', '.env');
+}
+
 export function getHomeEnvLocalPath() {
   return join(getHappyStacksHomeDir(), 'env.local');
 }
@@ -28,6 +33,10 @@ export async function ensureHomeEnvUpdated({ updates }) {
   await ensureEnvFileUpdated({ envPath: getHomeEnvPath(), updates });
 }
 
+export async function ensureCanonicalHomeEnvUpdated({ updates }) {
+  await ensureEnvFileUpdated({ envPath: getCanonicalHomeEnvPath(), updates });
+}
+
 export async function ensureHomeEnvLocalUpdated({ updates }) {
   await ensureEnvFileUpdated({ envPath: getHomeEnvLocalPath(), updates });
 }
@@ -37,4 +46,3 @@ export async function ensureUserConfigEnvUpdated({ cliRootDir, updates }) {
   await ensureEnvFileUpdated({ envPath, updates });
   return envPath;
 }
-

package/scripts/utils/env.mjs

@@ -65,6 +65,17 @@ function applyStacksPrefixMapping() {
   }
 }
 
+// If HAPPY_STACKS_HOME_DIR isn't set, try the canonical pointer file at ~/.happy-stacks/.env first.
+//
+// This allows installs where the "real" home/workspace/runtime are elsewhere, while still
+// giving us a stable discovery location for launchd/SwiftBar/minimal shells.
+const canonicalEnvPath = join(homedir(), '.happy-stacks', '.env');
+if (!(process.env.HAPPY_STACKS_HOME_DIR ?? '').trim() && existsSync(canonicalEnvPath)) {
+  await loadEnvFile(canonicalEnvPath, { override: false });
+  await loadEnvFile(canonicalEnvPath, { override: true, overridePrefix: 'HAPPY_STACKS_' });
+  await loadEnvFile(canonicalEnvPath, { override: true, overridePrefix: 'HAPPY_LOCAL_' });
+}
+
 const __homeDir = resolveHomeDir();
 process.env.HAPPY_STACKS_HOME_DIR = process.env.HAPPY_STACKS_HOME_DIR ?? __homeDir;
 
@@ -99,22 +110,33 @@ if (hasHomeConfig) {
     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;
+  const stacksStorageRootRaw = (process.env.HAPPY_STACKS_STORAGE_DIR ?? process.env.HAPPY_LOCAL_STORAGE_DIR ?? '').trim();
+  const stacksStorageRoot = stacksStorageRootRaw ? expandHome(stacksStorageRootRaw) : join(homedir(), '.happy', 'stacks');
+  const legacyStacksRoot = join(homedir(), '.happy', 'local', 'stacks');
+
+  const candidates = [
+    join(stacksStorageRoot, stackName, 'env'),
+    join(legacyStacksRoot, stackName, 'env'),
+  ];
+  const envPath = candidates.find((p) => existsSync(p));
+  if (!envPath) return;
+
+  process.env.HAPPY_STACKS_ENV_FILE = envPath;
+  process.env.HAPPY_LOCAL_ENV_FILE = envPath;
 })();
-// 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_' });
+// 3) Load explicit env file overlay (stack env, or any caller-provided env file) last (highest precedence).
+//
+// IMPORTANT:
+// Stack env files intentionally include some non-prefixed keys (e.g. DATABASE_URL, HAPPY_SERVER_LIGHT_DATA_DIR)
+// that must apply for true per-stack isolation. Do not filter by prefix here.
+{
+  const stacksEnv = process.env.HAPPY_STACKS_ENV_FILE?.trim() ? process.env.HAPPY_STACKS_ENV_FILE.trim() : '';
+  const localEnv = process.env.HAPPY_LOCAL_ENV_FILE?.trim() ? process.env.HAPPY_LOCAL_ENV_FILE.trim() : '';
+  const unique = Array.from(new Set([stacksEnv, localEnv].filter(Boolean)));
+  for (const p of unique) {
+    // eslint-disable-next-line no-await-in-loop
+    await loadEnvFile(p, { override: true });
+  }
 }
 
 // Make both prefixes available to the rest of the codebase.

package/scripts/utils/expo.mjs

@@ -0,0 +1,94 @@
+import { createHash } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+
+function hashDir(dir) {
+  return createHash('sha1').update(String(dir ?? '')).digest('hex').slice(0, 12);
+}
+
+export function getExpoStatePaths({ baseDir, kind, projectDir, stateFileName = 'expo.state.json' }) {
+  const key = hashDir(projectDir);
+  const stateDir = join(baseDir, kind, key);
+  return {
+    key,
+    stateDir,
+    statePath: join(stateDir, stateFileName),
+    expoHomeDir: join(stateDir, 'expo-home'),
+    tmpDir: join(stateDir, 'tmp'),
+  };
+}
+
+export async function ensureExpoIsolationEnv({ env, stateDir, expoHomeDir, tmpDir }) {
+  await mkdir(stateDir, { recursive: true });
+  await mkdir(expoHomeDir, { recursive: true });
+  await mkdir(tmpDir, { recursive: true });
+
+  // Expo CLI uses this to override ~/.expo.
+  env.__UNSAFE_EXPO_HOME_DIRECTORY = env.__UNSAFE_EXPO_HOME_DIRECTORY ?? expoHomeDir;
+
+  // Metro default cache root is `path.join(os.tmpdir(), 'metro-cache')`, so TMPDIR isolates it.
+  env.TMPDIR = env.TMPDIR ?? tmpDir;
+}
+
+export function wantsExpoClearCache({ env }) {
+  const raw = (env.HAPPY_STACKS_EXPO_CLEAR_CACHE ?? env.HAPPY_LOCAL_EXPO_CLEAR_CACHE ?? '').trim();
+  if (raw) {
+    return raw !== '0';
+  }
+  // Default: clear cache when non-interactive (LLMs/services), keep fast iteration in TTY shells.
+  return !(process.stdin.isTTY && process.stdout.isTTY);
+}
+
+export async function readPidState(statePath) {
+  try {
+    if (!existsSync(statePath)) return null;
+    const raw = await readFile(statePath, 'utf-8');
+    const state = JSON.parse(raw);
+    const pid = Number(state?.pid);
+    if (!Number.isFinite(pid) || pid <= 0) return null;
+    return state;
+  } catch {
+    return null;
+  }
+}
+
+export function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function isStateProcessRunning(statePath) {
+  const state = await readPidState(statePath);
+  if (!state) return { running: false, state: null };
+  const pid = Number(state.pid);
+  return { running: isPidAlive(pid), state };
+}
+
+export async function writePidState(statePath, state) {
+  await mkdir(dirname(statePath), { recursive: true }).catch(() => {});
+  await writeFile(statePath, JSON.stringify(state, null, 2) + '\n', 'utf-8');
+}
+
+export async function killPid(pid) {
+  const n = Number(pid);
+  if (!Number.isFinite(n) || n <= 1) return;
+  try {
+    process.kill(n, 'SIGTERM');
+  } catch {
+    return;
+  }
+  await delay(500);
+  try {
+    process.kill(n, 0);
+    process.kill(n, 'SIGKILL');
+  } catch {
+    // exited
+  }
+}
+