happy-stacks 0.3.0 → 0.5.0

package/scripts/utils/stack/interactive_stack_config.mjs

@@ -0,0 +1,185 @@
+import { join, resolve } from 'node:path';
+
+import { prompt, promptWorktreeSource } from '../cli/wizard.mjs';
+import { coerceHappyMonorepoRootFromPath, getComponentsDir } from '../paths/paths.mjs';
+import { resolveComponentSpecToDir } from '../git/worktrees.mjs';
+
+function wantsNo(raw) {
+  const v = String(raw ?? '').trim().toLowerCase();
+  return v === 'n' || v === 'no' || v === '0' || v === 'false';
+}
+
+function resolveHappySpecDir({ rootDir, spec }) {
+  if (!spec) return '';
+  if (spec === 'default' || spec === 'main') {
+    return join(getComponentsDir(rootDir), 'happy');
+  }
+  if (typeof spec === 'string') {
+    const dir = resolveComponentSpecToDir({ rootDir, component: 'happy', spec });
+    return dir ? resolve(rootDir, dir) : '';
+  }
+  return '';
+}
+
+export async function interactiveNew({ rootDir, rl, defaults, deps = {} }) {
+  const promptFn = deps.prompt ?? prompt;
+  const promptWorktreeSourceFn = deps.promptWorktreeSource ?? promptWorktreeSource;
+
+  const out = { ...defaults };
+
+  if (!out.stackName) {
+    out.stackName = (await rl.question('Stack name: ')).trim();
+  }
+  if (!out.stackName) {
+    throw new Error('[stack] stack name is required');
+  }
+  if (out.stackName === 'main') {
+    throw new Error('[stack] stack name "main" is reserved (use the default stack without creating it)');
+  }
+
+  if (!out.serverComponent) {
+    const server = (await rl.question('Server component [happy-server-light|happy-server] (default: happy-server-light): ')).trim();
+    out.serverComponent = server || 'happy-server-light';
+  }
+
+  if (!out.port) {
+    const want = (await rl.question('Port (empty = ephemeral): ')).trim();
+    out.port = want ? Number(want) : null;
+  }
+
+  if (!out.createRemote) {
+    out.createRemote = await promptFn(rl, 'Git remote for creating new worktrees (default: upstream): ', { defaultValue: 'upstream' });
+  }
+
+  if (out.components.happy == null) {
+    out.components.happy = await promptWorktreeSourceFn({
+      rl,
+      rootDir,
+      component: 'happy',
+      stackName: out.stackName,
+      createRemote: out.createRemote,
+    });
+  }
+
+  const happyIsCreate = Boolean(out.components.happy && typeof out.components.happy === 'object' && out.components.happy.create);
+  const happyMonoRoot = coerceHappyMonorepoRootFromPath(resolveHappySpecDir({ rootDir, spec: out.components.happy }));
+  const canDeriveMonorepoGroup = Boolean(happyMonoRoot) || happyIsCreate;
+  let deriveMonorepoGroup = false;
+
+  if (canDeriveMonorepoGroup) {
+    const ans = await promptFn(rl, 'Detected happy monorepo checkout. Derive happy-cli + happy-server from it? [Y/n]: ', {
+      defaultValue: 'y',
+    });
+    deriveMonorepoGroup = !wantsNo(ans);
+  }
+
+  if (deriveMonorepoGroup) {
+    out.components['happy-cli'] = null;
+    out.components['happy-server'] = null;
+    // In monorepo mode, happy-server-light is derived when supported by the monorepo server checkout.
+    // If not supported, the stack env will keep the default separate happy-server-light checkout.
+    out.components['happy-server-light'] = null;
+  } else if (out.components['happy-cli'] == null) {
+    out.components['happy-cli'] = await promptWorktreeSourceFn({
+      rl,
+      rootDir,
+      component: 'happy-cli',
+      stackName: out.stackName,
+      createRemote: out.createRemote,
+    });
+  }
+
+  const serverComponent = out.serverComponent === 'happy-server' ? 'happy-server' : 'happy-server-light';
+  if (serverComponent === 'happy-server-light' && deriveMonorepoGroup) {
+    out.components['happy-server-light'] = null;
+    return out;
+  }
+  if (serverComponent === 'happy-server' && deriveMonorepoGroup) {
+    out.components['happy-server'] = null;
+  } else if (out.components[serverComponent] == null) {
+    out.components[serverComponent] = await promptWorktreeSourceFn({
+      rl,
+      rootDir,
+      component: serverComponent,
+      stackName: out.stackName,
+      createRemote: out.createRemote,
+    });
+  }
+
+  return out;
+}
+
+export async function interactiveEdit({ rootDir, rl, stackName, existingEnv, defaults, deps = {} }) {
+  const promptFn = deps.prompt ?? prompt;
+  const promptWorktreeSourceFn = deps.promptWorktreeSource ?? promptWorktreeSource;
+
+  const out = { ...defaults, stackName };
+
+  const currentServer = existingEnv.HAPPY_STACKS_SERVER_COMPONENT ?? existingEnv.HAPPY_LOCAL_SERVER_COMPONENT ?? '';
+  const server = await promptFn(rl, `Server component [happy-server-light|happy-server] (default: ${currentServer || 'happy-server-light'}): `, {
+    defaultValue: currentServer || 'happy-server-light',
+  });
+  out.serverComponent = server || 'happy-server-light';
+
+  const currentPort = existingEnv.HAPPY_STACKS_SERVER_PORT ?? existingEnv.HAPPY_LOCAL_SERVER_PORT ?? '';
+  const wantPort = await promptFn(rl, `Port (empty = keep ${currentPort || 'ephemeral'}; type 'ephemeral' to unpin): `, { defaultValue: '' });
+  const wantTrimmed = wantPort.trim().toLowerCase();
+  out.port = wantTrimmed === 'ephemeral' ? null : wantPort ? Number(wantPort) : currentPort ? Number(currentPort) : null;
+
+  const currentRemote = existingEnv.HAPPY_STACKS_STACK_REMOTE ?? existingEnv.HAPPY_LOCAL_STACK_REMOTE ?? '';
+  out.createRemote = await promptFn(rl, `Git remote for creating new worktrees (default: ${currentRemote || 'upstream'}): `, {
+    defaultValue: currentRemote || 'upstream',
+  });
+
+  out.components.happy = await promptWorktreeSourceFn({
+    rl,
+    rootDir,
+    component: 'happy',
+    stackName,
+    createRemote: out.createRemote,
+  });
+
+  const happyIsCreate = Boolean(out.components.happy && typeof out.components.happy === 'object' && out.components.happy.create);
+  const happyMonoRoot = coerceHappyMonorepoRootFromPath(resolveHappySpecDir({ rootDir, spec: out.components.happy }));
+  const canDeriveMonorepoGroup = Boolean(happyMonoRoot) || happyIsCreate;
+  let deriveMonorepoGroup = false;
+  if (canDeriveMonorepoGroup) {
+    const ans = await promptFn(rl, 'Detected happy monorepo checkout. Derive happy-cli + happy-server from it? [Y/n]: ', {
+      defaultValue: 'y',
+    });
+    deriveMonorepoGroup = !wantsNo(ans);
+  }
+
+  if (deriveMonorepoGroup) {
+    out.components['happy-cli'] = null;
+    out.components['happy-server'] = null;
+    out.components['happy-server-light'] = null;
+  } else if (out.components['happy-cli'] == null) {
+    out.components['happy-cli'] = await promptWorktreeSourceFn({
+      rl,
+      rootDir,
+      component: 'happy-cli',
+      stackName,
+      createRemote: out.createRemote,
+    });
+  }
+
+  const serverComponent = out.serverComponent === 'happy-server' ? 'happy-server' : 'happy-server-light';
+  if (serverComponent === 'happy-server-light' && deriveMonorepoGroup) {
+    out.components['happy-server-light'] = null;
+    return out;
+  }
+  if (serverComponent === 'happy-server' && deriveMonorepoGroup) {
+    out.components['happy-server'] = null;
+  } else {
+    out.components[serverComponent] = await promptWorktreeSourceFn({
+      rl,
+      rootDir,
+      component: serverComponent,
+      stackName,
+      createRemote: out.createRemote,
+    });
+  }
+
+  return out;
+}

