happy-stacks 0.1.2 → 0.3.0

package/scripts/utils/stack/dirs.mjs

@@ -0,0 +1,27 @@
+import { join } from 'node:path';
+
+import { expandHome } from '../paths/canonical_home.mjs';
+import { getDefaultAutostartPaths } from '../paths/paths.mjs';
+
+export function getCliHomeDirFromEnvOrDefault({ stackBaseDir, env }) {
+  const fromEnv = (env?.HAPPY_STACKS_CLI_HOME_DIR ?? env?.HAPPY_LOCAL_CLI_HOME_DIR ?? '').trim();
+  return fromEnv || join(stackBaseDir, 'cli');
+}
+
+export function getServerLightDataDirFromEnvOrDefault({ stackBaseDir, env }) {
+  const fromEnv = (env?.HAPPY_SERVER_LIGHT_DATA_DIR ?? '').trim();
+  return fromEnv || join(stackBaseDir, 'server-light');
+}
+
+export function resolveCliHomeDir(env = process.env) {
+  const fromExplicit = (env.HAPPY_HOME_DIR ?? '').trim();
+  if (fromExplicit) {
+    return expandHome(fromExplicit);
+  }
+  const fromStacks = (env.HAPPY_STACKS_CLI_HOME_DIR ?? env.HAPPY_LOCAL_CLI_HOME_DIR ?? '').trim();
+  if (fromStacks) {
+    return expandHome(fromStacks);
+  }
+  return join(getDefaultAutostartPaths().baseDir, 'cli');
+}
+

package/scripts/utils/stack/editor_workspace.mjs

