happy-stacks 0.6.12 → 0.6.13

package/scripts/utils/review/tool_home_seed.test.mjs

@@ -0,0 +1,113 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { seedAugmentHomeFromRealHome, seedCodeRabbitHomeFromRealHome, seedCodexHomeFromRealHome } from './tool_home_seed.mjs';
+
+test('seedCodeRabbitHomeFromRealHome copies coderabbit state into isolated home when missing', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'happy-stacks-coderabbit-seed-'));
+  const realHome = join(root, 'real');
+  const isolatedHome = join(root, 'isolated');
+
+  try {
+    await mkdir(join(realHome, '.coderabbit'), { recursive: true });
+    await mkdir(join(realHome, '.config', 'coderabbit'), { recursive: true });
+    await writeFile(join(realHome, '.coderabbit', 'auth.json'), 'secret-ish\n', 'utf-8');
+    await writeFile(join(realHome, '.config', 'coderabbit', 'config.toml'), 'cfg\n', 'utf-8');
+
+    await mkdir(isolatedHome, { recursive: true });
+
+    await seedCodeRabbitHomeFromRealHome({ realHomeDir: realHome, isolatedHomeDir: isolatedHome });
+
+    assert.equal(await readFile(join(isolatedHome, '.coderabbit', 'auth.json'), 'utf-8'), 'secret-ish\n');
+    assert.equal(await readFile(join(isolatedHome, '.config', 'coderabbit', 'config.toml'), 'utf-8'), 'cfg\n');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('seedCodeRabbitHomeFromRealHome does not overwrite existing isolated state', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'happy-stacks-coderabbit-seed-'));
+  const realHome = join(root, 'real');
+  const isolatedHome = join(root, 'isolated');
+
+  try {
+    await mkdir(join(realHome, '.coderabbit'), { recursive: true });
+    await writeFile(join(realHome, '.coderabbit', 'auth.json'), 'from-real\n', 'utf-8');
+
+    await mkdir(join(isolatedHome, '.coderabbit'), { recursive: true });
+    await writeFile(join(isolatedHome, '.coderabbit', 'auth.json'), 'already\n', 'utf-8');
+
+    await seedCodeRabbitHomeFromRealHome({ realHomeDir: realHome, isolatedHomeDir: isolatedHome });
+
+    assert.equal(await readFile(join(isolatedHome, '.coderabbit', 'auth.json'), 'utf-8'), 'already\n');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('seedCodeRabbitHomeFromRealHome refreshes auth.json when the real home has a newer one', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'happy-stacks-coderabbit-seed-'));
+  const realHome = join(root, 'real');
+  const isolatedHome = join(root, 'isolated');
+
+  try {
+    await mkdir(join(realHome, '.coderabbit'), { recursive: true });
+    await mkdir(join(isolatedHome, '.coderabbit'), { recursive: true });
+
+    await writeFile(join(isolatedHome, '.coderabbit', 'auth.json'), 'old\n', 'utf-8');
+    // Ensure a later mtime for the real auth.
+    await new Promise((r) => setTimeout(r, 15));
+    await writeFile(join(realHome, '.coderabbit', 'auth.json'), 'new\n', 'utf-8');
+
+    await seedCodeRabbitHomeFromRealHome({ realHomeDir: realHome, isolatedHomeDir: isolatedHome });
+
+    assert.equal(await readFile(join(isolatedHome, '.coderabbit', 'auth.json'), 'utf-8'), 'new\n');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('seedCodexHomeFromRealHome refreshes auth/config when the real home has newer ones', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'happy-stacks-codex-seed-'));
+  const realHome = join(root, 'real');
+  const isolatedHome = join(root, 'isolated');
+
+  try {
+    await mkdir(join(realHome, '.codex'), { recursive: true });
+    await mkdir(isolatedHome, { recursive: true });
+
+    await writeFile(join(isolatedHome, 'auth.json'), 'old-auth\n', 'utf-8');
+    await writeFile(join(isolatedHome, 'config.toml'), 'old-cfg\n', 'utf-8');
+
+    await new Promise((r) => setTimeout(r, 15));
+    await writeFile(join(realHome, '.codex', 'auth.json'), 'new-auth\n', 'utf-8');
+    await writeFile(join(realHome, '.codex', 'config.toml'), 'new-cfg\n', 'utf-8');
+
+    await seedCodexHomeFromRealHome({ realHomeDir: realHome, isolatedHomeDir: isolatedHome });
+
+    assert.equal(await readFile(join(isolatedHome, 'auth.json'), 'utf-8'), 'new-auth\n');
+    assert.equal(await readFile(join(isolatedHome, 'config.toml'), 'utf-8'), 'new-cfg\n');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('seedAugmentHomeFromRealHome copies session.json into isolated cache dir', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'happy-stacks-augment-seed-'));
+  const realHome = join(root, 'real');
+  const isolatedHome = join(root, 'isolated');
+
+  try {
+    await mkdir(join(realHome, '.augment'), { recursive: true });
+    await writeFile(join(realHome, '.augment', 'session.json'), '{"ok":true}\n', 'utf-8');
+    await mkdir(isolatedHome, { recursive: true });
+
+    await seedAugmentHomeFromRealHome({ realHomeDir: realHome, isolatedHomeDir: isolatedHome });
+
+    assert.equal(await readFile(join(isolatedHome, 'session.json'), 'utf-8'), '{"ok":true}\n');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});

