happy-stacks 0.0.0 → 0.1.2

package/scripts/utils/stack_stop.mjs

@@ -0,0 +1,206 @@
+import { existsSync } from 'node:fs';
+import { readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+import { getComponentDir } from './paths.mjs';
+import { killPortListeners } from './ports.mjs';
+import { isPidAlive, killPid, readPidState } from './expo.mjs';
+import { stopLocalDaemon } from '../daemon.mjs';
+import { stopHappyServerManagedInfra } from './happy_server_infra.mjs';
+
+function parseIntOrNull(raw) {
+  const s = String(raw ?? '').trim();
+  if (!s) return null;
+  const n = Number(s);
+  return Number.isFinite(n) && n > 0 ? n : null;
+}
+
+function resolveServerComponentFromStackEnv(env) {
+  const v =
+    (env.HAPPY_STACKS_SERVER_COMPONENT ?? env.HAPPY_LOCAL_SERVER_COMPONENT ?? '').toString().trim() || 'happy-server-light';
+  return v === 'happy-server' ? 'happy-server' : 'happy-server-light';
+}
+
+async function daemonControlPost({ httpPort, path, body = {} }) {
+  const ctl = new AbortController();
+  const t = setTimeout(() => ctl.abort(), 1500);
+  try {
+    const res = await fetch(`http://127.0.0.1:${httpPort}${path}`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(body),
+      signal: ctl.signal,
+    });
+    const text = await res.text();
+    if (!res.ok) {
+      throw new Error(`daemon control ${path} failed (http ${res.status}): ${text.trim()}`);
+    }
+    return text.trim() ? JSON.parse(text) : null;
+  } finally {
+    clearTimeout(t);
+  }
+}
+
+async function stopDaemonTrackedSessions({ cliHomeDir, json }) {
+  // Read daemon state file written by happy-cli; needed to call control server (/list, /stop-session).
+  const statePath = join(cliHomeDir, 'daemon.state.json');
+  if (!existsSync(statePath)) {
+    return { ok: true, skipped: true, reason: 'missing_state', stoppedSessionIds: [] };
+  }
+
+  let state = null;
+  try {
+    state = JSON.parse(await readFile(statePath, 'utf-8'));
+  } catch {
+    return { ok: false, skipped: true, reason: 'bad_state', stoppedSessionIds: [] };
+  }
+
+  const httpPort = Number(state?.httpPort);
+  const pid = Number(state?.pid);
+  if (!Number.isFinite(httpPort) || httpPort <= 0) {
+    return { ok: false, skipped: true, reason: 'missing_http_port', stoppedSessionIds: [] };
+  }
+  if (!Number.isFinite(pid) || pid <= 1) {
+    return { ok: false, skipped: true, reason: 'missing_pid', stoppedSessionIds: [] };
+  }
+  try {
+    process.kill(pid, 0);
+  } catch {
+    return { ok: true, skipped: true, reason: 'daemon_not_running', stoppedSessionIds: [] };
+  }
+
+  const listed = await daemonControlPost({ httpPort, path: '/list' }).catch((e) => {
+    if (!json) console.warn(`[stack] failed to list daemon sessions: ${e instanceof Error ? e.message : String(e)}`);
+    return null;
+  });
+  const children = Array.isArray(listed?.children) ? listed.children : [];
+
+  const stoppedSessionIds = [];
+  for (const child of children) {
+    const sid = String(child?.happySessionId ?? '').trim();
+    if (!sid) continue;
+    // eslint-disable-next-line no-await-in-loop
+    const res = await daemonControlPost({ httpPort, path: '/stop-session', body: { sessionId: sid } }).catch(() => null);
+    if (res?.success) {
+      stoppedSessionIds.push(sid);
+    }
+  }
+
+  return { ok: true, skipped: false, stoppedSessionIds };
+}
+
+async function stopExpoStateDir({ stackName, baseDir, kind, stateFileName, json }) {
+  const root = join(baseDir, kind);
+  let entries = [];
+  try {
+    entries = await readdir(root, { withFileTypes: true });
+  } catch {
+    entries = [];
+  }
+
+  const killed = [];
+  for (const e of entries) {
+    if (!e.isDirectory()) continue;
+    const statePath = join(root, e.name, stateFileName);
+    // eslint-disable-next-line no-await-in-loop
+    const state = await readPidState(statePath);
+    if (!state) continue;
+    const pid = Number(state.pid);
+    const port = parseIntOrNull(state.port);
+
+    if (!Number.isFinite(pid) || pid <= 1) continue;
+    if (!isPidAlive(pid)) continue;
+
+    if (!json) {
+      // eslint-disable-next-line no-console
+      console.log(`[stack] stopping ${kind} (pid=${pid}${port ? ` port=${port}` : ''}) for ${stackName}`);
+    }
+    if (port) {
+      // eslint-disable-next-line no-await-in-loop
+      await killPortListeners(port, { label: `${stackName} ${kind}` });
+    }
+    // eslint-disable-next-line no-await-in-loop
+    await killPid(pid);
+    killed.push({ pid, port, statePath });
+  }
+  return killed;
+}
+
+export async function stopStackWithEnv({ rootDir, stackName, baseDir, env, json, noDocker = false, aggressive = false }) {
+  const actions = {
+    stackName,
+    baseDir,
+    aggressive,
+    daemonSessionsStopped: null,
+    daemonStopped: false,
+    killedPorts: [],
+    uiDev: [],
+    mobile: [],
+    infra: null,
+    errors: [],
+  };
+
+  const serverComponent = resolveServerComponentFromStackEnv(env);
+  const port = parseIntOrNull(env.HAPPY_STACKS_SERVER_PORT ?? env.HAPPY_LOCAL_SERVER_PORT);
+  const backendPort = parseIntOrNull(env.HAPPY_STACKS_HAPPY_SERVER_BACKEND_PORT ?? env.HAPPY_LOCAL_HAPPY_SERVER_BACKEND_PORT);
+  const cliHomeDir = (env.HAPPY_STACKS_CLI_HOME_DIR ?? env.HAPPY_LOCAL_CLI_HOME_DIR ?? join(baseDir, 'cli')).toString();
+  const cliBin = join(getComponentDir(rootDir, 'happy-cli'), 'bin', 'happy.mjs');
+
+  if (aggressive) {
+    try {
+      actions.daemonSessionsStopped = await stopDaemonTrackedSessions({ cliHomeDir, json });
+    } catch (e) {
+      actions.errors.push({ step: 'daemon-sessions', error: e instanceof Error ? e.message : String(e) });
+    }
+  }
+
+  try {
+    const internalServerUrl = port ? `http://127.0.0.1:${port}` : 'http://127.0.0.1:3005';
+    await stopLocalDaemon({ cliBin, internalServerUrl, cliHomeDir });
+    actions.daemonStopped = true;
+  } catch (e) {
+    actions.errors.push({ step: 'daemon', error: e instanceof Error ? e.message : String(e) });
+  }
+
+  try {
+    actions.uiDev = await stopExpoStateDir({ stackName, baseDir, kind: 'ui-dev', stateFileName: 'ui.state.json', json });
+  } catch (e) {
+    actions.errors.push({ step: 'expo-ui', error: e instanceof Error ? e.message : String(e) });
+  }
+  try {
+    actions.mobile = await stopExpoStateDir({ stackName, baseDir, kind: 'mobile', stateFileName: 'expo.state.json', json });
+  } catch (e) {
+    actions.errors.push({ step: 'expo-mobile', error: e instanceof Error ? e.message : String(e) });
+  }
+
+  if (backendPort) {
+    try {
+      const pids = await killPortListeners(backendPort, { label: `${stackName} happy-server-backend` });
+      actions.killedPorts.push({ port: backendPort, pids, label: 'happy-server-backend' });
+    } catch (e) {
+      actions.errors.push({ step: 'backend-port', error: e instanceof Error ? e.message : String(e) });
+    }
+  }
+  if (port) {
+    try {
+      const pids = await killPortListeners(port, { label: `${stackName} server` });
+      actions.killedPorts.push({ port, pids, label: 'server' });
+    } catch (e) {
+      actions.errors.push({ step: 'server-port', error: e instanceof Error ? e.message : String(e) });
+    }
+  }
+
+  const managed = (env.HAPPY_STACKS_MANAGED_INFRA ?? env.HAPPY_LOCAL_MANAGED_INFRA ?? '1').toString().trim() !== '0';
+  if (!noDocker && serverComponent === 'happy-server' && managed) {
+    try {
+      actions.infra = await stopHappyServerManagedInfra({ stackName, baseDir, removeVolumes: false });
+    } catch (e) {
+      actions.errors.push({ step: 'infra', error: e instanceof Error ? e.message : String(e) });
+    }
+  } else {
+    actions.infra = { ok: true, skipped: true, reason: noDocker ? 'no_docker' : 'not_managed_or_not_happy_server' };
+  }
+
+  return actions;
+}
+

