happy-stacks 0.0.0

package/scripts/daemon.mjs

@@ -0,0 +1,349 @@
+import { spawnProc, run, runCapture } from './utils/proc.mjs';
+import { existsSync, readdirSync, readFileSync, unlinkSync } from 'node:fs';
+import { chmod, copyFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+import { homedir } from 'node:os';
+
+/**
+ * Daemon lifecycle helpers for happy-stacks.
+ *
+ * Centralizes:
+ * - stopping old daemons (legacy + local home dirs)
+ * - cleaning stale lock/state
+ * - starting daemon and handling first-time auth
+ * - printing actionable diagnostics
+ */
+
+export function cleanupStaleDaemonState(homeDir) {
+  const statePath = join(homeDir, 'daemon.state.json');
+  const lockPath = join(homeDir, 'daemon.state.json.lock');
+
+  if (!existsSync(lockPath)) {
+    return;
+  }
+
+  // If lock PID exists and is running, keep lock/state.
+  try {
+    const raw = readFileSync(lockPath, 'utf-8').trim();
+    const pid = Number(raw);
+    if (Number.isFinite(pid) && pid > 0) {
+      try {
+        process.kill(pid, 0);
+        return;
+      } catch {
+        // stale pid
+      }
+    }
+  } catch {
+    // ignore
+  }
+
+  // If state PID exists and is running, keep lock/state.
+  if (existsSync(statePath)) {
+    try {
+      const state = JSON.parse(readFileSync(statePath, 'utf-8'));
+      const pid = typeof state?.pid === 'number' ? state.pid : null;
+      if (pid) {
+        try {
+          process.kill(pid, 0);
+          return;
+        } catch {
+          // stale pid
+        }
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  try { unlinkSync(lockPath); } catch { /* ignore */ }
+  try { unlinkSync(statePath); } catch { /* ignore */ }
+}
+
+function getLatestDaemonLogPath(homeDir) {
+  try {
+    const logsDir = join(homeDir, 'logs');
+    const files = readdirSync(logsDir).filter((f) => f.endsWith('-daemon.log')).sort();
+    if (!files.length) return null;
+    return join(logsDir, files[files.length - 1]);
+  } catch {
+    return null;
+  }
+}
+
+function readLastLines(path, lines = 60) {
+  try {
+    const content = readFileSync(path, 'utf-8');
+    const parts = content.split('\n');
+    return parts.slice(Math.max(0, parts.length - lines)).join('\n');
+  } catch {
+    return null;
+  }
+}
+
+function excerptIndicatesMissingAuth(excerpt) {
+  if (!excerpt) return false;
+  return (
+    excerpt.includes('[AUTH] No credentials found') ||
+    excerpt.includes('No credentials found, starting authentication flow')
+  );
+}
+
+function authLoginHint() {
+  const stackName = (process.env.HAPPY_STACKS_STACK ?? process.env.HAPPY_LOCAL_STACK ?? '').trim() || 'main';
+  return stackName === 'main' ? 'happys auth login' : `happys stack auth ${stackName} login`;
+}
+
+async function seedCredentialsIfMissing({ cliHomeDir }) {
+  const sources = [
+    // Legacy happy-local storage root (most common for existing users).
+    join(homedir(), '.happy', 'local', 'cli'),
+    // Older global location.
+    join(homedir(), '.happy'),
+  ];
+
+  const copyIfMissing = async ({ relPath, mode, label }) => {
+    const target = join(cliHomeDir, relPath);
+    if (existsSync(target)) {
+      return { copied: false, source: null, target };
+    }
+    const sourceDir = sources.find((d) => existsSync(join(d, relPath)));
+    if (!sourceDir) {
+      return { copied: false, source: null, target };
+    }
+    const source = join(sourceDir, relPath);
+    await mkdir(cliHomeDir, { recursive: true });
+    await copyFile(source, target);
+    await chmod(target, mode).catch(() => {});
+    console.log(`[local] migrated ${label}: ${source} -> ${target}`);
+    return { copied: true, source, target };
+  };
+
+  // access.key holds the auth token + encryption material (keep tight permissions)
+  const access = await copyIfMissing({ relPath: 'access.key', mode: 0o600, label: 'CLI credentials (access.key)' })
+    .catch((err) => {
+      console.warn(`[local] failed to migrate CLI credentials into ${cliHomeDir}:`, err);
+      return { copied: false, source: null, target: join(cliHomeDir, 'access.key') };
+    });
+
+  // settings.json holds machineId and other client state; migrate to keep your machine identity stable.
+  const settings = await copyIfMissing({ relPath: 'settings.json', mode: 0o600, label: 'CLI settings (settings.json)' })
+    .catch((err) => {
+      console.warn(`[local] failed to migrate CLI settings into ${cliHomeDir}:`, err);
+      return { copied: false, source: null, target: join(cliHomeDir, 'settings.json') };
+    });
+
+  return { ok: true, copied: access.copied || settings.copied, access, settings };
+}
+
+async function killDaemonFromLockFile({ cliHomeDir }) {
+  const lockPath = join(cliHomeDir, 'daemon.state.json.lock');
+  if (!existsSync(lockPath)) {
+    return false;
+  }
+
+  let pid = null;
+  try {
+    const raw = readFileSync(lockPath, 'utf-8').trim();
+    const n = Number(raw);
+    if (Number.isFinite(n) && n > 0) {
+      pid = n;
+    }
+  } catch {
+    // ignore
+  }
+  if (!pid) {
+    return false;
+  }
+
+  // If pid is alive, confirm it looks like a happy daemon and terminate it.
+  try {
+    process.kill(pid, 0);
+  } catch {
+    return false;
+  }
+
+  let cmd = '';
+  try {
+    cmd = await runCapture('ps', ['-p', String(pid), '-o', 'command=']);
+  } catch {
+    cmd = '';
+  }
+  const looksLikeDaemon = cmd.includes(' daemon ') || cmd.includes('daemon start') || cmd.includes('daemon start-sync');
+  if (!looksLikeDaemon) {
+    console.warn(`[local] refusing to kill pid ${pid} from lock file (doesn't look like daemon): ${cmd.trim()}`);
+    return false;
+  }
+
+  try {
+    process.kill(pid, 'SIGTERM');
+  } catch {
+    return false;
+  }
+  await delay(500);
+  try {
+    process.kill(pid, 0);
+    // Still alive: hard kill.
+    process.kill(pid, 'SIGKILL');
+  } catch {
+    // exited
+  }
+  console.log(`[local] killed stuck daemon pid ${pid} (from ${lockPath})`);
+  return true;
+}
+
+async function waitForCredentialsFile({ path, timeoutMs, isShuttingDown }) {
+  const deadline = Date.now() + timeoutMs;
+  while (!isShuttingDown() && Date.now() < deadline) {
+    try {
+      if (existsSync(path)) {
+        const raw = readFileSync(path, 'utf-8').trim();
+        if (raw.length > 0) {
+          return true;
+        }
+      }
+    } catch {
+      // ignore
+    }
+    await delay(500);
+  }
+  return false;
+}
+
+export function getDaemonEnv({ baseEnv, cliHomeDir, internalServerUrl, publicServerUrl }) {
+  return {
+    ...baseEnv,
+    HAPPY_SERVER_URL: internalServerUrl,
+    HAPPY_WEBAPP_URL: publicServerUrl,
+    HAPPY_HOME_DIR: cliHomeDir,
+  };
+}
+
+export async function stopLocalDaemon({ cliBin, internalServerUrl, cliHomeDir }) {
+  const env = {
+    ...process.env,
+    HAPPY_SERVER_URL: internalServerUrl,
+    HAPPY_HOME_DIR: cliHomeDir,
+  };
+
+  try {
+    await new Promise((resolve) => {
+      const proc = spawnProc('daemon', cliBin, ['daemon', 'stop'], env, { stdio: ['ignore', 'pipe', 'pipe'] });
+      proc.on('exit', () => resolve());
+    });
+  } catch {
+    // ignore
+  }
+
+  // If the daemon never wrote daemon.state.json (e.g. it got stuck in auth in a non-interactive context),
+  // stopLocalDaemon() can't find it. Fall back to the lock file PID.
+  await killDaemonFromLockFile({ cliHomeDir });
+}
+
+export async function startLocalDaemonWithAuth({
+  cliBin,
+  cliHomeDir,
+  internalServerUrl,
+  publicServerUrl,
+  isShuttingDown,
+}) {
+  const baseEnv = { ...process.env };
+  const daemonEnv = getDaemonEnv({ baseEnv, cliHomeDir, internalServerUrl, publicServerUrl });
+
+  // If this is a migrated/new stack home dir, seed credentials from the user's existing login (best-effort)
+  // to avoid requiring an interactive auth flow under launchd.
+  await seedCredentialsIfMissing({ cliHomeDir });
+
+  // Stop any existing daemon (best-effort) in both legacy and local home dirs.
+  const legacyEnv = { ...daemonEnv, HAPPY_HOME_DIR: join(homedir(), '.happy') };
+  try {
+    await new Promise((resolve) => {
+      const proc = spawnProc('daemon', cliBin, ['daemon', 'stop'], legacyEnv, { stdio: ['ignore', 'pipe', 'pipe'] });
+      proc.on('exit', () => resolve());
+    });
+  } catch {
+    // ignore
+  }
+  try {
+    await new Promise((resolve) => {
+      const proc = spawnProc('daemon', cliBin, ['daemon', 'stop'], daemonEnv, { stdio: ['ignore', 'pipe', 'pipe'] });
+      proc.on('exit', () => resolve());
+    });
+  } catch {
+    // ignore
+  }
+
+  // If state is missing and stop couldn't find it, force-stop the lock PID (otherwise repeated restarts accumulate daemons).
+  await killDaemonFromLockFile({ cliHomeDir: join(homedir(), '.happy') });
+  await killDaemonFromLockFile({ cliHomeDir });
+
+  // Clean up stale lock/state files that can block daemon start.
+  cleanupStaleDaemonState(join(homedir(), '.happy'));
+  cleanupStaleDaemonState(cliHomeDir);
+
+  const credentialsPath = join(cliHomeDir, 'access.key');
+
+  const startOnce = async () => {
+    const exitCode = await new Promise((resolve) => {
+      const proc = spawnProc('daemon', cliBin, ['daemon', 'start'], daemonEnv, { stdio: ['ignore', 'pipe', 'pipe'] });
+      proc.on('exit', (code) => resolve(code ?? 0));
+    });
+
+    if (exitCode === 0) {
+      return { ok: true, exitCode, excerpt: null, logPath: null };
+    }
+
+    const logPath = getLatestDaemonLogPath(cliHomeDir) || getLatestDaemonLogPath(join(homedir(), '.happy'));
+    const excerpt = logPath ? readLastLines(logPath, 120) : null;
+    return { ok: false, exitCode, excerpt, logPath };
+  };
+
+  const first = await startOnce();
+  if (!first.ok) {
+    if (first.excerpt) {
+      console.error(`[local] daemon failed to start; last daemon log (${first.logPath}):\n${first.excerpt}`);
+    } else {
+      console.error('[local] daemon failed to start; no daemon log found');
+    }
+
+    if (excerptIndicatesMissingAuth(first.excerpt)) {
+      console.error(
+        `[local] daemon is not authenticated yet (expected on first run).\n` +
+        `[local] Keeping the server running so you can login.\n` +
+        `[local] In another terminal, run:\n` +
+        `${authLoginHint()}\n` +
+        `[local] Waiting for credentials at ${credentialsPath}...`
+      );
+
+      const ok = await waitForCredentialsFile({ path: credentialsPath, timeoutMs: 10 * 60_000, isShuttingDown });
+      if (!ok) {
+        throw new Error('Timed out waiting for daemon credentials (auth login not completed)');
+      }
+
+      console.log('[local] credentials detected, retrying daemon start...');
+      const second = await startOnce();
+      if (!second.ok) {
+        if (second.excerpt) {
+          console.error(`[local] daemon still failed to start; last daemon log (${second.logPath}):\n${second.excerpt}`);
+        }
+        throw new Error('Failed to start daemon (after credentials were created)');
+      }
+    } else {
+      console.error(`[local] To authenticate against this local server, run:\n${authLoginHint()}`);
+      throw new Error('Failed to start daemon');
+    }
+  }
+
+  // Confirm daemon status (best-effort)
+  try {
+    await run('node', [cliBin, 'daemon', 'status'], { env: daemonEnv });
+  } catch {
+    // ignore
+  }
+}
+
+export async function daemonStatusSummary({ cliBin, cliHomeDir, internalServerUrl, publicServerUrl }) {
+  const env = getDaemonEnv({ baseEnv: process.env, cliHomeDir, internalServerUrl, publicServerUrl });
+  return await runCapture('node', [cliBin, 'daemon', 'status'], { env });
+}

package/scripts/dev.mjs

@@ -0,0 +1,181 @@
+import './utils/env.mjs';
+import { parseArgs } from './utils/args.mjs';
+import { killProcessTree } from './utils/proc.mjs';
+import { getComponentDir, getDefaultAutostartPaths, getRootDir } from './utils/paths.mjs';
+import { killPortListeners } from './utils/ports.mjs';
+import { getServerComponentName, waitForServerReady } from './utils/server.mjs';
+import { ensureDepsInstalled, pmSpawnScript, requireDir } from './utils/pm.mjs';
+import { join } from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+import { homedir } from 'node:os';
+import { startLocalDaemonWithAuth, stopLocalDaemon } from './daemon.mjs';
+import { resolvePublicServerUrl } from './tailscale.mjs';
+import { printResult, wantsHelp, wantsJson } from './utils/cli.mjs';
+import { assertServerComponentDirMatches } from './utils/validate.mjs';
+
+/**
+ * Dev mode stack:
+ * - happy-server-light
+ * - happy-cli daemon
+ * - Expo web dev server (watch/reload)
+ */
+
+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: { flags: ['--server=happy-server|happy-server-light', '--no-ui', '--no-daemon'], json: true },
+      text: [
+        '[dev] usage:',
+        '  happys dev [--server=happy-server|happy-server-light] [--json]',
+        '  note: --json prints the resolved config (dry-run) and exits.',
+      ].join('\n'),
+    });
+    return;
+  }
+  const rootDir = getRootDir(import.meta.url);
+
+  const serverPort = process.env.HAPPY_LOCAL_SERVER_PORT
+    ? parseInt(process.env.HAPPY_LOCAL_SERVER_PORT, 10)
+    : 3005;
+
+  const internalServerUrl = `http://127.0.0.1:${serverPort}`;
+  const defaultPublicUrl = `http://localhost:${serverPort}`;
+  const envPublicUrl = process.env.HAPPY_LOCAL_SERVER_URL?.trim() ? process.env.HAPPY_LOCAL_SERVER_URL.trim() : '';
+  const resolved = await resolvePublicServerUrl({
+    internalServerUrl,
+    defaultPublicUrl,
+    envPublicUrl,
+    allowEnable: true,
+  });
+  const publicServerUrl = resolved.publicServerUrl;
+
+  const serverComponentName = getServerComponentName({ kv });
+  if (serverComponentName === 'both') {
+    throw new Error(`[local] --server=both is not supported for dev (pick one: happy-server-light or happy-server)`);
+  }
+
+  const startUi = !flags.has('--no-ui') && (process.env.HAPPY_LOCAL_UI ?? '1') !== '0';
+  const startDaemon = !flags.has('--no-daemon') && (process.env.HAPPY_LOCAL_DAEMON ?? '1') !== '0';
+
+  const serverDir = getComponentDir(rootDir, serverComponentName);
+  const uiDir = getComponentDir(rootDir, 'happy');
+  const cliDir = getComponentDir(rootDir, 'happy-cli');
+
+  assertServerComponentDirMatches({ rootDir, serverComponentName, serverDir });
+
+  await requireDir(serverComponentName, serverDir);
+  await requireDir('happy', uiDir);
+  await requireDir('happy-cli', cliDir);
+
+  const cliBin = join(cliDir, 'bin', 'happy.mjs');
+  const cliHomeDir = process.env.HAPPY_LOCAL_CLI_HOME_DIR?.trim()
+    ? process.env.HAPPY_LOCAL_CLI_HOME_DIR.trim().replace(/^~(?=\/)/, homedir())
+    : join(getDefaultAutostartPaths().baseDir, 'cli');
+
+  if (json) {
+    printResult({
+      json,
+      data: {
+        mode: 'dev',
+        serverComponentName,
+        serverDir,
+        uiDir,
+        cliDir,
+        serverPort,
+        internalServerUrl,
+        publicServerUrl,
+        startUi,
+        startDaemon,
+        cliHomeDir,
+      },
+    });
+    return;
+  }
+
+  const children = [];
+  let shuttingDown = false;
+  const baseEnv = { ...process.env };
+
+  // Start server
+  await killPortListeners(serverPort, { label: 'server' });
+  const serverEnv = {
+    ...baseEnv,
+    PORT: String(serverPort),
+    PUBLIC_URL: publicServerUrl,
+    // Avoid noisy failures if a previous run left the metrics port busy.
+    METRICS_ENABLED: baseEnv.METRICS_ENABLED ?? 'false',
+  };
+  await ensureDepsInstalled(serverDir, serverComponentName);
+  const server = await pmSpawnScript({ label: 'server', dir: serverDir, script: 'dev', env: serverEnv });
+  children.push(server);
+
+  await waitForServerReady(internalServerUrl);
+  console.log(`[local] server ready at ${internalServerUrl}`);
+  console.log(
+    `[local] tip: to run 'happy' from your terminal *against this local server* (and have sessions show up in the UI), use:\n` +
+    `export HAPPY_SERVER_URL=\"${internalServerUrl}\"\n` +
+      `export HAPPY_HOME_DIR=\"${cliHomeDir}\"\n` +
+    `export HAPPY_WEBAPP_URL=\"${publicServerUrl}\"\n`
+  );
+
+  // Start daemon (detached daemon process managed by happy-cli)
+  if (startDaemon) {
+    await startLocalDaemonWithAuth({
+      cliBin,
+      cliHomeDir,
+      internalServerUrl,
+      publicServerUrl,
+      isShuttingDown: () => shuttingDown,
+    });
+  }
+
+  // Start UI (Expo web dev server)
+  if (startUi) {
+    await ensureDepsInstalled(uiDir, 'happy');
+    const uiEnv = { ...baseEnv };
+    delete uiEnv.CI;
+    uiEnv.EXPO_PUBLIC_HAPPY_SERVER_URL = publicServerUrl;
+    uiEnv.EXPO_PUBLIC_DEBUG = uiEnv.EXPO_PUBLIC_DEBUG ?? '1';
+    const ui = await pmSpawnScript({ label: 'ui', dir: uiDir, script: 'web', env: uiEnv });
+    children.push(ui);
+  }
+
+  const shutdown = async () => {
+    if (shuttingDown) {
+      return;
+    }
+    shuttingDown = true;
+    console.log('\n[local] shutting down...');
+
+    if (startDaemon) {
+      await stopLocalDaemon({ cliBin, internalServerUrl, cliHomeDir });
+    }
+
+    for (const child of children) {
+      if (child.exitCode == null) {
+        killProcessTree(child, 'SIGINT');
+      }
+    }
+
+    await delay(1500);
+    for (const child of children) {
+      if (child.exitCode == null) {
+        killProcessTree(child, 'SIGKILL');
+      }
+    }
+  };
+
+  process.on('SIGINT', () => shutdown().then(() => process.exit(0)));
+  process.on('SIGTERM', () => shutdown().then(() => process.exit(0)));
+
+  await new Promise(() => {});
+}
+
+main().catch((err) => {
+  console.error('[local] failed:', err);
+  process.exit(1);
+});