package/scripts/utils/stack/cli_identities.mjs

@@ -0,0 +1,29 @@
+import { dirname, join } from 'node:path';
+
+const IDENTITY_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$/;
+
+export function parseCliIdentityOrThrow(raw) {
+  const v = (raw ?? '').toString().trim();
+  if (!v || v === 'default') return 'default';
+  if (!IDENTITY_RE.test(v)) {
+    throw new Error(
+      `[stack] invalid --identity=${JSON.stringify(v)}. ` +
+        `Expected: "default" or a short name matching ${IDENTITY_RE} (max 64 chars).`
+    );
+  }
+  return v;
+}
+
+export function resolveCliHomeDirForIdentity({ cliHomeDir, identity }) {
+  const id = parseCliIdentityOrThrow(identity);
+  if (id === 'default') return cliHomeDir;
+
+  // Keep identities adjacent to the stack's default cli home dir:
+  //   <...>/<stack>/cli              (default)
+  //   <...>/<stack>/cli-identities/<id>
+  //
+  // If the stack overrides cliHomeDir to a custom path, we keep the same layout
+  // relative to that path's parent directory.
+  const baseDir = dirname(cliHomeDir);
+  return join(baseDir, 'cli-identities', id);
+}

package/scripts/utils/stack/startup.mjs

@@ -16,6 +16,11 @@ function looksLikeAlreadyExistsError(msg) {
   return s.includes('already exists') || s.includes('duplicate') || s.includes('constraint failed');
 }
 
