@happier-dev/stack 0.1.0-preview.5.1

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

@@ -0,0 +1,117 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { chmod, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { run } from '../proc/proc.mjs';
+import { assertSafeRelativeRepoPath, getUncommittedOps } from './uncommitted_ops.mjs';
+
+function gitEnv() {
+  const clean = {};
+  for (const [k, v] of Object.entries(process.env)) {
+    if (k.startsWith('HAPPIER_STACK_')) continue;
+    clean[k] = v;
+  }
+  return {
+    ...clean,
+    GIT_AUTHOR_NAME: 'Test',
+    GIT_AUTHOR_EMAIL: 'test@example.com',
+    GIT_COMMITTER_NAME: 'Test',
+    GIT_COMMITTER_EMAIL: 'test@example.com',
+  };
+}
+
+test('getUncommittedOps includes modified, deleted, and untracked paths', async () => {
+  const repo = await mkdtemp(join(tmpdir(), 'happy-review-uncommitted-ops-'));
+  const env = gitEnv();
+  try {
+    await run('git', ['init', '-q'], { cwd: repo, env });
+    await run('git', ['checkout', '-q', '-b', 'main'], { cwd: repo, env });
+
+    await writeFile(join(repo, 'a.txt'), 'base-a\n', 'utf-8');
+    await writeFile(join(repo, 'b.txt'), 'base-b\n', 'utf-8');
+    await run('git', ['add', '.'], { cwd: repo, env });
+    await run('git', ['commit', '-q', '-m', 'chore: base'], { cwd: repo, env });
+
+    // Uncommitted changes: modify, delete, and add an untracked file.
+    await writeFile(join(repo, 'a.txt'), 'changed-a\n', 'utf-8');
+    await rm(join(repo, 'b.txt'));
+    await writeFile(join(repo, 'c.txt'), 'untracked-c\n', 'utf-8');
+
+    const ops = await getUncommittedOps({ cwd: repo, env });
+    assert.ok(ops.checkout.has('a.txt'));
+    assert.ok(ops.checkout.has('c.txt'));
+    assert.ok(ops.remove.has('b.txt'));
+    assert.equal(ops.all.size, 3);
+  } finally {
+    await rm(repo, { recursive: true, force: true });
+  }
+});
+
+test('getUncommittedOps handles repositories with no commits', async () => {
+  const repo = await mkdtemp(join(tmpdir(), 'happy-review-uncommitted-ops-empty-head-'));
+  const env = gitEnv();
+  try {
+    await run('git', ['init', '-q'], { cwd: repo, env });
+    await run('git', ['checkout', '-q', '-b', 'main'], { cwd: repo, env });
+
+    await writeFile(join(repo, 'first.txt'), 'hello\n', 'utf-8');
+
+    const ops = await getUncommittedOps({ cwd: repo, env });
+    assert.ok(ops.checkout.has('first.txt'));
+    assert.equal(ops.remove.size, 0);
+    assert.equal(ops.all.size, 1);
+  } finally {
+    await rm(repo, { recursive: true, force: true });
+  }
+});
+
+test('assertSafeRelativeRepoPath rejects traversal and absolute paths', () => {
+  assert.throws(() => assertSafeRelativeRepoPath('../outside'), /unsafe path/i);
+  assert.throws(() => assertSafeRelativeRepoPath('/etc/passwd'), /unsafe path/i);
+  assert.throws(() => assertSafeRelativeRepoPath('C:\\tmp\\x.txt'), /unsafe path/i);
+});
+
+test('assertSafeRelativeRepoPath allows normalized nested relative paths', () => {
+  assert.equal(assertSafeRelativeRepoPath('apps/cli/src/index.ts'), 'apps/cli/src/index.ts');
+  assert.equal(assertSafeRelativeRepoPath('./apps/cli/../cli/src/index.ts'), 'apps/cli/src/index.ts');
+});
+
+test('getUncommittedOps rejects absolute paths from git output', async (t) => {
+  if (process.platform === 'win32') {
+    t.skip('POSIX executable shim required for fake git binary');
+    return;
+  }
+
+  const tmp = await mkdtemp(join(tmpdir(), 'happy-review-uncommitted-ops-abs-'));
+  try {
+    const fakeGit = join(tmp, 'git');
+    await writeFile(
+      fakeGit,
+      [
+        '#!/usr/bin/env node',
+        'const args = process.argv.slice(2);',
+        "if (args[0] === 'diff') {",
+        "  process.stdout.write('M\\0/etc/passwd\\0');",
+        '  process.exit(0);',
+        '}',
+        "if (args[0] === 'ls-files') {",
+        '  process.exit(0);',
+        '}',
+        'process.exit(0);',
+        '',
+      ].join('\n'),
+      'utf-8'
+    );
+    await chmod(fakeGit, 0o755);
+
+    const env = {
+      ...process.env,
+      PATH: `${tmp}:${process.env.PATH ?? ''}`,
+    };
+    await assert.rejects(() => getUncommittedOps({ cwd: tmp, env }), /unsafe path/i);
+  } finally {
+    await rm(tmp, { recursive: true, force: true });
+  }
+});

package/scripts/utils/sandbox/review_pr_sandbox.mjs

@@ -0,0 +1,105 @@
+import { existsSync } from 'node:fs';
+import { readFile, readdir, stat, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { basename, join, resolve } from 'node:path';
+
+export const REVIEW_PR_MARKER_FILENAME = '.happier-stack-sandbox-marker';
+export const REVIEW_PR_META_FILENAME = '.happier-stack-review-pr.json';
+
+export function reviewPrSandboxPrefixBase(baseStackName) {
+  const base = String(baseStackName ?? '').trim() || 'pr';
+  // Keep prefix stable for listing/reuse; mkdtemp adds a random suffix.
+  return `hstack-review-pr-${base}-`;
+}
+
+export function reviewPrSandboxPrefixPath(baseStackName) {
+  return join(tmpdir(), reviewPrSandboxPrefixBase(baseStackName));
+}
+
+async function readJsonBestEffort(path) {
+  try {
+    const raw = await readFile(path, 'utf-8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+export async function listReviewPrSandboxes({ baseStackName }) {
+  const prefixBase = reviewPrSandboxPrefixBase(baseStackName);
+  const root = tmpdir();
+  let entries = [];
+  try {
+    entries = await readdir(root, { withFileTypes: true });
+  } catch {
+    entries = [];
+  }
+
+  const out = [];
+  for (const e of entries) {
+    if (!e.isDirectory()) continue;
+    if (!e.name.startsWith(prefixBase)) continue;
+    const dir = resolve(join(root, e.name));
+    const markerPath = join(dir, REVIEW_PR_MARKER_FILENAME);
+    if (!existsSync(markerPath)) continue;
+
+    let markerOk = false;
+    try {
+      const marker = await readFile(markerPath, 'utf-8');
+      markerOk = marker.trim().startsWith('review-pr');
+    } catch {
+      markerOk = false;
+    }
+    if (!markerOk) continue;
+
+    const metaPath = join(dir, REVIEW_PR_META_FILENAME);
+    const meta = await readJsonBestEffort(metaPath);
+
+    let mtimeMs = 0;
+    try {
+      mtimeMs = (await stat(dir)).mtimeMs;
+    } catch {
+      mtimeMs = 0;
+    }
+
+    out.push({
+      dir,
+      name: basename(dir),
+      markerPath,
+      metaPath,
+      baseStackName: String(meta?.baseStackName ?? '').trim() || String(baseStackName ?? '').trim() || null,
+      stackName: String(meta?.stackName ?? '').trim() || null,
+      createdAtMs: typeof meta?.createdAtMs === 'number' ? meta.createdAtMs : null,
+      lastTouchedAtMs: Number.isFinite(mtimeMs) ? mtimeMs : null,
+    });
+  }
+
+  out.sort((a, b) => (b.lastTouchedAtMs ?? 0) - (a.lastTouchedAtMs ?? 0));
+  return out;
+}
+
+export async function writeReviewPrSandboxMeta({ sandboxDir, baseStackName, stackName, argv }) {
+  const dir = resolve(String(sandboxDir ?? '').trim());
+  const markerPath = join(dir, REVIEW_PR_MARKER_FILENAME);
+  const metaPath = join(dir, REVIEW_PR_META_FILENAME);
+
+  // Marker (for safe deletion) + meta (for reuse menu).
+  await writeFile(markerPath, 'review-pr\n', 'utf-8');
+  await writeFile(
+    metaPath,
+    JSON.stringify(
+      {
+        kind: 'review-pr',
+        createdAtMs: Date.now(),
+        baseStackName: String(baseStackName ?? '').trim() || null,
+        stackName: String(stackName ?? '').trim() || null,
+        argv: Array.isArray(argv) ? argv : null,
+      },
+      null,
+      2
+    ) + '\n',
+    'utf-8'
+  );
+
+  return { markerPath, metaPath };
+}

package/scripts/utils/server/apply_server_light_env_defaults.mjs

@@ -0,0 +1,14 @@
+import { join } from 'node:path';
+
+export function applyServerLightEnvDefaults({ baseEnv, serverEnv, baseDir }) {
+  const dataDir = baseEnv.HAPPIER_SERVER_LIGHT_DATA_DIR?.trim()
+    ? baseEnv.HAPPIER_SERVER_LIGHT_DATA_DIR.trim()
+    : join(baseDir, 'server-light');
+  serverEnv.HAPPIER_SERVER_LIGHT_DATA_DIR = dataDir;
+  serverEnv.HAPPIER_SERVER_LIGHT_FILES_DIR = baseEnv.HAPPIER_SERVER_LIGHT_FILES_DIR?.trim()
+    ? baseEnv.HAPPIER_SERVER_LIGHT_FILES_DIR.trim()
+    : join(dataDir, 'files');
+  serverEnv.HAPPIER_SERVER_LIGHT_DB_DIR = baseEnv.HAPPIER_SERVER_LIGHT_DB_DIR?.trim()
+    ? baseEnv.HAPPIER_SERVER_LIGHT_DB_DIR.trim()
+    : join(dataDir, 'pglite');
+}

package/scripts/utils/server/flavor_scripts.mjs

@@ -0,0 +1,138 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+function readScripts(serverDir) {
+  try {
+    const pkgPath = join(serverDir, 'package.json');
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+    const scripts = pkg?.scripts && typeof pkg.scripts === 'object' ? pkg.scripts : {};
+    return scripts;
+  } catch {
+    return {};
+  }
+}
+
+function hasScript(scripts, name) {
+  return typeof scripts?.[name] === 'string' && scripts[name].trim().length > 0;
+}
+
+function detectServerLightDbFlavor({ serverDir }) {
+  const scripts = readScripts(serverDir);
+  if (hasScript(scripts, 'migrate:light:deploy')) {
+    // Current Happier "light" flavor uses embedded Postgres via PGlite.
+    return 'pglite';
+  }
+  // Legacy SQLite-era layouts (kept for old checkouts and potential future reintroduction).
+  if (existsSync(join(serverDir, 'prisma', 'sqlite', 'schema.prisma'))) return 'sqlite';
+  if (existsSync(join(serverDir, 'prisma', 'schema.sqlite.prisma'))) return 'sqlite';
+  return 'unknown';
+}
+
+export function isUnifiedHappyServerLight({ serverDir }) {
+  // "Unified" means the monorepo server package supports a first-class light flavor.
+  // Today that is PGlite-based.
+  return detectServerLightDbFlavor({ serverDir }) === 'pglite';
+}
+
+export function resolveServerLightPrismaSchemaArgs({ serverDir }) {
+  const flavor = detectServerLightDbFlavor({ serverDir });
+  if (flavor === 'pglite') {
+    // Light flavor uses the main Postgres schema.
+    return ['--schema', 'prisma/schema.prisma'];
+  }
+  if (flavor === 'sqlite') {
+    if (existsSync(join(serverDir, 'prisma', 'sqlite', 'schema.prisma'))) {
+      return ['--schema', 'prisma/sqlite/schema.prisma'];
+    }
+    if (existsSync(join(serverDir, 'prisma', 'schema.sqlite.prisma'))) {
+      return ['--schema', 'prisma/schema.sqlite.prisma'];
+    }
+  }
+  return [];
+}
+
+export function resolveServerLightPrismaMigrateDeployArgs({ serverDir }) {
+  return ['migrate', 'deploy', ...resolveServerLightPrismaSchemaArgs({ serverDir })];
+}
+
+export function resolveServerLightPrismaClientImport({ serverDir }) {
+  const flavor = detectServerLightDbFlavor({ serverDir });
+  if (flavor === 'pglite') {
+    // Light flavor uses the standard Postgres Prisma client (schema.prisma).
+    return '@prisma/client';
+  }
+  if (flavor === 'sqlite') {
+    const clientPath = join(serverDir, 'generated', 'sqlite-client', 'index.js');
+    return pathToFileURL(clientPath).href;
+  }
+  return '@prisma/client';
+}
+
+export function resolvePrismaClientImportForServerComponent({ serverComponentName, serverComponent, serverDir }) {
+  const name = serverComponentName ?? serverComponent;
+  if (name === 'happier-server-light') {
+    return resolveServerLightPrismaClientImport({ serverDir });
+  }
+  return '@prisma/client';
+}
+
+function resolveGeneratedClientEntrypoint({ serverDir, provider }) {
+  const p = String(provider ?? '').trim().toLowerCase();
+  if (p === 'sqlite') {
+    return join(serverDir, 'generated', 'sqlite-client', 'index.js');
+  }
+  if (p === 'mysql') {
+    return join(serverDir, 'generated', 'mysql-client', 'index.js');
+  }
+  return '';
+}
+
+export function resolvePrismaClientImportForDbProvider({ serverDir, provider }) {
+  const entry = resolveGeneratedClientEntrypoint({ serverDir, provider });
+  if (entry && existsSync(entry)) {
+    return pathToFileURL(entry).href;
+  }
+  // postgres + pglite share the default Prisma client.
+  return '@prisma/client';
+}
+
+export function resolveServerDevScript({ serverComponentName, serverDir, prismaPush }) {
+  const scripts = readScripts(serverDir);
+
+  if (serverComponentName === 'happier-server') {
+    return 'start';
+  }
+
+  if (serverComponentName === 'happier-server-light') {
+    // Prefer the dedicated dev script that ensures migrations are applied before starting.
+    if (hasScript(scripts, 'dev:light')) {
+      return 'dev:light';
+    }
+    // Fallback: no dev script, run the light start script.
+    if (hasScript(scripts, 'start:light')) {
+      return 'start:light';
+    }
+
+    // Legacy behavior: prefer `dev` for older server-light checkouts.
+    if (prismaPush) {
+      return hasScript(scripts, 'dev') ? 'dev' : 'start';
+    }
+    return hasScript(scripts, 'start') ? 'start' : 'dev';
+  }
+
+  // Unknown: be conservative.
+  return 'start';
+}
+
+export function resolveServerStartScript({ serverComponentName, serverDir }) {
+  const scripts = readScripts(serverDir);
+
+  if (serverComponentName === 'happier-server-light') {
+    if (hasScript(scripts, 'start:light')) {
+      return 'start:light';
+    }
+  }
+
+  return 'start';
+}

package/scripts/utils/server/flavor_scripts.test.mjs

@@ -0,0 +1,115 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import {
+  resolvePrismaClientImportForServerComponent,
+  resolveServerDevScript,
+  resolveServerLightPrismaClientImport,
+  resolveServerLightPrismaMigrateDeployArgs,
+  resolveServerStartScript,
+} from './flavor_scripts.mjs';
+
+async function writeJson(path, obj) {
+  await writeFile(path, JSON.stringify(obj, null, 2) + '\n', 'utf-8');
+}
+
+async function withServerDir(run) {
+  const dir = await mkdtemp(join(tmpdir(), 'hs-flavor-scripts-'));
+  try {
+    await run(dir);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+
+async function writeServerScriptsPackageJson(dir, scripts) {
+  await writeJson(join(dir, 'package.json'), { scripts });
+}
+
+test('resolveServer*Script uses light scripts when unified light flavor is detected', async () => {
+  await withServerDir(async (dir) => {
+    await writeServerScriptsPackageJson(dir, {
+      'start:light': 'node x',
+      'dev:light': 'node y',
+      'migrate:light:deploy': 'node z',
+    });
+    assert.equal(resolveServerDevScript({ serverComponentName: 'happier-server-light', serverDir: dir, prismaPush: true }), 'dev:light');
+    assert.equal(resolveServerDevScript({ serverComponentName: 'happier-server-light', serverDir: dir, prismaPush: false }), 'dev:light');
+    assert.equal(resolveServerStartScript({ serverComponentName: 'happier-server-light', serverDir: dir }), 'start:light');
+  });
+});
+
+test('resolveServer*Script falls back to legacy scripts for non-unified happier-server-light', async () => {
+  await withServerDir(async (dir) => {
+    await writeServerScriptsPackageJson(dir, { start: 'node start', dev: 'node dev' });
+    assert.equal(resolveServerDevScript({ serverComponentName: 'happier-server-light', serverDir: dir, prismaPush: true }), 'dev');
+    assert.equal(resolveServerDevScript({ serverComponentName: 'happier-server-light', serverDir: dir, prismaPush: false }), 'start');
+    assert.equal(resolveServerStartScript({ serverComponentName: 'happier-server-light', serverDir: dir }), 'start');
+  });
+});
+
+test('resolveServer*Script returns start for happier-server', async () => {
+  await withServerDir(async (dir) => {
+    await writeServerScriptsPackageJson(dir, { start: 'node start', dev: 'node dev' });
+    assert.equal(resolveServerDevScript({ serverComponentName: 'happier-server', serverDir: dir, prismaPush: true }), 'start');
+    assert.equal(resolveServerDevScript({ serverComponentName: 'happier-server', serverDir: dir, prismaPush: false }), 'start');
+    assert.equal(resolveServerStartScript({ serverComponentName: 'happier-server', serverDir: dir }), 'start');
+  });
+});
+
+test('resolveServerLightPrismaMigrateDeployArgs adds --schema when unified light flavor is detected', async () => {
+  await withServerDir(async (dir) => {
+    await writeServerScriptsPackageJson(dir, { 'migrate:light:deploy': 'node z' });
+    assert.deepEqual(resolveServerLightPrismaMigrateDeployArgs({ serverDir: dir }), ['migrate', 'deploy', '--schema', 'prisma/schema.prisma']);
+  });
+});
+
+test('resolveServerLightPrismaMigrateDeployArgs supports legacy schema.sqlite.prisma', async () => {
+  await withServerDir(async (dir) => {
+    await mkdir(join(dir, 'prisma'), { recursive: true });
+    await writeFile(join(dir, 'prisma', 'schema.sqlite.prisma'), 'datasource db { provider = "sqlite" }\n', 'utf-8');
+
+    assert.deepEqual(resolveServerLightPrismaMigrateDeployArgs({ serverDir: dir }), ['migrate', 'deploy', '--schema', 'prisma/schema.sqlite.prisma']);
+  });
+});
+
+test('resolveServerLightPrismaClientImport returns @prisma/client for pglite light flavor', async () => {
+  await withServerDir(async (dir) => {
+    await writeServerScriptsPackageJson(dir, { 'migrate:light:deploy': 'node z' });
+    assert.equal(resolveServerLightPrismaClientImport({ serverDir: dir }), '@prisma/client');
+  });
+});
+
+test('resolveServerLightPrismaClientImport returns file URL for sqlite light flavor (legacy)', async () => {
+  await withServerDir(async (dir) => {
+    await mkdir(join(dir, 'prisma', 'sqlite'), { recursive: true });
+    await writeFile(join(dir, 'prisma', 'sqlite', 'schema.prisma'), 'datasource db { provider = "sqlite" }\n', 'utf-8');
+    const spec = resolveServerLightPrismaClientImport({ serverDir: dir });
+    assert.equal(typeof spec, 'string');
+    assert.ok(spec.startsWith('file:'), `expected file: URL import spec, got: ${spec}`);
+    assert.ok(spec.endsWith('/generated/sqlite-client/index.js'), `unexpected import spec: ${spec}`);
+  });
+});
+
+test('resolvePrismaClientImportForServerComponent returns @prisma/client for pglite server-light', async () => {
+  await withServerDir(async (dir) => {
+    await writeServerScriptsPackageJson(dir, { 'migrate:light:deploy': 'node z' });
+    assert.equal(resolvePrismaClientImportForServerComponent({ serverComponentName: 'happier-server-light', serverDir: dir }), '@prisma/client');
+  });
+});
+
+test('resolvePrismaClientImportForServerComponent accepts serverComponent alias (back-compat)', async () => {
+  await withServerDir(async (dir) => {
+    await writeServerScriptsPackageJson(dir, { 'migrate:light:deploy': 'node z' });
+    assert.equal(resolvePrismaClientImportForServerComponent({ serverComponent: 'happier-server-light', serverDir: dir }), '@prisma/client');
+  });
+});
+
+test('resolvePrismaClientImportForServerComponent returns @prisma/client for happier-server', async () => {
+  await withServerDir(async (dir) => {
+    assert.equal(resolvePrismaClientImportForServerComponent({ serverComponentName: 'happier-server', serverDir: dir }), '@prisma/client');
+  });
+});