package/scripts/utils/validate.mjs

@@ -1,4 +1,5 @@
-import { resolve, sep } from 'node:path';
+import { readFileSync } from 'node:fs';
+import { join, resolve, sep } from 'node:path';
 import { getComponentsDir } from './paths.mjs';
 
 function isInside(path, dir) {
@@ -45,3 +46,43 @@ export function assertServerComponentDirMatches({ rootDir, serverComponentName,
   );
 }
 
+function detectPrismaProvider(schemaText) {
+  // Best-effort parse of:
+  // datasource db { provider = "sqlite" ... }
+  const m = schemaText.match(/datasource\s+db\s*\{[\s\S]*?\bprovider\s*=\s*\"([a-zA-Z0-9_-]+)\"/m);
+  return m?.[1] ?? '';
+}
+
+export function assertServerPrismaProviderMatches({ serverComponentName, serverDir }) {
+  const schemaPath = join(serverDir, 'prisma', 'schema.prisma');
+  let schemaText = '';
+  try {
+    schemaText = readFileSync(schemaPath, 'utf-8');
+  } catch {
+    // If it doesn't exist, skip validation; not every server component necessarily uses Prisma.
+    return;
+  }
+
+  const provider = detectPrismaProvider(schemaText);
+  if (!provider) {
+    return;
+  }
+
+  if (serverComponentName === 'happy-server-light' && provider !== 'sqlite') {
+    throw new Error(
+      `[server] happy-server-light expects Prisma datasource provider \"sqlite\", but found \"${provider}\" in:\n` +
+        `- ${schemaPath}\n` +
+        `This usually means you're pointing happy-server-light at an upstream happy-server checkout/PR (Postgres).\n` +
+        `Fix: either switch server flavor to happy-server, or point happy-server-light at a fork checkout that keeps sqlite support.`
+    );
+  }
+
+  if (serverComponentName === 'happy-server' && provider === 'sqlite') {
+    throw new Error(
+      `[server] happy-server expects Prisma datasource provider \"postgresql\", but found \"sqlite\" in:\n` +
+        `- ${schemaPath}\n` +
+        `Fix: either switch server flavor to happy-server-light, or point happy-server at the full-server checkout.`
+    );
+  }
+}
+

package/scripts/worktrees.mjs

@@ -14,6 +14,14 @@ import { existsSync } from 'node:fs';
 import { getHomeEnvLocalPath, getHomeEnvPath, resolveUserConfigEnvPath } from './utils/config.mjs';
 import { detectServerComponentDirMismatch } from './utils/validate.mjs';
 
+function getActiveStackName() {
+  return (process.env.HAPPY_STACKS_STACK ?? process.env.HAPPY_LOCAL_STACK ?? '').trim() || 'main';
+}
+
+function isMainStack() {
+  return getActiveStackName() === 'main';
+}
+
 function getWorktreesRoot(rootDir) {
   return join(getComponentsDir(rootDir), '.worktrees');
 }
@@ -142,6 +150,7 @@ async function ensureWorktreeExclude(worktreeDir, patterns) {
   const want = patterns.map((p) => p.trim()).filter(Boolean).filter((p) => !existingLines.has(p));
   if (!want.length) return;
   const next = (existing ? existing.replace(/\s*$/, '') + '\n' : '') + want.join('\n') + '\n';
+  await mkdir(dirname(excludePath), { recursive: true });
   await writeFile(excludePath, next, 'utf-8');
 }
 
@@ -475,13 +484,33 @@ async function cmdMigrate({ rootDir }) {
   return { moved: totalMoved, branchesRenamed: totalRenamed };
 }
 
-async function cmdUse({ rootDir, args }) {
+async function cmdUse({ rootDir, args, flags }) {
   const component = args[0];
   const spec = args[1];
   if (!component || !spec) {
     throw new Error('[wt] usage: happys wt use <component> <owner/branch|path|default>');
   }
 
+  // Safety: main stack should not be repointed to arbitrary worktrees by default.
+  // This is the most common “oops, the main stack now runs my PR checkout” footgun (especially for agents).
+  const force = Boolean(flags?.has('--force'));
+  if (!force && isMainStack() && spec !== 'default' && spec !== 'main') {
+    throw new Error(
+      `[wt] refusing to change main stack component override by default.\n` +
+        `- stack: main\n` +
+        `- component: ${component}\n` +
+        `- requested: ${spec}\n` +
+        `\n` +
+        `Recommendation:\n` +
+        `- Create a new isolated stack and switch that stack instead:\n` +
+        `  happys stack new exp1 --interactive\n` +
+        `  happys stack wt exp1 -- use ${component} ${spec}\n` +
+        `\n` +
+        `If you really intend to repoint the main stack, re-run with --force:\n` +
+        `  happys wt use ${component} ${spec} --force\n`
+    );
+  }
+
   const key = componentDirEnvKey(component);
   const worktreesRoot = getWorktreesRoot(rootDir);
   const envPath = process.env.HAPPY_STACKS_ENV_FILE?.trim()
@@ -577,10 +606,10 @@ async function cmdUseInteractive({ rootDir }) {
         options: specs.map((s) => ({ label: s, value: s })),
         defaultIndex: 0,
       });
-      await cmdUse({ rootDir, args: [component, picked] });
+      await cmdUse({ rootDir, args: [component, picked], flags: new Set(['--force']) });
       return;
     }
-    await cmdUse({ rootDir, args: [component, 'default'] });
+    await cmdUse({ rootDir, args: [component, 'default'], flags: new Set(['--force']) });
   });
 }
 
