happy-stacks 0.4.0 → 0.5.0

package/scripts/utils/stack/startup.mjs

@@ -3,17 +3,51 @@ 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 }));
@@ -90,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);
@@ -119,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/tailscale/ip.mjs

@@ -0,0 +1,116 @@
+/**
+ * Tailscale IP detection utilities.
+ *
+ * Provides functions to detect the local Tailscale IPv4 address for port forwarding.
+ */
+
+import { runCaptureResult } from '../proc/proc.mjs';
+import { resolveCommandPath } from '../proc/commands.mjs';
+import { access, constants } from 'node:fs/promises';
+
+const TAILSCALE_TIMEOUT_MS = 3000;
+
+/**
+ * Check if a path is executable.
+ */
+async function isExecutable(path) {
+  try {
+    await access(path, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Tailscale env: strip XPC_SERVICE_NAME which can cause hangs in LaunchAgent contexts.
+ */
+function tailscaleEnv() {
+  const env = { ...process.env };
+  delete env.XPC_SERVICE_NAME;
+  return env;
+}
+
+/**
+ * Resolve the tailscale CLI path.
+ *
+ * Priority:
+ * 1. HAPPY_LOCAL_TAILSCALE_BIN env override
+ * 2. PATH lookup
+ * 3. macOS app bundle paths
+ */
+export async function resolveTailscaleCmd() {
+  // Explicit override
+  if (process.env.HAPPY_LOCAL_TAILSCALE_BIN?.trim()) {
+    return process.env.HAPPY_LOCAL_TAILSCALE_BIN.trim();
+  }
+
+  // Try PATH first
+  try {
+    const found = await resolveCommandPath('tailscale', { env: tailscaleEnv(), timeoutMs: TAILSCALE_TIMEOUT_MS });
+    if (found) return found;
+  } catch {
+    // ignore
+  }
+
+  // macOS app bundle paths
+  const appCliPath = '/Applications/Tailscale.app/Contents/MacOS/tailscale';
+  if (await isExecutable(appCliPath)) return appCliPath;
+
+  const appPath = '/Applications/Tailscale.app/Contents/MacOS/Tailscale';
+  if (await isExecutable(appPath)) return appPath;
+
+  return null;
+}
+
+/**
+ * Get the local Tailscale IPv4 address.
+ *
+ * @returns {Promise<string | null>} The Tailscale IPv4 address, or null if unavailable.
+ */
+export async function getTailscaleIpv4() {
+  const cmd = await resolveTailscaleCmd();
+  if (!cmd) return null;
+
+  const result = await runCaptureResult(cmd, ['ip', '-4'], {
+    env: tailscaleEnv(),
+    timeoutMs: TAILSCALE_TIMEOUT_MS,
+  });
+
+  if (!result.ok) return null;
+
+  const ip = result.out.trim().split('\n')[0]?.trim();
+  // Validate IPv4 format (basic check)
+  if (!ip || !/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(ip)) return null;
+
+  return ip;
+}
+
+/**
+ * Check if Tailscale is available and connected.
+ *
+ * @returns {Promise<boolean>}
+ */
+export async function isTailscaleAvailable() {
+  const ip = await getTailscaleIpv4();
+  return Boolean(ip);
+}
+
+/**
+ * Get Tailscale status information.
+ *
+ * @returns {Promise<{ available: boolean, ip: string | null, error: string | null }>}
+ */
+export async function getTailscaleStatus() {
+  const cmd = await resolveTailscaleCmd();
+  if (!cmd) {
+    return { available: false, ip: null, error: 'tailscale CLI not found' };
+  }
+
+  const ip = await getTailscaleIpv4();
+  if (!ip) {
+    return { available: false, ip: null, error: 'tailscale not connected or no IPv4 address' };
+  }
+
+  return { available: true, ip, error: null };
+}

package/scripts/utils/ui/ansi.mjs

@@ -0,0 +1,39 @@
+function supportsAnsi() {
+  if (!process.stdout.isTTY) return false;
+  if (process.env.NO_COLOR) return false;
+  if ((process.env.TERM ?? '').toLowerCase() === 'dumb') return false;
+  return true;
+}
+
+function wrap(code, s) {
+  return supportsAnsi() ? `\x1b[${code}m${s}\x1b[0m` : String(s);
+}
+
+export function ansiEnabled() {
+  return supportsAnsi();
+}
+
+export function bold(s) {
+  return wrap('1', s);
+}
+
+export function dim(s) {
+  return wrap('2', s);
+}
+
+export function red(s) {
+  return wrap('31', s);
+}
+
+export function green(s) {
+  return wrap('32', s);
+}
+
+export function yellow(s) {
+  return wrap('33', s);
+}
+
+export function cyan(s) {
+  return wrap('36', s);
+}
+

package/scripts/where.mjs

@@ -26,8 +26,8 @@ async function main() {
   if (wantsHelp(argv, { flags }) || argv.includes('help')) {
     printResult({
       json,
-      data: { flags: ['--json'], commands: ['where', 'env'] },
-      text: ['[where] usage:', '  happys where [--json]', '  happys env [--json]'].join('\n'),
+      data: { flags: ['--json'], commands: ['where'] },
+      text: ['[where] usage:', '  happys where [--json]'].join('\n'),
     });
     return;
   }