happy-stacks 0.1.0 → 0.2.0

package/scripts/build.mjs

@@ -1,11 +1,11 @@
 import './utils/env.mjs';
-import { parseArgs } from './utils/args.mjs';
+import { parseArgs } from './utils/cli/args.mjs';
 import { getComponentDir, getDefaultAutostartPaths, getRootDir } from './utils/paths.mjs';
 import { ensureDepsInstalled, pmExecBin, requireDir } from './utils/pm.mjs';
 import { dirname, join } from 'node:path';
 import { readFile, rm, mkdir, writeFile } from 'node:fs/promises';
 import { tailscaleServeHttpsUrl } from './tailscale.mjs';
-import { printResult, wantsHelp, wantsJson } from './utils/cli.mjs';
+import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
 
 /**
  * Build a lightweight static web UI bundle (no Expo dev server).
@@ -22,17 +22,24 @@ async function main() {
   if (wantsHelp(argv, { flags })) {
     printResult({
       json,
-      data: { flags: ['--tauri', '--no-tauri'], json: true },
+      data: { flags: ['--tauri', '--no-tauri', '--no-ui'], json: true },
       text: [
         '[build] usage:',
         '  happys build [--tauri] [--json]',
         '  (legacy in a cloned repo): pnpm build [-- --tauri] [--json]',
-        '  node scripts/build.mjs [--tauri|--no-tauri] [--json]',
+        '  node scripts/build.mjs [--tauri|--no-tauri] [--no-ui] [--json]',
       ].join('\n'),
     });
     return;
   }
   const rootDir = getRootDir(import.meta.url);
+
+  // Optional: skip building the web UI bundle.
+  //
+  // This is useful for evidence capture flows that validate non-UI components (e.g. `happy-cli`)
+  // but still require a "build" step.
+  const skipUi = flags.has('--no-ui');
+
   const uiDir = getComponentDir(rootDir, 'happy');
   await requireDir('happy', uiDir);
 
@@ -49,6 +56,19 @@ async function main() {
 
   // UI is served at root; /ui redirects to /.
 
+  if (skipUi) {
+    // Ensure the output dir exists so server-light doesn't crash if used, but do not run Expo export.
+    await rm(outDir, { recursive: true, force: true });
+    await mkdir(outDir, { recursive: true });
+    await writeFile(join(outDir, '.happy-stacks-build-skipped'), 'no-ui\n', 'utf-8');
+    if (json) {
+      printResult({ json, data: { ok: true, outDir, skippedUi: true, tauriBuilt: false } });
+    } else {
+      console.log(`[local] skipping UI export (--no-ui); created empty UI dir at ${outDir}`);
+    }
+    return;
+  }
+
   await ensureDepsInstalled(uiDir, 'happy');
 
   // Clean output to avoid stale assets.

package/scripts/cli-link.mjs

@@ -1,8 +1,8 @@
 import './utils/env.mjs';
-import { parseArgs } from './utils/args.mjs';
+import { parseArgs } from './utils/cli/args.mjs';
 import { getComponentDir, getRootDir } from './utils/paths.mjs';
 import { ensureCliBuilt, ensureHappyCliLocalNpmLinked } from './utils/pm.mjs';
-import { printResult, wantsHelp, wantsJson } from './utils/cli.mjs';
+import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
 
 /**
  * Link the local Happy CLI wrapper into your PATH.
@@ -11,7 +11,7 @@ import { printResult, wantsHelp, wantsJson } from './utils/cli.mjs';
  *
  * What it does:
  * - optionally builds `components/happy-cli` (controlled by env/flags)
- * - installs `happy`/`happys` shims under `~/.happy-stacks/bin` (recommended over `npm link`)
+ * - installs `happy`/`happys` shims under `<homeDir>/bin` (default: `~/.happy-stacks/bin`) (recommended over `npm link`)
  *
  * Env:
  * - HAPPY_LOCAL_CLI_BUILD=0 to skip building happy-cli

package/scripts/completion.mjs

@@ -5,11 +5,13 @@ import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 
-import { parseArgs } from './utils/args.mjs';
-import { printResult, wantsHelp, wantsJson } from './utils/cli.mjs';
+import { parseArgs } from './utils/cli/args.mjs';
+import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
 import { runCapture } from './utils/proc.mjs';
-import { getHappysRegistry } from './utils/cli_registry.mjs';
+import { getHappysRegistry } from './utils/cli/cli_registry.mjs';
+import { expandHome } from './utils/canonical_home.mjs';
 import { getHappyStacksHomeDir, getRootDir } from './utils/paths.mjs';
+import { isSandboxed, sandboxAllowsGlobalSideEffects } from './utils/sandbox.mjs';
 
 function detectShell() {
   const raw = (process.env.SHELL ?? '').toLowerCase();
@@ -18,10 +20,6 @@ function detectShell() {
   return 'zsh';
 }
 
-function expandHome(p) {
-  return p.replace(/^~(?=\/)/, homedir());
-}
-
 function parseShellArg({ argv, kv }) {
   const fromKv = (kv.get('--shell') ?? '').trim();
   const fromEnv = (process.env.HAPPY_STACKS_SHELL ?? '').trim();
@@ -217,6 +215,9 @@ function completionPaths({ homeDir, shell }) {
 }
 
 async function ensureShellInstall({ homeDir, shell }) {
+  if (isSandboxed() && !sandboxAllowsGlobalSideEffects()) {
+    return { updated: false, path: null, skipped: 'sandbox' };
+  }
   const shellPath = (process.env.SHELL ?? '').toLowerCase();
   const isDarwin = process.platform === 'darwin';
 
@@ -338,7 +339,10 @@ async function main() {
     await writeFile(file, contents, 'utf-8');
 
     // fish loads completions automatically; zsh/bash need a tiny shell config hook.
-    const hook = shell === 'fish' ? { updated: false, path: null } : await ensureShellInstall({ homeDir, shell });
+    const hook =
+      shell === 'fish'
+        ? { updated: false, path: null }
+        : await ensureShellInstall({ homeDir, shell });
 
     printResult({
       json,
@@ -346,6 +350,9 @@ async function main() {
       text: [
         `[completion] installed: ${file}`,
         hook?.path ? (hook.updated ? `[completion] enabled via: ${hook.path}` : `[completion] already enabled in: ${hook.path}`) : null,
+        hook?.skipped === 'sandbox'
+          ? '[completion] note: skipped editing shell rc files (sandbox mode). To enable this, re-run with HAPPY_STACKS_SANDBOX_ALLOW_GLOBAL=1'
+          : null,
         '[completion] note: restart your terminal (or source your shell config) to pick it up.',
       ]
         .filter(Boolean)

package/scripts/daemon.mjs

@@ -1,4 +1,7 @@
 import { spawnProc, run, runCapture } from './utils/proc.mjs';
+import { resolveAuthSeedFromEnv } from './utils/stack_startup.mjs';
+import { getStacksStorageRoot } from './utils/paths.mjs';
+import { isSandboxed, sandboxAllowsGlobalSideEffects } from './utils/sandbox.mjs';
 import { existsSync, readdirSync, readFileSync, unlinkSync } from 'node:fs';
 import { chmod, copyFile, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
@@ -15,7 +18,7 @@ import { homedir } from 'node:os';
  * - printing actionable diagnostics
  */
 