@@ -0,0 +1,152 @@
+import { join, resolve } from 'node:path';
+import { writeFile } from 'node:fs/promises';
+
+import { expandHome } from '../paths/canonical_home.mjs';
+import { getComponentDir, getWorkspaceDir, resolveStackEnvPath } from '../paths/paths.mjs';
+import { ensureDir } from '../fs/ops.mjs';
+import { getEnvValueAny } from '../env/values.mjs';
+import { readEnvObjectFromFile } from '../env/read.mjs';
+import { resolveCommandPath } from '../proc/commands.mjs';
+import { run, runCapture } from '../proc/proc.mjs';
+import { getCliHomeDirFromEnvOrDefault } from './dirs.mjs';
+
+function resolveWorkspaceDirFromStackEnv({ rootDir, stackEnv }) {
+  const raw = getEnvValueAny(stackEnv, ['HAPPY_STACKS_WORKSPACE_DIR', 'HAPPY_LOCAL_WORKSPACE_DIR']);
+  if (!raw) {
+    return getWorkspaceDir(rootDir);
+  }
+  const expanded = expandHome(raw);
+  return expanded.startsWith('/') ? expanded : resolve(rootDir, expanded);
+}
+
+function resolveComponentDirFromStackEnv({ rootDir, stackEnv, keys, component }) {
+  const raw = getEnvValueAny(stackEnv, keys);
+  if (!raw) return getComponentDir(rootDir, component);
+  const expanded = expandHome(raw);
+  if (expanded.startsWith('/')) return expanded;
+  const workspaceDir = resolveWorkspaceDirFromStackEnv({ rootDir, stackEnv });
+  return resolve(workspaceDir, expanded);
+}
+
+export async function isCursorInstalled({ cwd, env } = {}) {
+  if (await resolveCommandPath('cursor', { cwd, env })) return true;
+  if (process.platform !== 'darwin') return false;
+  try {
+    await runCapture('open', ['-Ra', 'Cursor'], { cwd, env });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function openWorkspaceInEditor({ rootDir, editor, workspacePath }) {
+  if (editor === 'code') {
+    const codePath = await resolveCommandPath('code', { cwd: rootDir, env: process.env });
+    if (!codePath) {
+      throw new Error(
+        "[stack] VS Code CLI 'code' not found on PATH. In VS Code: Cmd+Shift+P → 'Shell Command: Install code command in PATH'."
+      );
+    }
+    await run(codePath, ['-n', workspacePath], { cwd: rootDir, env: process.env, stdio: 'inherit' });
+    return;
+  }
+
+  const cursorPath = await resolveCommandPath('cursor', { cwd: rootDir, env: process.env });
+  if (cursorPath) {
+    try {
+      await run(cursorPath, ['-n', workspacePath], { cwd: rootDir, env: process.env, stdio: 'inherit' });
+    } catch {
+      await run(cursorPath, [workspacePath], { cwd: rootDir, env: process.env, stdio: 'inherit' });
+    }
+    return;
+  }
+
+  if (process.platform === 'darwin') {
+    // Cursor installed but CLI missing is common on macOS.
+    await run('open', ['-na', 'Cursor', workspacePath], { cwd: rootDir, env: process.env, stdio: 'inherit' });
+    return;
+  }
+
+  throw new Error("[stack] Cursor CLI 'cursor' not found on PATH (and non-macOS fallback is unavailable).");
+}
+
+export async function writeStackCodeWorkspace({
+  rootDir,
+  stackName,
+  includeStackDir,
+  includeAllComponents,
+  includeCliHome,
+}) {
+  const { baseDir, envPath } = resolveStackEnvPath(stackName);
+  const stackEnv = await readEnvObjectFromFile(envPath);
+
+  const serverComponent =
+    getEnvValueAny(stackEnv, ['HAPPY_STACKS_SERVER_COMPONENT', 'HAPPY_LOCAL_SERVER_COMPONENT']) || 'happy-server-light';
+
+  const selectedComponents = includeAllComponents
+    ? ['happy', 'happy-cli', 'happy-server-light', 'happy-server']
+    : ['happy', 'happy-cli', serverComponent];
+
+  const componentSpecs = [
+    { component: 'happy', keys: ['HAPPY_STACKS_COMPONENT_DIR_HAPPY', 'HAPPY_LOCAL_COMPONENT_DIR_HAPPY'] },
+    { component: 'happy-cli', keys: ['HAPPY_STACKS_COMPONENT_DIR_HAPPY_CLI', 'HAPPY_LOCAL_COMPONENT_DIR_HAPPY_CLI'] },
+    {
+      component: 'happy-server-light',
+      keys: ['HAPPY_STACKS_COMPONENT_DIR_HAPPY_SERVER_LIGHT', 'HAPPY_LOCAL_COMPONENT_DIR_HAPPY_SERVER_LIGHT'],
+    },
+    { component: 'happy-server', keys: ['HAPPY_STACKS_COMPONENT_DIR_HAPPY_SERVER', 'HAPPY_LOCAL_COMPONENT_DIR_HAPPY_SERVER'] },
+  ];
+  const byName = new Map(componentSpecs.map((c) => [c.component, c.keys]));
+
+  const folders = [];
+  if (includeStackDir) {
+    folders.push({ name: `stack:${stackName}`, path: baseDir });
+  }
+  if (includeCliHome) {
+    const cliHomeDir = getCliHomeDirFromEnvOrDefault({ stackBaseDir: baseDir, env: stackEnv });
+    folders.push({ name: `cli:${stackName}`, path: expandHome(cliHomeDir) });
+  }
+  for (const component of selectedComponents) {
+    const keys = byName.get(component) ?? [];
+    const dir = resolveComponentDirFromStackEnv({ rootDir, stackEnv, keys, component });
+    folders.push({ name: component, path: dir });
+  }
+
+  // Deduplicate by path (can happen if multiple components are pointed at the same dir).
+  const uniqFolders = folders.filter((f, i, arr) => arr.findIndex((x) => x.path === f.path) === i);
+
+  await ensureDir(baseDir);
+  const workspacePath = join(baseDir, `stack.${stackName}.code-workspace`);
+  const payload = {
+    folders: uniqFolders,
+    settings: {
+      'search.exclude': {
+        '**/node_modules/**': true,
+        '**/.git/**': true,
+        '**/logs/**': true,
+        '**/cli/logs/**': true,
+      },
+      'files.watcherExclude': {
+        '**/node_modules/**': true,
+        '**/.git/**': true,
+        '**/logs/**': true,
+        '**/cli/logs/**': true,
+      },
+    },
+  };
+  await writeFile(workspacePath, JSON.stringify(payload, null, 2) + '\n', 'utf-8');
+
+  return {
+    workspacePath,
+    baseDir,
+    envPath,
+    serverComponent,
+    folders: uniqFolders,
+    flags: {
+      includeStackDir: Boolean(includeStackDir),
+      includeCliHome: Boolean(includeCliHome),
+      includeAllComponents: Boolean(includeAllComponents),
+    },
+  };
+}
+

package/scripts/utils/stack/names.mjs

@@ -0,0 +1,12 @@
+export function sanitizeStackName(raw, { fallback = 'stack', maxLen = 64 } = {}) {
+  const s = String(raw ?? '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9-]+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-+/, '')
+    .replace(/-+$/, '');
+  const out = s || String(fallback ?? 'stack');
+  return Number.isFinite(maxLen) && maxLen > 0 ? out.slice(0, maxLen) : out;
+}
+

package/scripts/utils/stack/runtime_state.mjs

@@ -0,0 +1,87 @@
+import { existsSync } from 'node:fs';
+import { unlink } from 'node:fs/promises';
+import { join } from 'node:path';
+
+import { resolveStackEnvPath } from '../paths/paths.mjs';
+import { readJsonIfExists, writeJsonAtomic } from '../fs/json.mjs';
+import { isPidAlive } from '../proc/pids.mjs';
+
+export { isPidAlive };
+
+export function getStackRuntimeStatePath(stackName) {
+  const { baseDir } = resolveStackEnvPath(stackName);
+  return join(baseDir, 'stack.runtime.json');
+}
+
+export async function readStackRuntimeStateFile(statePath) {
+  const parsed = await readJsonIfExists(statePath, { defaultValue: null });
+  return parsed && typeof parsed === 'object' ? parsed : null;
+}
+
+export async function writeStackRuntimeStateFile(statePath, state) {
+  if (!statePath) {
+    throw new Error('[stack] missing runtime state path');
+  }
+  await writeJsonAtomic(statePath, state);
+}
+
+function isPlainObject(v) {
+  return Boolean(v) && typeof v === 'object' && !Array.isArray(v);
+}
+
+function deepMerge(a, b) {
+  if (!isPlainObject(a) || !isPlainObject(b)) {
+    return b;
+  }
+  const out = { ...a };
+  for (const [k, v] of Object.entries(b)) {
+    if (isPlainObject(out[k]) && isPlainObject(v)) {
+      out[k] = deepMerge(out[k], v);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+
+export async function updateStackRuntimeStateFile(statePath, patch) {
+  const existing = (await readStackRuntimeStateFile(statePath)) ?? {};
+  const next = deepMerge(existing, patch ?? {});
+  await writeStackRuntimeStateFile(statePath, next);
+  return next;
+}
+
+export async function recordStackRuntimeStart(statePath, { stackName, script, ephemeral, ownerPid, ports } = {}) {
+  const now = new Date().toISOString();
+  const existing = (await readStackRuntimeStateFile(statePath)) ?? {};
+  const startedAt = typeof existing.startedAt === 'string' && existing.startedAt.trim() ? existing.startedAt : now;
+  const next = deepMerge(existing, {
+    version: 1,
+    stackName,
+    script,
+    ephemeral: Boolean(ephemeral),
+    ownerPid,
+    ports: ports ?? {},
+    startedAt,
+    updatedAt: now,
+  });
+  await writeStackRuntimeStateFile(statePath, next);
+  return next;
+}
+
+export async function recordStackRuntimeUpdate(statePath, patch = {}) {
+  return await updateStackRuntimeStateFile(statePath, {
+    ...(patch ?? {}),
+    updatedAt: new Date().toISOString(),
+  });
+}
+
+export async function deleteStackRuntimeStateFile(statePath) {
+  try {
+    if (!statePath || !existsSync(statePath)) return;
+    await unlink(statePath);
+  } catch {
+    // ignore
+  }
+}
+

package/scripts/utils/stack/stacks.mjs

@@ -0,0 +1,45 @@
+import { readdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { getLegacyStorageRoot, getStacksStorageRoot } from '../paths/paths.mjs';
+import { isSandboxed, sandboxAllowsGlobalSideEffects } from '../env/sandbox.mjs';
+import { resolveStackEnvPath } from '../paths/paths.mjs';
+
+export async function listAllStackNames() {
+  const names = new Set(['main']);
+  const allowLegacy = !isSandboxed() || sandboxAllowsGlobalSideEffects();
+  const roots = [
+    // New layout: ~/.happy/stacks/<name>/env
+    getStacksStorageRoot(),
+    // Legacy layout: ~/.happy/local/stacks/<name>/env
+    ...(allowLegacy ? [join(getLegacyStorageRoot(), 'stacks')] : []),
+  ];
+
+  for (const root of roots) {
+    let entries = [];
+    try {
+      // eslint-disable-next-line no-await-in-loop
+      entries = await readdir(root, { withFileTypes: true });
+    } catch {
+      entries = [];
+    }
+    for (const ent of entries) {
+      if (!ent.isDirectory()) continue;
+      const name = ent.name;
+      if (!name || name.startsWith('.')) continue;
+      const envPath = join(root, name, 'env');
+      if (existsSync(envPath)) {
+        names.add(name);
+      }
+    }
+  }
+
+  return Array.from(names).sort();
+}
+
+export function stackExistsSync(stackName) {
+  const name = String(stackName ?? '').trim() || 'main';
+  if (name === 'main') return true;
+  return existsSync(resolveStackEnvPath(name).envPath);
+}

package/scripts/utils/stack/startup.mjs

@@ -0,0 +1,208 @@
+import { runCapture } from '../proc/proc.mjs';
+import { ensureDepsInstalled, pmExecBin } from '../proc/pm.mjs';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+function looksLikeMissingTableError(msg) {
+  const s = String(msg ?? '').toLowerCase();
+  return s.includes('does not exist') || s.includes('no such table');
+}
+
+async function probeAccountCount({ serverDir, env }) {
+  const probe = `
+	let db;
+	try {
+	  const { PrismaClient } = await import('@prisma/client');
+	  db = new PrismaClient();
+	  const accountCount = await db.account.count();
+	  console.log(JSON.stringify({ accountCount }));
+	} catch (e) {
+	  console.log(
+	    JSON.stringify({
+	      error: {
+	        name: e?.name,
+	        message: e?.message,
+	        code: e?.code,
+	      },
+	    })
+	  );
+	} finally {
+	  try {
+	    await db?.$disconnect();
+	  } catch {
+	    // ignore
+	  }
+	}
+	`.trim();
+
+  const out = await runCapture(process.execPath, ['--input-type=module', '-e', probe], { cwd: serverDir, env, timeoutMs: 15_000 });
+  const parsed = out.trim() ? JSON.parse(out.trim()) : {};
+  if (parsed?.error) {
+    const e = new Error(parsed.error.message || 'unknown prisma probe error');
+    if (typeof parsed.error.name === 'string' && parsed.error.name) e.name = parsed.error.name;
+    if (typeof parsed.error.code === 'string' && parsed.error.code) e.code = parsed.error.code;
+    throw e;
+  }
+  return Number(parsed.accountCount ?? 0);
+}
+
+export function resolveAutoCopyFromMainEnabled({ env, stackName, isInteractive }) {
+  const raw = (env.HAPPY_STACKS_AUTO_AUTH_SEED ?? env.HAPPY_LOCAL_AUTO_AUTH_SEED ?? '').toString().trim();
+  if (raw) return raw !== '0';
+
+  // Legacy toggle (kept for existing setups):
+  // - if set, it only controls enable/disable; source stack remains configurable via HAPPY_STACKS_AUTH_SEED_FROM.
+  const legacy = (env.HAPPY_STACKS_AUTO_COPY_FROM_MAIN ?? env.HAPPY_LOCAL_AUTO_COPY_FROM_MAIN ?? '').toString().trim();
+  if (legacy) return legacy !== '0';
+
+  if (stackName === 'main') return false;
+
+  // Default:
+  // - always auto-seed in non-interactive contexts (agents/services)
+  // - in interactive shells, auto-seed only when the user explicitly configured a non-main seed stack
+  //   (this avoids silently spreading main identity for users who haven't opted in yet).
+  if (!isInteractive) return true;
+  const seed = (env.HAPPY_STACKS_AUTH_SEED_FROM ?? env.HAPPY_LOCAL_AUTH_SEED_FROM ?? '').toString().trim();
+  return Boolean(seed && seed !== 'main');
+}
+
+export function resolveAuthSeedFromEnv(env) {
+  // Back-compat for an earlier experimental var name:
+  // - if set to a non-bool-ish stack name, treat it as the seed source
+  // - if set to "1"/"true", ignore (source comes from HAPPY_STACKS_AUTH_SEED_FROM)
+  const legacyAutoFrom = (env.HAPPY_STACKS_AUTO_AUTH_SEED_FROM ?? env.HAPPY_LOCAL_AUTO_AUTH_SEED_FROM ?? '').toString().trim();
+  if (legacyAutoFrom && legacyAutoFrom !== '0' && legacyAutoFrom !== '1' && legacyAutoFrom.toLowerCase() !== 'true') {
+    return legacyAutoFrom;
+  }
+  // Legacy toggle: "on" implies main (historical behavior).
+  const legacy = (env.HAPPY_STACKS_AUTO_COPY_FROM_MAIN ?? env.HAPPY_LOCAL_AUTO_COPY_FROM_MAIN ?? '').toString().trim();
+  if (legacy && legacy !== '0') return 'main';
+  // Otherwise, use the general default seed stack.
+  const seed = (env.HAPPY_STACKS_AUTH_SEED_FROM ?? env.HAPPY_LOCAL_AUTH_SEED_FROM ?? '').toString().trim();
+  return seed || 'main';
+}
+
+export async function ensureServerLightSchemaReady({ serverDir, env }) {
+  await ensureDepsInstalled(serverDir, 'happy-server-light');
+
+  try {
+    const accountCount = await probeAccountCount({ serverDir, env });
+    return { ok: true, pushed: false, accountCount };
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (!looksLikeMissingTableError(msg)) {
+      throw e;
+    }
+    await pmExecBin({ dir: serverDir, bin: 'prisma', args: ['db', 'push'], env });
+    const accountCount = await probeAccountCount({ serverDir, env });
+    return { ok: true, pushed: true, accountCount };
+  }
+}
+
+export async function ensureHappyServerSchemaReady({ serverDir, env }) {
+  await ensureDepsInstalled(serverDir, 'happy-server');
+
+  try {
+    const accountCount = await probeAccountCount({ serverDir, env });
+    return { ok: true, migrated: false, accountCount };
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (!looksLikeMissingTableError(msg)) {
+      throw e;
+    }
+    // If tables are missing, try migrations (safe for postgres). Then re-probe.
+    await pmExecBin({ dir: serverDir, bin: 'prisma', args: ['migrate', 'deploy'], env });
+    const accountCount = await probeAccountCount({ serverDir, env });
+    return { ok: true, migrated: true, accountCount };
+  }
+}
+
+export async function getAccountCountForServerComponent({ serverComponentName, serverDir, env, bestEffort = false }) {
+  if (serverComponentName === 'happy-server-light') {
+    const ready = await ensureServerLightSchemaReady({ serverDir, env });
+    return { ok: true, accountCount: Number.isFinite(ready.accountCount) ? ready.accountCount : 0 };
+  }
+  if (serverComponentName === 'happy-server') {
+    try {
+      const ready = await ensureHappyServerSchemaReady({ serverDir, env });
+      return { ok: true, accountCount: Number.isFinite(ready.accountCount) ? ready.accountCount : 0 };
+    } catch (e) {
+      if (!bestEffort) throw e;
+      return { ok: false, accountCount: null, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  return { ok: false, accountCount: null, error: `unknown server component: ${serverComponentName}` };
+}
+
+export async function maybeAutoCopyAuthFromMainIfNeeded({
+  rootDir,
+  env,
+  enabled,
+  stackName,
+  cliHomeDir,
+  accountCount,
+  quiet = false,
+  authEnv = null,
+}) {
+  const accessKeyPath = join(cliHomeDir, 'access.key');
+  const hasAccessKey = existsSync(accessKeyPath);
+
+  // "Initialized" heuristic:
+  // - if we have credentials AND (when known) at least one Account row, we don't need to seed from main.
+  const hasAccounts = typeof accountCount === 'number' ? accountCount > 0 : null;
+  const needsSeed = !hasAccessKey || hasAccounts === false;
+
+  if (!enabled || !needsSeed) {
+    return { ok: true, skipped: true, reason: !enabled ? 'disabled' : 'already_initialized' };
+  }
+
+  const reason = !hasAccessKey ? 'missing_credentials' : 'no_accounts';
+  const fromStackName = resolveAuthSeedFromEnv(env);
+  const linkAuth =
+    (env.HAPPY_STACKS_AUTH_LINK ?? env.HAPPY_LOCAL_AUTH_LINK ?? '').toString().trim() === '1' ||
+    (env.HAPPY_STACKS_AUTH_MODE ?? env.HAPPY_LOCAL_AUTH_MODE ?? '').toString().trim() === 'link';
+  if (!quiet) {
+    console.log(`[local] auth: auto seed from ${fromStackName} for ${stackName} (${reason})`);
+  }
+
+  // Best-effort: copy credentials/master secret + seed accounts from the configured seed stack.
+  // Keep this non-fatal; the daemon will emit actionable errors if it still can't authenticate.
+  try {
+    const out = await runCapture(
+      process.execPath,
+      [`${rootDir}/scripts/auth.mjs`, 'copy-from', fromStackName, '--json', ...(linkAuth ? ['--link'] : [])],
+      {
+      cwd: rootDir,
+      env: authEnv && typeof authEnv === 'object' ? authEnv : env,
+      }
+    );
+    return { ok: true, skipped: false, reason, out: out.trim() ? JSON.parse(out) : null };
+  } catch (e) {
+    return { ok: false, skipped: false, reason, error: e instanceof Error ? e.message : String(e) };
+  }
+}
+
+export async function prepareDaemonAuthSeedIfNeeded({
+  rootDir,
+  env,
+  stackName,
+  cliHomeDir,
+  startDaemon,
+  isInteractive,
+  accountCount,
+  quiet = false,
+  authEnv = null,
+}) {
+  if (!startDaemon) return { ok: true, skipped: true, reason: 'no_daemon' };
+  const enabled = resolveAutoCopyFromMainEnabled({ env, stackName, isInteractive });
+  return await maybeAutoCopyAuthFromMainIfNeeded({
+    rootDir,
+    env,
+    enabled,
+    stackName,
+    cliHomeDir,
+    accountCount,
+    quiet,
+    authEnv,
+  });
+}