package/scripts/utils/stack/pr_stack_name.mjs

@@ -0,0 +1,16 @@
+import { parseGithubPullRequest } from '../git/refs.mjs';
+import { sanitizeStackName } from './names.mjs';
+
+export function inferPrStackBaseName({ happy, happyCli, server, serverLight, fallback = 'pr' }) {
+  const parts = [];
+  const hn = parseGithubPullRequest(happy)?.number ?? null;
+  const cn = parseGithubPullRequest(happyCli)?.number ?? null;
+  const sn = parseGithubPullRequest(server)?.number ?? null;
+  const sln = parseGithubPullRequest(serverLight)?.number ?? null;
+  if (hn) parts.push(`happy${hn}`);
+  if (cn) parts.push(`cli${cn}`);
+  if (sn) parts.push(`server${sn}`);
+  if (sln) parts.push(`light${sln}`);
+  return sanitizeStackName(parts.length ? `pr-${parts.join('-')}` : fallback, { fallback, maxLen: 64 });
+}
+

package/scripts/utils/stack/runtime_state.mjs

@@ -51,7 +51,7 @@ export async function updateStackRuntimeStateFile(statePath, patch) {
   return next;
 }
 
-export async function recordStackRuntimeStart(statePath, { stackName, script, ephemeral, ownerPid, ports } = {}) {
+export async function recordStackRuntimeStart(statePath, { stackName, script, ephemeral, ownerPid, ports, ...rest } = {}) {
   const now = new Date().toISOString();
   const existing = (await readStackRuntimeStateFile(statePath)) ?? {};
   const startedAt = typeof existing.startedAt === 'string' && existing.startedAt.trim() ? existing.startedAt : now;
@@ -64,6 +64,7 @@ export async function recordStackRuntimeStart(statePath, { stackName, script, ep
     ports: ports ?? {},
     startedAt,
     updatedAt: now,
+    ...(rest ?? {}),
   });
   await writeStackRuntimeStateFile(statePath, next);
   return next;

package/scripts/utils/stack/startup.mjs

@@ -1,18 +1,53 @@
 import { runCapture } from '../proc/proc.mjs';
 import { ensureDepsInstalled, pmExecBin } from '../proc/pm.mjs';
+import { isSandboxed, sandboxAllowsGlobalSideEffects } from '../env/sandbox.mjs';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
+import { mkdir } from 'node:fs/promises';
+import { resolvePrismaClientImportForServerComponent, resolveServerLightPrismaMigrateDeployArgs, resolveServerLightPrismaSchemaArgs } from '../server/flavor_scripts.mjs';
 
 function looksLikeMissingTableError(msg) {
   const s = String(msg ?? '').toLowerCase();
   return s.includes('does not exist') || s.includes('no such table');
 }
 
-async function probeAccountCount({ serverDir, env }) {
+function looksLikeAlreadyExistsError(msg) {
+  const s = String(msg ?? '').toLowerCase();
+  return s.includes('already exists') || s.includes('duplicate') || s.includes('constraint failed');
+}
+
+function looksLikeMissingGeneratedSqliteClientError(err) {
+  const code = err && typeof err === 'object' ? err.code : '';
+  if (code !== 'ERR_MODULE_NOT_FOUND') return false;
+  const msg = err instanceof Error ? err.message : String(err ?? '');
+  return msg.includes('/generated/sqlite-client/') || msg.includes('\\generated\\sqlite-client\\');
+}
+
+async function findSqliteBaselineMigrationDir({ serverDir }) {
+  try {
+    // Unified monorepo server-light migrations live under prisma/sqlite/migrations.
+    // For legacy schema.sqlite.prisma setups, migrations use the default prisma/migrations folder.
+    const migrationsDir = existsSync(join(serverDir, 'prisma', 'sqlite', 'schema.prisma'))
+      ? join(serverDir, 'prisma', 'sqlite', 'migrations')
+      : join(serverDir, 'prisma', 'migrations');
+    const { readdir } = await import('node:fs/promises');
+    const entries = await readdir(migrationsDir, { withFileTypes: true });
+    const dirs = entries
+      .filter((e) => e.isDirectory())
+      .map((e) => e.name)
+      .sort();
+    return dirs[0] || null;
+  } catch {
+    return null;
+  }
+}
+
+async function probeAccountCount({ serverComponentName, serverDir, env }) {
+  const clientImport = resolvePrismaClientImportForServerComponent({ serverComponentName, serverDir });
   const probe = `
 	let db;
 	try {
-	  const { PrismaClient } = await import('@prisma/client');
+	  const { PrismaClient } = await import(${JSON.stringify(clientImport)});
 	  db = new PrismaClient();
 	  const accountCount = await db.account.count();
 	  console.log(JSON.stringify({ accountCount }));
@@ -47,6 +82,12 @@ async function probeAccountCount({ serverDir, env }) {
 }
 
 export function resolveAutoCopyFromMainEnabled({ env, stackName, isInteractive }) {
+  // Sandboxes should be isolated by default.
+  // Auto auth seeding can copy credentials/account rows from another stack (global state),
+  // which breaks isolation and can confuse guided auth flows (setup-pr/review-pr).
+  if (isSandboxed() && !sandboxAllowsGlobalSideEffects()) {
+    return false;
+  }
   const raw = (env.HAPPY_STACKS_AUTO_AUTH_SEED ?? env.HAPPY_LOCAL_AUTO_AUTH_SEED ?? '').toString().trim();
   if (raw) return raw !== '0';
 
@@ -83,27 +124,93 @@ export function resolveAuthSeedFromEnv(env) {
 }
 
 export async function ensureServerLightSchemaReady({ serverDir, env }) {
-  await ensureDepsInstalled(serverDir, 'happy-server-light');
+  await ensureDepsInstalled(serverDir, 'happy-server-light', { env });
 
+  const dataDir = (env?.HAPPY_SERVER_LIGHT_DATA_DIR ?? '').toString().trim();
+  const filesDir = (env?.HAPPY_SERVER_LIGHT_FILES_DIR ?? '').toString().trim() || (dataDir ? join(dataDir, 'files') : '');
+  if (dataDir) {
+    try {
+      await mkdir(dataDir, { recursive: true });
+    } catch {
+      // best-effort
+    }
+  }
+  if (filesDir) {
+    try {
+      await mkdir(filesDir, { recursive: true });
+    } catch {
+      // best-effort
+    }
+  }
+
+  const probe = async () => await probeAccountCount({ serverComponentName: 'happy-server-light', serverDir, env });
+  const schemaArgs = resolveServerLightPrismaSchemaArgs({ serverDir });
+
+  const isUnified = schemaArgs.length > 0;
+
+  // Unified server-light (monorepo): ensure deterministic migrations are applied (idempotent).
+  // Legacy server-light (single schema.prisma with db push): do NOT run `prisma migrate deploy`,
+  // because it commonly fails with P3005 when the DB was created by `prisma db push` and no migrations exist.
+  if (isUnified) {
+    try {
+      await pmExecBin({ dir: serverDir, bin: 'prisma', args: resolveServerLightPrismaMigrateDeployArgs({ serverDir }), env });
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      // If the SQLite DB was created before migrations existed (historical db push era),
+      // `migrate deploy` can fail because tables already exist. Best-effort: baseline-resolve
+      // the first migration, then retry deploy.
+      if (looksLikeAlreadyExistsError(msg)) {
+        const baseline = await findSqliteBaselineMigrationDir({ serverDir });
+        if (baseline) {
+          await pmExecBin({
+            dir: serverDir,
+            bin: 'prisma',
+            args: ['migrate', 'resolve', ...schemaArgs, '--applied', baseline],
+            env,
+          }).catch(() => {});
+          await pmExecBin({ dir: serverDir, bin: 'prisma', args: resolveServerLightPrismaMigrateDeployArgs({ serverDir }), env });
+        } else {
+          throw e;
+        }
+      } else {
+        throw e;
+      }
+    }
+  }
+
+  // 2) Probe account count (used for auth seeding heuristics).
   try {
-    const accountCount = await probeAccountCount({ serverDir, env });
-    return { ok: true, pushed: false, accountCount };
+    const accountCount = await probe();
+    return { ok: true, migrated: isUnified, accountCount };
   } catch (e) {
+    if (looksLikeMissingGeneratedSqliteClientError(e)) {
+      await pmExecBin({ dir: serverDir, bin: 'prisma', args: ['generate', ...schemaArgs], env });
+      const accountCount = await probe();
+      return { ok: true, migrated: isUnified, accountCount };
+    }
     const msg = e instanceof Error ? e.message : String(e);
-    if (!looksLikeMissingTableError(msg)) {
-      throw e;
+    if (looksLikeMissingTableError(msg)) {
+      if (isUnified) {
+        // Tables still missing after migrate deploy; fail closed with a clear error.
+        throw new Error(`[server-light] sqlite schema not ready after prisma migrate deploy (missing tables).`);
+      }
+      // Legacy server-light: schema is typically applied via `prisma db push` in the component's dev/start scripts.
+      // Best-effort: don't fail the whole stack startup just because we can't probe here.
+      return { ok: true, migrated: false, accountCount: 0 };
+    }
+    if (!isUnified) {
+      // Legacy server-light: probing is best-effort (don't make stack dev fail closed here).
+      return { ok: true, migrated: false, accountCount: 0 };
     }
-    await pmExecBin({ dir: serverDir, bin: 'prisma', args: ['db', 'push'], env });
-    const accountCount = await probeAccountCount({ serverDir, env });
-    return { ok: true, pushed: true, accountCount };
+    throw e;
   }
 }
 
 export async function ensureHappyServerSchemaReady({ serverDir, env }) {
-  await ensureDepsInstalled(serverDir, 'happy-server');
+  await ensureDepsInstalled(serverDir, 'happy-server', { env });
 
   try {
-    const accountCount = await probeAccountCount({ serverDir, env });
+    const accountCount = await probeAccountCount({ serverComponentName: 'happy-server', serverDir, env });
     return { ok: true, migrated: false, accountCount };
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
@@ -112,7 +219,7 @@ export async function ensureHappyServerSchemaReady({ serverDir, env }) {
     }
     // 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 });
+    const accountCount = await probeAccountCount({ serverComponentName: 'happy-server', serverDir, env });
     return { ok: true, migrated: true, accountCount };
   }
 }

package/scripts/utils/stack/startup_server_light_dirs.test.mjs

@@ -0,0 +1,64 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { chmod, mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+
+import { ensureServerLightSchemaReady } from './startup.mjs';
+
+async function writeJson(path, obj) {
+  await writeFile(path, JSON.stringify(obj, null, 2) + '\n', 'utf-8');
+}
+
+test('ensureServerLightSchemaReady creates stack sqlite data dirs before probing', async (t) => {
+  const root = await mkdtemp(join(tmpdir(), 'hs-startup-sqlite-dirs-'));
+  t.after(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  const serverDir = join(root, 'server');
+  await mkdir(serverDir, { recursive: true });
+  await writeJson(join(serverDir, 'package.json'), { name: 'server', version: '0.0.0' });
+  await writeFile(join(serverDir, 'yarn.lock'), '# yarn\n', 'utf-8');
+  await mkdir(join(serverDir, 'node_modules'), { recursive: true });
+  await writeFile(join(serverDir, 'node_modules', '.yarn-integrity'), 'ok\n', 'utf-8');
+
+  await mkdir(join(serverDir, 'prisma', 'sqlite'), { recursive: true });
+  await writeFile(join(serverDir, 'prisma', 'sqlite', 'schema.prisma'), 'datasource db { provider = "sqlite" }\n', 'utf-8');
+
+  // Provide the generated client so we don't need to run prisma generate in this test.
+  await mkdir(join(serverDir, 'generated', 'sqlite-client'), { recursive: true });
+  await writeFile(
+    join(serverDir, 'generated', 'sqlite-client', 'index.js'),
+    ['export class PrismaClient {', '  constructor() { this.account = { count: async () => 0 }; }', '  async $disconnect() {}', '}'].join('\n') +
+      '\n',
+    'utf-8'
+  );
+
+  // Minimal stub `yarn` so commandExists('yarn') succeeds.
+  const binDir = join(root, 'bin');
+  await mkdir(binDir, { recursive: true });
+  const yarnPath = join(binDir, 'yarn');
+  await writeFile(yarnPath, ['#!/usr/bin/env node', "console.log('1.22.22');"].join('\n') + '\n', 'utf-8');
+  await chmod(yarnPath, 0o755);
+
+  const dataDir = join(root, 'data');
+  const filesDir = join(dataDir, 'files');
+  const env = {
+    ...process.env,
+    PATH: `${binDir}:${process.env.PATH ?? ''}`,
+    HAPPY_SERVER_LIGHT_DATA_DIR: dataDir,
+    HAPPY_SERVER_LIGHT_FILES_DIR: filesDir,
+    DATABASE_URL: `file:${join(dataDir, 'happy-server-light.sqlite')}`,
+  };
+
+  assert.equal(existsSync(dataDir), false);
+  assert.equal(existsSync(filesDir), false);
+
+  await ensureServerLightSchemaReady({ serverDir, env });
+
+  assert.equal(existsSync(dataDir), true);
+  assert.equal(existsSync(filesDir), true);
+});
+

package/scripts/utils/stack/startup_server_light_generate.test.mjs

@@ -0,0 +1,70 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, rm, writeFile, chmod } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+
+import { ensureServerLightSchemaReady } from './startup.mjs';
+
+async function writeJson(path, obj) {
+  await writeFile(path, JSON.stringify(obj, null, 2) + '\n', 'utf-8');
+}
+
+test('ensureServerLightSchemaReady runs prisma generate when unified sqlite client is missing', async (t) => {
+  const root = await mkdtemp(join(tmpdir(), 'hs-startup-sqlite-generate-'));
+  t.after(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  const serverDir = join(root, 'server');
+  await mkdir(serverDir, { recursive: true });
+  await writeJson(join(serverDir, 'package.json'), { name: 'server', version: '0.0.0' });
+  await writeFile(join(serverDir, 'yarn.lock'), '# yarn\n', 'utf-8');
+
+  // Mark deps as installed so ensureDepsInstalled doesn't attempt a real install.
+  await mkdir(join(serverDir, 'node_modules'), { recursive: true });
+  await writeFile(join(serverDir, 'node_modules', '.yarn-integrity'), 'ok\n', 'utf-8');
+
+  // Unified light detection + expected schema path.
+  await mkdir(join(serverDir, 'prisma', 'sqlite'), { recursive: true });
+  await writeFile(join(serverDir, 'prisma', 'sqlite', 'schema.prisma'), 'datasource db { provider = "sqlite" }\n', 'utf-8');
+
+  // generated/sqlite-client exists, but the entrypoint is missing (this triggers ERR_MODULE_NOT_FOUND).
+  await mkdir(join(serverDir, 'generated', 'sqlite-client'), { recursive: true });
+
+  // Provide a stub `yarn` in PATH so pmExecBin("prisma", ...) succeeds without real dependencies.
+  const binDir = join(root, 'bin');
+  await mkdir(binDir, { recursive: true });
+  const yarnPath = join(binDir, 'yarn');
+  await writeFile(
+    yarnPath,
+    [
+      '#!/usr/bin/env node',
+      "const { writeFileSync } = require('node:fs');",
+      "const { join } = require('node:path');",
+      'const cwd = process.cwd();',
+      'const out = join(cwd, "generated", "sqlite-client", "index.js");',
+      'const text = [',
+      "  'export class PrismaClient {',",
+      "  '  constructor() { this.account = { count: async () => 0 }; }',",
+      "  '  async $disconnect() {}',",
+      "  '}',",
+      "].join('\\n') + '\\n';",
+      'writeFileSync(out, text, "utf-8");',
+      'process.exit(0);',
+    ].join('\n') + '\n',
+    'utf-8'
+  );
+  await chmod(yarnPath, 0o755);
+
+  const oldPath = process.env.PATH;
+  try {
+    process.env.PATH = `${binDir}:${oldPath ?? ''}`;
+    const res = await ensureServerLightSchemaReady({ serverDir, env: process.env });
+    assert.equal(res.ok, true);
+    assert.equal(res.migrated, true);
+    assert.equal(res.accountCount, 0);
+  } finally {
+    process.env.PATH = oldPath;
+  }
+});

package/scripts/utils/stack/startup_server_light_legacy.test.mjs

@@ -0,0 +1,88 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { chmod, mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+
+import { ensureServerLightSchemaReady } from './startup.mjs';
+
+async function writeJson(path, obj) {
+  await writeFile(path, JSON.stringify(obj, null, 2) + '\n', 'utf-8');
+}
+
+test('ensureServerLightSchemaReady does not run prisma migrate deploy for legacy happy-server-light checkouts', async (t) => {
+  const root = await mkdtemp(join(tmpdir(), 'hs-startup-sqlite-legacy-'));
+  t.after(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  const serverDir = join(root, 'server');
+  await mkdir(serverDir, { recursive: true });
+  await writeJson(join(serverDir, 'package.json'), { name: 'server', version: '0.0.0', type: 'module' });
+  await writeFile(join(serverDir, 'yarn.lock'), '# yarn\n', 'utf-8');
+
+  // Mark deps as installed so ensureDepsInstalled doesn't attempt a real install.
+  await mkdir(join(serverDir, 'node_modules'), { recursive: true });
+  await writeFile(join(serverDir, 'node_modules', '.yarn-integrity'), 'ok\n', 'utf-8');
+
+  // Legacy checkout: no prisma/sqlite/schema.prisma and no prisma/schema.sqlite.prisma.
+  // Provide a minimal node_modules @prisma/client so probeAccountCount can succeed.
+  await mkdir(join(serverDir, 'node_modules', '@prisma', 'client'), { recursive: true });
+  await writeJson(join(serverDir, 'node_modules', '@prisma', 'client', 'package.json'), {
+    name: '@prisma/client',
+    type: 'module',
+    main: './index.js',
+  });
+  await writeFile(
+    join(serverDir, 'node_modules', '@prisma', 'client', 'index.js'),
+    [
+      'export class PrismaClient {',
+      '  constructor() { this.account = { count: async () => 0 }; }',
+      '  async $disconnect() {}',
+      '}',
+    ].join('\n') + '\n',
+    'utf-8'
+  );
+
+  const marker = join(root, 'called-prisma.txt');
+
+  // Provide a stub `yarn` so ensureYarnReady + pmExecBin are controllable.
+  const binDir = join(root, 'bin');
+  await mkdir(binDir, { recursive: true });
+  const yarnPath = join(binDir, 'yarn');
+  await writeFile(
+    yarnPath,
+    [
+      '#!/usr/bin/env node',
+      "const fs = require('node:fs');",
+      "const path = require('node:path');",
+      "const args = process.argv.slice(2);",
+      // ensureYarnReady calls: yarn --version
+      "if (args.includes('--version')) { console.log('1.22.22'); process.exit(0); }",
+      // pmExecBin calls: yarn run prisma ...
+      "if (args[0] === 'run' && args[1] === 'prisma') {",
+      `  fs.writeFileSync(${JSON.stringify(marker)}, args.join(' ') + '\\n', 'utf-8');`,
+      '  process.exit(0);',
+      '}',
+      "console.log('ok');",
+      'process.exit(0);',
+    ].join('\n') + '\n',
+    'utf-8'
+  );
+  await chmod(yarnPath, 0o755);
+
+  const env = {
+    ...process.env,
+    PATH: `${binDir}:${process.env.PATH ?? ''}`,
+    DATABASE_URL: `file:${join(root, 'happy-server-light.sqlite')}`,
+  };
+
+  const res = await ensureServerLightSchemaReady({ serverDir, env });
+  assert.equal(res.ok, true);
+  assert.equal(res.migrated, false);
+  assert.equal(res.accountCount, 0);
+
+  assert.equal(existsSync(marker), false, `expected no prisma migrate deploy call, but saw: ${marker}`);
+});
+

package/scripts/utils/stack/stop.mjs

@@ -126,6 +126,7 @@ export async function stopStackWithEnv({ rootDir, stackName, baseDir, env, json,
     daemonSessionsStopped: null,
     daemonStopped: false,
     killedPorts: [],
+    expoDev: [],
     uiDev: [],
     mobile: [],
     infra: null,
@@ -136,7 +137,13 @@ export async function stopStackWithEnv({ rootDir, stackName, baseDir, env, json,
   const port = coercePort(env.HAPPY_STACKS_SERVER_PORT ?? env.HAPPY_LOCAL_SERVER_PORT);
   const backendPort = coercePort(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');
+  // IMPORTANT:
+  // When stopping a stack, always prefer the stack's pinned happy-cli checkout/worktree.
+  // Otherwise, PR stacks can accidentally run the base checkout's CLI bin, which may not be built
+  // (we intentionally skip building base checkouts in some sandbox PR flows).
+  const pinnedCliDir = (env.HAPPY_STACKS_COMPONENT_DIR_HAPPY_CLI ?? env.HAPPY_LOCAL_COMPONENT_DIR_HAPPY_CLI ?? '').toString().trim();
+  const cliDir = pinnedCliDir || getComponentDir(rootDir, 'happy-cli');
+  const cliBin = join(cliDir, 'bin', 'happy.mjs');
   const envPath = (env.HAPPY_STACKS_ENV_FILE ?? env.HAPPY_LOCAL_ENV_FILE ?? '').toString();
 
   // Preferred: stop stack-started processes (by PID) recorded in stack.runtime.json.
@@ -194,12 +201,16 @@ export async function stopStackWithEnv({ rootDir, stackName, baseDir, env, json,
   }
 
   try {
-    actions.uiDev = await stopExpoStateDir({ stackName, baseDir, kind: 'ui-dev', stateFileName: 'ui.state.json', envPath, json });
+    actions.expoDev = await stopExpoStateDir({ stackName, baseDir, kind: 'expo-dev', stateFileName: 'expo.state.json', envPath, json });
   } catch (e) {
-    actions.errors.push({ step: 'expo-ui', error: e instanceof Error ? e.message : String(e) });
+    actions.errors.push({ step: 'expo-dev', error: e instanceof Error ? e.message : String(e) });
   }
   try {
-    actions.mobile = await stopExpoStateDir({ stackName, baseDir, kind: 'mobile', stateFileName: 'expo.state.json', envPath, json });
+    // Legacy cleanups (best-effort): older runs used separate state dirs.
+    actions.uiDev = await stopExpoStateDir({ stackName, baseDir, kind: 'ui-dev', stateFileName: 'ui.state.json', envPath, json });
+    const killedDev = await stopExpoStateDir({ stackName, baseDir, kind: 'mobile-dev', stateFileName: 'mobile.state.json', envPath, json });
+    const killedLegacy = await stopExpoStateDir({ stackName, baseDir, kind: 'mobile', stateFileName: 'expo.state.json', envPath, json });
+    actions.mobile = [...killedDev, ...killedLegacy];
   } catch (e) {
     actions.errors.push({ step: 'expo-mobile', error: e instanceof Error ? e.message : String(e) });
   }