-export function cleanupStaleDaemonState(homeDir) {
+export async function cleanupStaleDaemonState(homeDir) {
   const statePath = join(homeDir, 'daemon.state.json');
   const lockPath = join(homeDir, 'daemon.state.json.lock');
 
@@ -23,14 +26,27 @@ export function cleanupStaleDaemonState(homeDir) {
     return;
   }
 
-  // If lock PID exists and is running, keep lock/state.
+  const lsofHasPath = async (pid, pathNeedle) => {
+    try {
+      const out = await runCapture('sh', ['-lc', `command -v lsof >/dev/null 2>&1 && lsof -nP -p ${pid} 2>/dev/null || true`]);
+      return out.includes(pathNeedle);
+    } catch {
+      return false;
+    }
+  };
+
+  // If lock PID exists and is running, keep lock/state ONLY if it still owns the lock file path.
   try {
     const raw = readFileSync(lockPath, 'utf-8').trim();
     const pid = Number(raw);
     if (Number.isFinite(pid) && pid > 0) {
       try {
         process.kill(pid, 0);
-        return;
+        // If PID was recycled, refuse to trust it unless we can prove it's associated with this home dir.
+        // This prevents cross-stack daemon kills due to stale lock files.
+        if (await lsofHasPath(pid, lockPath)) {
+          return;
+        }
       } catch {
         // stale pid
       }
@@ -47,7 +63,10 @@ export function cleanupStaleDaemonState(homeDir) {
       if (pid) {
         try {
           process.kill(pid, 0);
-          return;
+          // Only keep if we can prove it still uses this home dir (via state path).
+          if (await lsofHasPath(pid, statePath)) {
+            return;
+          }
         } catch {
           // stale pid
         }
@@ -61,6 +80,88 @@ export function cleanupStaleDaemonState(homeDir) {
   try { unlinkSync(statePath); } catch { /* ignore */ }
 }
 
+export function checkDaemonState(cliHomeDir) {
+  const statePath = join(cliHomeDir, 'daemon.state.json');
+  const lockPath = join(cliHomeDir, 'daemon.state.json.lock');
+
+  const alive = (pid) => {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+  if (existsSync(statePath)) {
+    try {
+      const state = JSON.parse(readFileSync(statePath, 'utf-8'));
+      const pid = Number(state?.pid);
+      if (Number.isFinite(pid) && pid > 0) {
+        return alive(pid) ? { status: 'running', pid } : { status: 'stale_state', pid };
+      }
+      return { status: 'bad_state', pid: null };
+    } catch {
+      return { status: 'bad_state', pid: null };
+    }
+  }
+
+  if (existsSync(lockPath)) {
+    try {
+      const pid = Number(readFileSync(lockPath, 'utf-8').trim());
+      if (Number.isFinite(pid) && pid > 0) {
+        return alive(pid) ? { status: 'starting', pid } : { status: 'stale_lock', pid };
+      }
+      return { status: 'bad_lock', pid: null };
+    } catch {
+      return { status: 'bad_lock', pid: null };
+    }
+  }
+
+  return { status: 'stopped', pid: null };
+}
+
+export function isDaemonRunning(cliHomeDir) {
+  const s = checkDaemonState(cliHomeDir);
+  return s.status === 'running' || s.status === 'starting';
+}
+
+async function readDaemonPsEnv(pid) {
+  const n = Number(pid);
+  if (!Number.isFinite(n) || n <= 1) return null;
+  if (process.platform === 'win32') return null;
+  try {
+    const out = await runCapture('ps', ['eww', '-p', String(n)]);
+    const lines = out.split('\n').map((l) => l.trim()).filter(Boolean);
+    // Usually: header + one line.
+    return lines.length >= 2 ? lines[1] : lines[0] ?? null;
+  } catch {
+    return null;
+  }
+}
+
+async function daemonEnvMatches({ pid, cliHomeDir, internalServerUrl, publicServerUrl }) {
+  const line = await readDaemonPsEnv(pid);
+  if (!line) return null; // unknown
+  const home = String(cliHomeDir ?? '').trim();
+  const server = String(internalServerUrl ?? '').trim();
+  const web = String(publicServerUrl ?? '').trim();
+
+  // Must be for the same stack home dir.
+  if (home && !line.includes(`HAPPY_HOME_DIR=${home}`)) {
+    return false;
+  }
+  // If we have a desired server URL, require it (prevents ephemeral port mismatches).
+  if (server && !line.includes(`HAPPY_SERVER_URL=${server}`)) {
+    return false;
+  }
+  // Public URL mismatch is less fatal, but prefer it stable too when provided.
+  if (web && !line.includes(`HAPPY_WEBAPP_URL=${web}`)) {
+    return false;
+  }
+  return true;
+}
+
 function getLatestDaemonLogPath(homeDir) {
   try {
     const logsDir = join(homeDir, 'logs');
@@ -95,12 +196,28 @@ function authLoginHint() {
   return stackName === 'main' ? 'happys auth login' : `happys stack auth ${stackName} login`;
 }
 
+function authCopyFromSeedHint() {
+  const stackName = (process.env.HAPPY_STACKS_STACK ?? process.env.HAPPY_LOCAL_STACK ?? '').trim() || 'main';
+  if (stackName === 'main') return null;
+  const seed = resolveAuthSeedFromEnv(process.env);
+  return `happys stack auth ${stackName} copy-from ${seed}`;
+}
+
 async function seedCredentialsIfMissing({ cliHomeDir }) {
+  const stacksRoot = getStacksStorageRoot();
+  const allowGlobal = sandboxAllowsGlobalSideEffects();
+
   const sources = [
-    // Legacy happy-local storage root (most common for existing users).
-    join(homedir(), '.happy', 'local', 'cli'),
-    // Older global location.
-    join(homedir(), '.happy'),
+    // New layout: main stack credentials (preferred).
+    join(stacksRoot, 'main', 'cli'),
+    ...((!isSandboxed() || allowGlobal)
+      ? [
+          // 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 }) => {
@@ -176,6 +293,22 @@ async function killDaemonFromLockFile({ cliHomeDir }) {
     return false;
   }
 
+  // Hard safety: only kill if we can prove the PID is associated with this stack home dir.
+  // We do this by checking that `lsof -p <pid>` includes the lock path (or state file path).
+  let ownsLock = false;
+  try {
+    const out = await runCapture('sh', ['-lc', `command -v lsof >/dev/null 2>&1 && lsof -nP -p ${pid} 2>/dev/null || true`]);
+    ownsLock = out.includes(lockPath) || out.includes(join(cliHomeDir, 'daemon.state.json')) || out.includes(join(cliHomeDir, 'logs'));
+  } catch {
+    ownsLock = false;
+  }
+  if (!ownsLock) {
+    console.warn(
+      `[local] refusing to kill pid ${pid} from lock file (could be unrelated; lsof did not show ownership of ${cliHomeDir})`
+    );
+    return false;
+  }
+
   try {
     process.kill(pid, 'SIGTERM');
   } catch {
@@ -247,24 +380,43 @@ export async function startLocalDaemonWithAuth({
   internalServerUrl,
   publicServerUrl,
   isShuttingDown,
+  forceRestart = false,
 }) {
+  const stackName = (process.env.HAPPY_STACKS_STACK ?? process.env.HAPPY_LOCAL_STACK ?? '').trim() || 'main';
   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 });
+  const migrateCreds = (baseEnv.HAPPY_STACKS_MIGRATE_CREDENTIALS ?? baseEnv.HAPPY_LOCAL_MIGRATE_CREDENTIALS ?? '1').trim() !== '0';
+  if (migrateCreds) {
+    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
+  const existing = checkDaemonState(cliHomeDir);
+  if (!forceRestart && (existing.status === 'running' || existing.status === 'starting')) {
+    const pid = existing.pid;
+    const matches = await daemonEnvMatches({ pid, cliHomeDir, internalServerUrl, publicServerUrl });
+    if (matches === true) {
+      // eslint-disable-next-line no-console
+      console.log(`[local] daemon already running for stack home (pid=${pid})`);
+      return;
+    }
+    if (matches === false) {
+      // eslint-disable-next-line no-console
+      console.warn(
+        `[local] daemon is running but pointed at a different server URL; restarting (pid=${pid}).\n` +
+          `[local] expected: ${internalServerUrl}\n`
+      );
+    } else {
+      // unknown: best-effort keep running to avoid killing an unrelated process
+      // eslint-disable-next-line no-console
+      console.warn(`[local] daemon status is running but could not verify env; not restarting (pid=${pid})`);
+      return;
+    }
   }
+
+  // Stop any existing daemon for THIS stack home dir.
   try {
     await new Promise((resolve) => {
       const proc = spawnProc('daemon', cliBin, ['daemon', 'stop'], daemonEnv, { stdio: ['ignore', 'pipe', 'pipe'] });
@@ -274,13 +426,27 @@ export async function startLocalDaemonWithAuth({
     // ignore
   }
 
+  // Best-effort: for the main stack, also stop the legacy global daemon home (~/.happy) to prevent legacy overlap.
+  if (stackName === 'main' && (!isSandboxed() || sandboxAllowsGlobalSideEffects())) {
+    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
+    }
+    // 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 cleanupStaleDaemonState(join(homedir(), '.happy'));
+  }
+
   // 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);
+  await cleanupStaleDaemonState(cliHomeDir);
 
   const credentialsPath = join(cliHomeDir, 'access.key');
 
@@ -294,7 +460,9 @@ export async function startLocalDaemonWithAuth({
       return { ok: true, exitCode, excerpt: null, logPath: null };
     }
 
-    const logPath = getLatestDaemonLogPath(cliHomeDir) || getLatestDaemonLogPath(join(homedir(), '.happy'));
+    const logPath =
+      getLatestDaemonLogPath(cliHomeDir) ||
+      ((!isSandboxed() || sandboxAllowsGlobalSideEffects()) ? getLatestDaemonLogPath(join(homedir(), '.happy')) : null);
     const excerpt = logPath ? readLastLines(logPath, 120) : null;
     return { ok: false, exitCode, excerpt, logPath };
   };
@@ -308,11 +476,13 @@ export async function startLocalDaemonWithAuth({
     }
 
     if (excerptIndicatesMissingAuth(first.excerpt)) {
+      const copyHint = authCopyFromSeedHint();
       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` +
+        (copyHint ? `[local] Or (recommended if main is already logged in):\n${copyHint}\n` : '') +
         `[local] Waiting for credentials at ${credentialsPath}...`
       );
 
@@ -330,7 +500,14 @@ export async function startLocalDaemonWithAuth({
         throw new Error('Failed to start daemon (after credentials were created)');
       }
     } else {
-      console.error(`[local] To authenticate against this local server, run:\n${authLoginHint()}`);
+      const copyHint = authCopyFromSeedHint();
+      console.error(
+        `[local] daemon failed to start (server returned an error).\n` +
+          `[local] Try:\n` +
+          `- happys doctor\n` +
+          (copyHint ? `- ${copyHint}\n` : '') +
+          `- ${authLoginHint()}`
+      );
       throw new Error('Failed to start daemon');
     }
   }