glashjs 0.12.0 → 0.13.0

package/src/config.mjs

@@ -19,6 +19,8 @@ export const DEFAULT_CONFIG = {
   publicDir: 'public',
   // File-based routes (pages + api/) served by `glash dev` / `glash serve`.
   routesDir: 'routes',
+  // Global stylesheets injected into every rendered document.
+  stylesheets: [],
   port: 3000,
   outDir: '.glash/out',
   themeColor: '#0b0d12',

package/src/create.mjs

@@ -0,0 +1,593 @@
+// glashjs create
+// ---------------------------------------------------------------------------
+// Interactive project scaffolder for the GlashDB-native full-stack framework.
+
+import { spawn } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import { createInterface } from 'node:readline/promises';
+import path from 'node:path';
+import { generateTypedRoutes } from './typed-routes.mjs';
+
+const CSS_CHOICES = new Set(['tailwind', 'plain', 'none']);
+const PM_CHOICES = new Set(['npm', 'pnpm', 'yarn', 'bun']);
+
+export async function createProject(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const interactive = options.interactive ?? (process.stdin.isTTY && process.stdout.isTTY && !options.yes);
+  const rl = interactive ? createInterface({ input: process.stdin, output: process.stdout }) : null;
+  try {
+    const answers = await collectAnswers(options, rl);
+    const target = path.resolve(cwd, answers.directory);
+    await assertWritableTarget(target, answers.force);
+    await fs.mkdir(target, { recursive: true });
+    await writeProject(target, answers);
+    await generateTypedRoutes({ root: target, log: () => undefined });
+
+    if (answers.install) await installDependencies(target, answers.packageManager);
+    if (answers.git) await initGit(target);
+
+    printNextSteps(target, answers, options.log ?? console.log);
+    return { target, answers };
+  } finally {
+    rl?.close();
+  }
+}
+
+async function collectAnswers(options, rl) {
+  const name = slugify(options.name || await ask(rl, 'Project name', 'glash-app'));
+  const css = normalizeChoice(options.css || await ask(rl, 'CSS setup (tailwind/plain/none)', 'tailwind'), CSS_CHOICES, 'tailwind');
+  const postgres = boolAnswer(options.postgres, await ask(rl, 'Use Postgres by default?', 'yes'));
+  const auth = boolAnswer(options.auth, await ask(rl, 'Add glashAuth routes?', 'yes'));
+  const sqlRunner = boolAnswer(options.sqlRunner, await ask(rl, 'Add SQL runner support?', 'yes'));
+  const aiPrompts = boolAnswer(options.aiPrompts, await ask(rl, 'Add AI deployment prompts?', 'yes'));
+  const install = boolAnswer(options.install, await ask(rl, 'Install dependencies now?', 'yes'));
+  const packageManager = normalizeChoice(options.packageManager || await ask(rl, 'Package manager (npm/pnpm/yarn/bun)', detectPackageManager()), PM_CHOICES, 'npm');
+  const git = boolAnswer(options.git, await ask(rl, 'Initialize git?', 'yes'));
+
+  return {
+    name,
+    directory: options.directory || name,
+    css,
+    postgres,
+    auth,
+    sqlRunner,
+    aiPrompts,
+    install,
+    packageManager,
+    git,
+    force: !!options.force,
+  };
+}
+
+async function writeProject(root, answers) {
+  const files = projectFiles(answers);
+  for (const [file, contents] of Object.entries(files)) await writeFile(root, file, contents);
+}
+
+function projectFiles(answers) {
+  const hasCss = answers.css !== 'none';
+  const cssBuild = 'tailwindcss -i ./styles/input.css -o ./public/app.css';
+  const scripts = {
+    dev: answers.css === 'tailwind' ? `${cssBuild} && glashjs dev` : 'glashjs dev',
+    build: answers.css === 'tailwind' ? `glashjs typegen && ${cssBuild} && glashjs build` : 'glashjs typegen && glashjs build',
+    start: 'glashjs serve',
+    deploy: 'glashjs deploy',
+    typegen: 'glashjs typegen',
+  };
+  if (answers.css === 'tailwind') scripts['css:build'] = cssBuild;
+  if (answers.sqlRunner) scripts.sql = 'glashjs sql db/schema.sql';
+
+  const dependencies = {
+    glashjs: 'latest',
+    esbuild: '^0.28.0',
+    pg: '^8.16.3',
+    preact: '^10.29.2',
+    'preact-render-to-string': '^6.7.0',
+  };
+  const devDependencies = answers.css === 'tailwind'
+    ? { tailwindcss: '^4.1.0', '@tailwindcss/cli': '^4.1.0' }
+    : {};
+
+  return {
+    'package.json': json({
+      name: answers.name,
+      version: '0.1.0',
+      private: true,
+      type: 'module',
+      scripts,
+      dependencies,
+      ...(Object.keys(devDependencies).length ? { devDependencies } : {}),
+    }),
+    '.gitignore': gitignore(),
+    '.env.example': envExample(answers),
+    '.env.local': envLocal(answers),
+    'glash.config.mjs': configFile(answers, hasCss),
+    'README.md': projectReadme(answers),
+    'routes/_layout.jsx': layoutRoute(),
+    'routes/index.jsx': indexRoute(answers),
+    'routes/api/health.mjs': healthRoute(),
+    'db/schema.sql': schemaSql(answers),
+    ...(hasCss ? { 'public/app.css': appCss(answers.css) } : {}),
+    ...(answers.css === 'tailwind' ? { 'styles/input.css': tailwindInput() } : {}),
+    ...(answers.auth ? authRoutes() : {}),
+    ...(answers.sqlRunner ? sqlRunnerRoutes() : {}),
+    ...(answers.aiPrompts ? { '.glash/prompts/deploy.md': aiDeployPrompt(answers) } : {}),
+    'public/favicon.svg': faviconSvg(),
+  };
+}
+
+function configFile(answers, hasCss) {
+  return `import { defineConfig } from 'glashjs/config';
+
+export default defineConfig({
+  name: '${titleCase(answers.name)}',
+  shortName: '${answers.name}',
+  routesDir: 'routes',
+  publicDir: 'public',
+  outDir: '.glash/out',
+  offline: true,
+  animatedFavicon: true,
+  stylesheets: ${hasCss ? "['/app.css']" : '[]'},
+  dataPrefixes: ['/api/', '/auth/', '/rest/', '/live', '/stream'],
+  security: {
+    csp: {
+      connectSrc: ["'self'", 'https://api.glashdb.com'],
+    },
+  },
+});
+`;
+}
+
+function layoutRoute() {
+  return `import { Link } from 'glashjs/link';
+
+export default function RootLayout({ children }) {
+  return (
+    <div className="shell">
+      <header className="nav">
+        <Link href="/" className="brand">glashjs</Link>
+        <nav>
+          <Link href="/api/health">API</Link>
+          <Link href="/api/auth/me">Auth</Link>
+        </nav>
+      </header>
+      {children}
+    </div>
+  );
+}
+`;
+}
+
+function indexRoute(answers) {
+  return `import { useState } from 'preact/hooks';
+import { callServerFunction } from 'glashjs/server-functions';
+
+export const metadata = {
+  title: '${titleCase(answers.name)}',
+  description: 'A GlashDB-native full-stack app with framework, hosting, Postgres, auth, and deploy.',
+};
+
+export function getServerData() {
+  return {
+    features: [
+      'File-based routing',
+      'Typed routes',
+      'Server functions',
+      'API routes',
+      'Postgres by default',
+      'glashAuth built in',
+      'SQL runner support',
+      'AI deployment prompts',
+      'Zero-config hosting',
+      'Automatic env management',
+      'One-command deployment',
+    ],
+  };
+}
+
+export default function Home({ features = [] }) {
+  const [email, setEmail] = useState('');
+  const [message, setMessage] = useState('');
+
+  async function sendDemo() {
+    try {
+      const result = await callServerFunction('/api/functions/contact', { email });
+      setMessage(result.message);
+    } catch (error) {
+      setMessage(error.message);
+    }
+  }
+
+  return (
+    <main className="hero">
+      <p className="eyebrow">GlashDB native</p>
+      <h1>The Postgres-native full-stack framework for builders who want to ship without DevOps.</h1>
+      <p className="lede">
+        Framework + Hosting + Database + Auth + Deploy in one project. Start local, add real env vars, then ship with one command.
+      </p>
+
+      <section className="panel">
+        <div>
+          <h2>Server function demo</h2>
+          <p>Calls a file-based API route that runs only on the server.</p>
+        </div>
+        <div className="form">
+          <input value={email} onInput={(event) => setEmail(event.currentTarget.value)} placeholder="you@example.com" />
+          <button type="button" onClick={sendDemo}>Ping server</button>
+        </div>
+        {message ? <p className="result">{message}</p> : null}
+      </section>
+
+      <ul className="features">
+        {features.map((feature) => <li key={feature}>{feature}</li>)}
+      </ul>
+    </main>
+  );
+}
+`;
+}
+
+function healthRoute() {
+  return `import { json } from 'glashjs';
+import { optionalEnv } from 'glashjs/env';
+
+export const GET = () => json({
+  ok: true,
+  framework: 'glashjs',
+  database: optionalEnv('DATABASE_URL') ? 'configured' : 'not configured',
+  auth: optionalEnv('GLASHDB_ANON_KEY') ? 'configured' : 'not configured',
+});
+`;
+}
+
+function authRoutes() {
+  return {
+    'routes/api/auth/signup.mjs': `import { json } from 'glashjs';
+import { glashAuth, sessionCookie } from 'glashjs/auth';
+
+export const POST = async (ctx) => {
+  const auth = glashAuth();
+  const session = await auth.signup(ctx.body);
+  return json(session, { headers: { 'set-cookie': sessionCookie(session) } });
+};
+`,
+    'routes/api/auth/signin.mjs': `import { json } from 'glashjs';
+import { glashAuth, sessionCookie } from 'glashjs/auth';
+
+export const POST = async (ctx) => {
+  const auth = glashAuth();
+  const session = await auth.signin(ctx.body);
+  return json(session, { headers: { 'set-cookie': sessionCookie(session) } });
+};
+`,
+    'routes/api/auth/me.mjs': `import { json } from 'glashjs';
+import { glashAuth, readSessionCookie } from 'glashjs/auth';
+
+export const GET = async (ctx) => {
+  const session = readSessionCookie(ctx);
+  if (!session?.accessToken) return json({ user: null }, { status: 401 });
+  const user = await glashAuth().me(session.accessToken);
+  return json({ user });
+};
+`,
+  };
+}
+
+function sqlRunnerRoutes() {
+  return {
+    'routes/api/functions/contact.mjs': `import { serverFunction } from 'glashjs/server-functions';
+import { sql } from 'glashjs/postgres';
+
+export const POST = serverFunction(async ({ email }) => {
+  const value = String(email || '').trim();
+  if (!value.includes('@')) return { message: 'Add an email to test the server function.' };
+  await sql\`
+    insert into contacts (email)
+    values (\${value})
+    on conflict (email) do update set updated_at = now()
+  \`;
+  return { message: \`Saved \${value} in Postgres.\` };
+});
+`,
+    'routes/api/sql/run.mjs': `import { json } from 'glashjs';
+import { query } from 'glashjs/postgres';
+
+export const POST = async (ctx) => {
+  const expected = process.env.GLASH_SQL_RUNNER_TOKEN;
+  const token = String(ctx.headers.authorization || '').replace(/^Bearer\\s+/i, '');
+  if (!expected || token !== expected) return json({ error: 'SQL runner token required' }, { status: 401 });
+  const statement = String(ctx.body?.statement || '');
+  const params = Array.isArray(ctx.body?.params) ? ctx.body.params : [];
+  if (!statement.trim()) return json({ error: 'statement is required' }, { status: 400 });
+  const result = await query(statement, params);
+  return json({ rowCount: result.rowCount, rows: result.rows });
+};
+`,
+  };
+}
+
+function schemaSql() {
+  return `create table if not exists contacts (
+  id bigserial primary key,
+  email text unique not null,
+  created_at timestamptz not null default now(),
+  updated_at timestamptz not null default now()
+);
+`;
+}
+
+function envExample(answers) {
+  return `# GlashDB fills these during hosted deploys. Keep local values in .env.local.
+GLASHDB_API_URL="https://api.glashdb.com/api"
+GLASHDB_PROJECT_ID=""
+DATABASE_URL="postgresql://user:password@localhost:5432/${answers.name}?sslmode=disable"
+DIRECT_URL=""
+GLASHDB_ANON_KEY=""
+GLASH_SQL_RUNNER_TOKEN="${randomToken()}"
+`;
+}
+
+function envLocal(answers) {
+  return `# Local development only. Do not commit real secrets.
+GLASHDB_API_URL="https://api.glashdb.com/api"
+GLASHDB_PROJECT_ID=""
+DATABASE_URL="postgresql://user:password@localhost:5432/${answers.name}?sslmode=disable"
+DIRECT_URL=""
+GLASHDB_ANON_KEY=""
+GLASH_SQL_RUNNER_TOKEN="${randomToken()}"
+`;
+}
+
+function projectReadme(answers) {
+  const install = answers.install ? 'Dependencies were installed during create.' : `Install dependencies first:\n\n\`\`\`bash\n${answers.packageManager} install\n\`\`\``;
+  return `# ${titleCase(answers.name)}
+
+Built with glashjs: The Postgres-native full-stack framework for builders who want to ship without DevOps.
+
+${install}
+
+## Run locally
+
+\`\`\`bash
+${answers.packageManager} run dev
+\`\`\`
+
+## Useful commands
+
+\`\`\`bash
+${answers.packageManager} run typegen   # typed file-based routes
+${answers.packageManager} run build     # production build
+${answers.packageManager} run start     # serve the built app
+${answers.packageManager} run deploy    # one-command deployment to GlashDB
+${answers.sqlRunner ? `${answers.packageManager} run sql        # run db/schema.sql against DATABASE_URL` : ''}
+\`\`\`
+
+## First-class features in this starter
+
+- File-based routing in \`routes/\`.
+- Typed routes through \`glashjs typegen\`.
+- Server functions under \`routes/api/functions/\`.
+- API routes under \`routes/api/\`.
+- Postgres by default through \`glashjs/postgres\`.
+- glashAuth helpers through \`glashjs/auth\`.
+- SQL runner support through \`glashjs sql\`.
+- AI deployment prompts in \`.glash/prompts/\`.
+- Zero-config hosting with \`glashjs deploy\`.
+- Automatic env management with GlashDB project variables.
+- One-command deployment.
+
+Set real values in \`.env.local\` for local work, then use GlashDB env management for production.
+`;
+}
+
+function aiDeployPrompt(answers) {
+  return `# GlashDB deployment prompt
+
+You are preparing a glashjs app for deployment.
+
+Project: ${answers.name}
+Stack: framework + hosting + Postgres + glashAuth + deploy
+
+Before deployment:
+- Confirm \`npm run build\` passes.
+- Confirm \`DATABASE_URL\`, \`GLASHDB_PROJECT_ID\`, and \`GLASHDB_ANON_KEY\` are set when the app uses database/auth.
+- Keep \`public/\` assets deploy-safe. Use \`glash deploy --asset-mode auto\` for large media.
+- Prefer one command: \`npm run deploy\`.
+
+When logs fail, explain the failing route, env var, SQL statement, or package install step before changing code.
+`;
+}
+
+function appCss(css) {
+  if (css === 'tailwind') {
+    return `@layer base {
+  :root { color-scheme: dark; }
+}
+`;
+  }
+  return `:root {
+  color-scheme: dark;
+  font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+  background: #050505;
+  color: #f5f5f5;
+}
+
+* { box-sizing: border-box; }
+body { margin: 0; min-height: 100vh; background: #050505; }
+a { color: inherit; text-decoration: none; }
+
+.shell { min-height: 100vh; max-width: 1120px; margin: 0 auto; padding: 24px; }
+.nav { height: 56px; display: flex; align-items: center; justify-content: space-between; gap: 16px; border-bottom: 1px solid #262626; }
+.brand { font-weight: 700; }
+.nav nav { display: flex; gap: 14px; color: #a3a3a3; font-size: 14px; }
+.hero { padding: 72px 0; }
+.eyebrow { color: #f97316; text-transform: uppercase; letter-spacing: .18em; font-size: 12px; }
+h1 { max-width: 900px; font-size: clamp(42px, 7vw, 88px); line-height: 1.02; letter-spacing: 0; margin: 14px 0; }
+.lede { color: #b5b5b5; max-width: 720px; font-size: 18px; line-height: 1.65; }
+.panel { margin-top: 34px; border: 1px solid #262626; border-radius: 8px; padding: 22px; display: grid; gap: 16px; background: #0a0a0a; }
+.panel h2 { margin: 0 0 6px; }
+.panel p { margin: 0; color: #a3a3a3; }
+.form { display: flex; flex-wrap: wrap; gap: 10px; }
+input, button { min-height: 42px; border-radius: 6px; border: 1px solid #333; background: #111; color: #fff; padding: 0 12px; font: inherit; }
+button { background: #f97316; border-color: #f97316; color: #111; font-weight: 700; cursor: pointer; }
+.result { color: #fff !important; }
+.features { margin: 28px 0 0; padding: 0; display: grid; grid-template-columns: repeat(auto-fit, minmax(210px, 1fr)); gap: 10px; list-style: none; }
+.features li { border: 1px solid #262626; border-radius: 8px; padding: 14px; background: #0a0a0a; color: #d4d4d4; }
+`;
+}
+
+function tailwindInput() {
+  return `@import "tailwindcss";
+
+@source "../routes/**/*.{js,jsx,mjs,ts,tsx}";
+
+@layer base {
+  :root {
+    color-scheme: dark;
+    font-family: Inter, ui-sans-serif, system-ui, sans-serif;
+    background: #050505;
+    color: #f5f5f5;
+  }
+  body { margin: 0; min-height: 100vh; background: #050505; }
+}
+
+@layer components {
+  .shell { @apply min-h-screen mx-auto max-w-6xl px-6 py-6; }
+  .nav { @apply flex h-14 items-center justify-between gap-4 border-b border-neutral-800; }
+  .brand { @apply font-bold text-white; }
+  .nav nav { @apply flex gap-4 text-sm text-neutral-400; }
+  .hero { @apply py-20; }
+  .eyebrow { @apply text-xs uppercase tracking-[0.18em] text-orange-500; }
+  h1 { @apply mt-3 max-w-5xl text-5xl font-semibold leading-none text-white md:text-7xl; }
+  .lede { @apply mt-5 max-w-3xl text-lg leading-8 text-neutral-400; }
+  .panel { @apply mt-9 grid gap-4 rounded-lg border border-neutral-800 bg-neutral-950 p-6; }
+  .panel h2 { @apply text-xl font-semibold text-white; }
+  .panel p { @apply text-neutral-400; }
+  .form { @apply flex flex-wrap gap-3; }
+  input { @apply min-h-11 rounded-md border border-neutral-700 bg-neutral-900 px-3 text-white; }
+  button { @apply min-h-11 rounded-md bg-orange-500 px-4 font-bold text-neutral-950; }
+  .result { @apply text-white; }
+  .features { @apply mt-7 grid list-none gap-3 p-0 sm:grid-cols-2 lg:grid-cols-3; }
+  .features li { @apply rounded-lg border border-neutral-800 bg-neutral-950 p-4 text-neutral-300; }
+}
+`;
+}
+
+function faviconSvg() {
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
+  <rect width="64" height="64" rx="14" fill="#050505"/>
+  <circle cx="32" cy="32" r="17" fill="#f97316"/>
+  <circle cx="32" cy="32" r="7" fill="#050505"/>
+</svg>
+`;
+}
+
+function gitignore() {
+  return `node_modules
+.env
+.env.local
+.glash/out
+.DS_Store
+npm-debug.log*
+pnpm-debug.log*
+yarn-debug.log*
+`;
+}
+
+async function ask(rl, question, fallback) {
+  if (!rl) return fallback;
+  const answer = await rl.question(`${question} (${fallback}): `);
+  return answer.trim() || fallback;
+}
+
+function boolAnswer(value, fallback) {
+  if (typeof value === 'boolean') return value;
+  const raw = String(value ?? fallback ?? 'yes').trim().toLowerCase();
+  return ['y', 'yes', 'true', '1', 'on'].includes(raw);
+}
+
+function normalizeChoice(value, choices, fallback) {
+  const raw = String(value || '').trim().toLowerCase();
+  return choices.has(raw) ? raw : fallback;
+}
+
+function detectPackageManager() {
+  const userAgent = process.env.npm_config_user_agent || '';
+  if (userAgent.startsWith('pnpm')) return 'pnpm';
+  if (userAgent.startsWith('yarn')) return 'yarn';
+  if (userAgent.startsWith('bun')) return 'bun';
+  return 'npm';
+}
+
+async function assertWritableTarget(target, force) {
+  try {
+    const entries = await fs.readdir(target);
+    const meaningful = entries.filter((name) => !['.DS_Store'].includes(name));
+    if (meaningful.length && !force) {
+      throw new Error(`Target directory is not empty: ${target}. Use --force to write into it.`);
+    }
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+  }
+}
+
+async function writeFile(root, file, contents) {
+  const target = path.join(root, file);
+  await fs.mkdir(path.dirname(target), { recursive: true });
+  await fs.writeFile(target, contents);
+}
+
+async function installDependencies(root, packageManager) {
+  const args = packageManager === 'npm' ? ['install']
+    : packageManager === 'pnpm' ? ['install']
+      : packageManager === 'yarn' ? ['install']
+        : ['install'];
+  await run(packageManager, args, root);
+}
+
+async function initGit(root) {
+  try { await run('git', ['init'], root, { silent: true }); } catch {}
+}
+
+function run(cmd, args, cwd, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, { cwd, stdio: options.silent ? 'ignore' : 'inherit' });
+    child.on('error', reject);
+    child.on('exit', (code) => (code === 0 ? resolve() : reject(new Error(`${cmd} ${args.join(' ')} exited with code ${code}`))));
+  });
+}
+
+function printNextSteps(target, answers, log) {
+  const rel = path.relative(process.cwd(), target) || '.';
+  log(`\nCreated glashjs project in ${rel}`);
+  log('\nNext steps:');
+  log(`  cd ${shellQuote(rel)}`);
+  if (!answers.install) log(`  ${answers.packageManager} install`);
+  log(`  ${answers.packageManager} run dev`);
+  log(`  ${answers.packageManager} run deploy`);
+}
+
+function slugify(value) {
+  return String(value || 'glash-app')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, '-')
+    .replace(/^-+|-+$/g, '') || 'glash-app';
+}
+
+function titleCase(value) {
+  return String(value).replace(/[-_]+/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase());
+}
+
+function randomToken() {
+  return randomBytes(24).toString('base64url');
+}
+
+function shellQuote(value) {
+  return /^[a-zA-Z0-9_./-]+$/.test(value) ? value : JSON.stringify(value);
+}
+
+function json(value) {
+  return JSON.stringify(value, null, 2) + '\n';
+}

package/src/env.mjs

@@ -0,0 +1,88 @@
+// glashjs environment helpers
+// ---------------------------------------------------------------------------
+// Small, runtime-safe helpers for the env contract GlashDB manages during
+// deploy. They work locally from process.env and become zero-config once the
+// project is hosted on GlashDB.
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+
+export function env(name, options = {}) {
+  const fallback = Object.prototype.hasOwnProperty.call(options, 'default') ? options.default : undefined;
+  const required = options.required ?? fallback === undefined;
+  const value = process.env[name] ?? fallback;
+  if (required && (value === undefined || value === '')) {
+    throw new Error(`Missing required environment variable: ${name}`);
+  }
+  return value;
+}
+
+export function optionalEnv(name, fallback = '') {
+  return env(name, { required: false, default: fallback });
+}
+
+export function requireEnv(names) {
+  const out = {};
+  for (const name of names) out[name] = env(name);
+  return out;
+}
+
+export function publicEnv(prefixes = ['PUBLIC_', 'GLASH_PUBLIC_', 'NEXT_PUBLIC_']) {
+  const list = Array.isArray(prefixes) ? prefixes : [prefixes];
+  const out = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (list.some((prefix) => key.startsWith(prefix))) out[key] = value;
+  }
+  return out;
+}
+
+export function glashProjectEnv() {
+  return {
+    projectId: optionalEnv('GLASHDB_PROJECT_ID', optionalEnv('GLASHAUTH_PROJECT_ID', '')),
+    apiUrl: optionalEnv('GLASHDB_API_URL', 'https://api.glashdb.com/api'),
+    databaseUrl: optionalEnv('DATABASE_URL', ''),
+    directUrl: optionalEnv('DIRECT_URL', ''),
+    anonKey: optionalEnv('GLASHDB_ANON_KEY', optionalEnv('GLASHAUTH_ANON_KEY', '')),
+  };
+}
+
+export function loadEnvFiles(root = process.cwd(), options = {}) {
+  const mode = options.mode ?? process.env.NODE_ENV ?? 'development';
+  const locked = new Set(Object.keys(process.env));
+  const files = [
+    '.env',
+    '.env.local',
+    `.env.${mode}`,
+    `.env.${mode}.local`,
+  ];
+  const loaded = [];
+  for (const file of files) {
+    const full = path.resolve(root, file);
+    if (!existsSync(full)) continue;
+    const pairs = parseEnv(readFileSync(full, 'utf8'));
+    for (const [key, value] of Object.entries(pairs)) {
+      if (options.override || !locked.has(key)) process.env[key] = value;
+    }
+    loaded.push(file);
+  }
+  return loaded;
+}
+
+function parseEnv(text) {
+  const out = {};
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const match = /^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/.exec(trimmed);
+    if (!match) continue;
+    out[match[1]] = unquote(match[2]);
+  }
+  return out;
+}
+
+function unquote(value) {
+  const trimmed = value.trim();
+  if ((trimmed.startsWith('"') && trimmed.endsWith('"')) || (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+    return trimmed.slice(1, -1).replace(/\\n/g, '\n').replace(/\\"/g, '"').replace(/\\'/g, "'");
+  }
+  return trimmed.replace(/\s+#.*$/, '');
+}