@@ -652,7 +681,24 @@ async function cmdNew({ rootDir, argv }) {
   const deps = await maybeSetupDeps({ repoRoot, baseDir: baseWorktreeDir || '', worktreeDir: destPath, depsMode });
 
   const shouldUse = flags.has('--use');
+  const force = flags.has('--force');
   if (shouldUse) {
+    if (isMainStack() && !force) {
+      throw new Error(
+        `[wt] refusing to set main stack component override via --use by default.\n` +
+          `- stack: main\n` +
+          `- component: ${component}\n` +
+          `- new worktree: ${destPath}\n` +
+          `\n` +
+          `Recommendation:\n` +
+          `- Use an isolated stack instead:\n` +
+          `  happys stack new exp1 --interactive\n` +
+          `  happys stack wt exp1 -- use ${component} ${owner}/${slug}\n` +
+          `\n` +
+          `If you really intend to repoint the main stack, re-run with --force:\n` +
+          `  happys wt new ${component} ${slug} --use --force\n`
+      );
+    }
     const key = componentDirEnvKey(component);
     await ensureEnvLocalUpdated({ rootDir, updates: [{ key, value: destPath }] });
   }
@@ -776,7 +822,7 @@ async function cmdPr({ rootDir, argv }) {
   const shouldUse = flags.has('--use');
   if (shouldUse) {
     // Reuse cmdUse so it writes to env.local or stack env file depending on context.
-    await cmdUse({ rootDir, args: [component, destPath] });
+    await cmdUse({ rootDir, args: [component, destPath], flags });
   }
 
   const newHead = (await git(destPath, ['rev-parse', 'HEAD'])).trim();
@@ -1535,9 +1581,9 @@ async function main() {
         '  happys wt sync <component> [--remote=<name>] [--json]',
         '  happys wt sync-all [--remote=<name>] [--json]',
         '  happys wt list <component> [--json]',
-        '  happys wt new <component> <slug> [--from=upstream|origin] [--remote=<name>] [--base=<ref>|--base-worktree=<spec>] [--deps=none|link|install|link-or-install] [--use] [--interactive|-i] [--json]',
+        '  happys wt new <component> <slug> [--from=upstream|origin] [--remote=<name>] [--base=<ref>|--base-worktree=<spec>] [--deps=none|link|install|link-or-install] [--use] [--force] [--interactive|-i] [--json]',
         '  happys wt pr <component> <pr-url|number> [--remote=upstream] [--slug=<name>] [--deps=none|link|install|link-or-install] [--use] [--update] [--stash|--stash-keep] [--force] [--json]',
-        '  happys wt use <component> <owner/branch|path|default|main> [--interactive|-i] [--json]',
+        '  happys wt use <component> <owner/branch|path|default|main> [--force] [--interactive|-i] [--json]',
         '  happys wt status <component> [worktreeSpec|default|path] [--json]',
         '  happys wt update <component> [worktreeSpec|default|path] [--remote=upstream] [--base=<ref>] [--rebase|--merge] [--dry-run] [--stash|--stash-keep] [--force] [--json]',
         '  happys wt update-all [component] [--remote=upstream] [--base=<ref>] [--rebase|--merge] [--dry-run] [--stash|--stash-keep] [--force] [--json]',
@@ -1569,7 +1615,7 @@ async function main() {
     if (interactive && isTty()) {
       await cmdUseInteractive({ rootDir });
     } else {
-      const res = await cmdUse({ rootDir, args: positionals.slice(1) });
+      const res = await cmdUse({ rootDir, args: positionals.slice(1), flags });
       printResult({ json, data: res, text: `[wt] ${res.component}: active dir -> ${res.activeDir}` });
     }
     return;