+function looksLikeDatabaseLockedError(msg) {
+  const s = String(msg ?? '').toLowerCase();
+  return s.includes('database is locked') || s.includes('sqlite database error');
+}
+
 function looksLikeMissingGeneratedSqliteClientError(err) {
   const code = err && typeof err === 'object' ? err.code : '';
   if (code !== 'ERR_MODULE_NOT_FOUND') return false;
@@ -123,7 +128,7 @@ export function resolveAuthSeedFromEnv(env) {
   return seed || 'main';
 }
 
-export async function ensureServerLightSchemaReady({ serverDir, env }) {
+export async function ensureServerLightSchemaReady({ serverDir, env, bestEffort = false }) {
   await ensureDepsInstalled(serverDir, 'happy-server-light', { env });
 
   const dataDir = (env?.HAPPY_SERVER_LIGHT_DATA_DIR ?? '').toString().trim();
@@ -151,11 +156,19 @@ export async function ensureServerLightSchemaReady({ serverDir, env }) {
   // 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) {
+  //
+  // IMPORTANT:
+  // In dev/start flows the server process may already be running and holding the SQLite DB open.
+  // Running `prisma migrate deploy` concurrently will fail with "database is locked".
+  // When bestEffort=true (used for auth seeding heuristics), skip migrations and only probe.
+  if (isUnified && !bestEffort) {
     try {
       await pmExecBin({ dir: serverDir, bin: 'prisma', args: resolveServerLightPrismaMigrateDeployArgs({ serverDir }), env });
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
+      if (looksLikeDatabaseLockedError(msg) && bestEffort) {
+        return { ok: false, migrated: true, accountCount: null, error: msg };
+      }
       // 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.
@@ -185,13 +198,27 @@ export async function ensureServerLightSchemaReady({ serverDir, env }) {
   } 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 };
+      try {
+        const accountCount = await probe();
+        return { ok: true, migrated: isUnified, accountCount };
+      } catch (e2) {
+        const msg = e2 instanceof Error ? e2.message : String(e2);
+        if (bestEffort && looksLikeDatabaseLockedError(msg)) {
+          return { ok: false, migrated: isUnified, accountCount: null, error: msg };
+        }
+        throw e2;
+      }
     }
     const msg = e instanceof Error ? e.message : String(e);
+    if (bestEffort && looksLikeDatabaseLockedError(msg)) {
+      return { ok: false, migrated: isUnified, accountCount: null, error: msg };
+    }
     if (looksLikeMissingTableError(msg)) {
       if (isUnified) {
-        // Tables still missing after migrate deploy; fail closed with a clear error.
+        // Tables still missing after migrate deploy (or probe without migrations); fail closed unless best-effort.
+        if (bestEffort) {
+          return { ok: false, migrated: true, accountCount: null, error: 'sqlite schema not ready (missing tables)' };
+        }
         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.
@@ -202,6 +229,9 @@ export async function ensureServerLightSchemaReady({ serverDir, env }) {
       // Legacy server-light: probing is best-effort (don't make stack dev fail closed here).
       return { ok: true, migrated: false, accountCount: 0 };
     }
+    if (bestEffort) {
+      return { ok: false, migrated: true, accountCount: null, error: msg };
+    }
     throw e;
   }
 }
@@ -226,8 +256,16 @@ export async function ensureHappyServerSchemaReady({ serverDir, env }) {
 
 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 };
+    try {
+      const ready = await ensureServerLightSchemaReady({ serverDir, env, bestEffort });
+      if (!ready?.ok) {
+        return { ok: false, accountCount: null, error: String(ready?.error ?? 'server-light schema probe failed') };
+      }
+      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) };
+    }
   }
   if (serverComponentName === 'happy-server') {
     try {

package/scripts/worktrees.mjs

@@ -26,6 +26,7 @@ import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
 import { ensureEnvLocalUpdated } from './utils/env/env_local.mjs';
 import { ensureEnvFilePruned, ensureEnvFileUpdated } from './utils/env/env_file.mjs';
 import { isSandboxed } from './utils/env/sandbox.mjs';
+import { applyStackCacheEnv } from './utils/proc/pm.mjs';
 import { existsSync } from 'node:fs';
 import { getHomeEnvLocalPath, getHomeEnvPath, resolveUserConfigEnvPath } from './utils/env/config.mjs';
 import { detectServerComponentDirMismatch } from './utils/server/validate.mjs';
@@ -417,6 +418,8 @@ async function installDependencies({ dir }) {
     return { installed: false, reason: 'no package manager detected (no package.json)' };
   }
 
+  const env = await applyStackCacheEnv(process.env);
+
   // IMPORTANT:
   // When a caller requests --json, stdout must be reserved for JSON output only.
   // Package managers (especially Yarn) write progress to stdout, which would corrupt JSON parsing
@@ -424,7 +427,7 @@ async function installDependencies({ dir }) {
   const jsonMode = Boolean((process.argv ?? []).includes('--json'));
   const runForJson = async (cmd, args) => {
     try {
-      const out = await runCapture(cmd, args, { cwd: dir });
+      const out = await runCapture(cmd, args, { cwd: dir, env });
       if (out) process.stderr.write(out);
     } catch (e) {
       const out = String(e?.out ?? '');
@@ -439,7 +442,7 @@ async function installDependencies({ dir }) {
     if (jsonMode) {
       await runForJson('pnpm', ['install', '--frozen-lockfile']);
     } else {
-      await run('pnpm', ['install', '--frozen-lockfile'], { cwd: dir });
+      await run('pnpm', ['install', '--frozen-lockfile'], { cwd: dir, env });
     }
     return { installed: true, reason: null };
   }
@@ -448,7 +451,7 @@ async function installDependencies({ dir }) {
     if (jsonMode) {
       await runForJson('yarn', ['install', '--frozen-lockfile']);
     } else {
-      await run('yarn', ['install', '--frozen-lockfile'], { cwd: dir });
+      await run('yarn', ['install', '--frozen-lockfile'], { cwd: dir, env });
     }
     return { installed: true, reason: null };
   }
@@ -457,13 +460,13 @@ async function installDependencies({ dir }) {
     if (jsonMode) {
       await runForJson('npm', ['ci']);
     } else {
-      await run('npm', ['ci'], { cwd: dir });
+      await run('npm', ['ci'], { cwd: dir, env });
     }
   } else {
     if (jsonMode) {
       await runForJson('npm', ['install']);
     } else {
-      await run('npm', ['install'], { cwd: dir });
+      await run('npm', ['install'], { cwd: dir, env });
     }
   }
   return { installed: true, reason: null };