@glash/cli 0.2.34 → 0.2.36

package/README.md

@@ -109,6 +109,10 @@ glash deploy --asset-mode auto --asset-threshold 100mb
 Every deploy prints a live monitor link. Open it to watch the black-screen deployment flow while the CLI is packaging, uploading, building, routing, and checking the live URL.
 Public asset offload prepares assets in small batches and uses multipart uploads for large files, so image/video-heavy `public/` folders can upload without forcing the source bundle over the platform limit.
 
+Framework/runtime checks:
+
+`glash deploy` detects both the project framework and the runtime scripts in `package.json`. If they disagree, for example the project looks like Next.js but `start` calls `glash serve`, the CLI stops before upload and asks you to align the scripts or explicitly continue. Use `--ignore-framework-mismatch` only when the mismatch is intentional.
+
 Large source bundles:
 
 ```bash

package/bin/glash.mjs

@@ -104,6 +104,7 @@ ${color.bold('FLAGS')}
   --source-threshold <size>   Auto-chunk source threshold (default: 90mb)
   --source-concurrency <n>    Parallel chunk uploads for large source bundles (default: 4)
   --framework <name>          Override framework detection (glashjs, next, vite, etc.)
+  --ignore-framework-mismatch Continue when detected framework and runtime scripts differ
   --help, -h                  Show this help
   --version, -v               Show CLI version
 

package/commands/deploy.mjs

@@ -9,7 +9,7 @@ import { join, basename, extname } from 'node:path';
 import { tmpdir } from 'node:os';
 import { createReadStream, openAsBlob } from 'node:fs';
 import { access, readFile, rm, stat } from 'node:fs/promises';
-import { stdout } from 'node:process';
+import { stdin, stdout } from 'node:process';
 
 function currentCommit() {
   try {
@@ -137,6 +137,10 @@ export async function deploy({ flags }) {
   const target = flags.prod || flags.production ? 'production' : (flags.target || 'production');
   const requestedAssetMode = assetMode(flags);
   const projectProfile = remoteDeploy ? { framework: frameworkHint(flags), label: frameworkHint(flags) || 'auto' } : await detectProjectProfile(process.cwd(), flags);
+  if (!remoteDeploy) {
+    const compatible = await confirmFrameworkRuntimeCompatibility(projectProfile, flags);
+    if (!compatible) return fail('Deployment cancelled. Align the framework/runtime scripts or rerun with --ignore-framework-mismatch.');
+  }
   const monitorStartedAt = Date.now();
   const initialStatusUrl = deployMonitorUrl({ projectId, after: monitorStartedAt });
 
@@ -153,6 +157,7 @@ export async function deploy({ flags }) {
     target,
     source: remoteDeploy ? 'remote git deploy' : 'local upload',
     framework: projectProfile.framework,
+    runtime: projectProfile.runtime?.summary || '',
     sourceUpload: { mode: remoteDeploy ? 'remote' : 'pending', parts: 0 },
     packagesUploaded: 0,
     filesIncluded: 0,
@@ -713,30 +718,194 @@ function sourceUploadConcurrency(flags = {}) {
 }
 
 async function detectProjectProfile(cwd, flags = {}) {
+  const runtime = await inspectProjectRuntime(cwd);
   const forced = frameworkHint(flags);
-  if (forced) return { framework: forced, label: forced };
+  const profile = forced
+    ? { framework: forced, label: frameworkLabel(forced), forced: true }
+    : inferFrameworkFromRuntime(runtime);
+  return { ...profile, runtime: summarizeRuntimeCompatibility(profile, runtime) };
+}
+
+async function inspectProjectRuntime(cwd) {
   const pkg = await readPackageJson(cwd);
   const deps = { ...(pkg?.dependencies ?? {}), ...(pkg?.devDependencies ?? {}) };
   const scripts = pkg?.scripts ?? {};
+  const scriptText = Object.values(scripts).join('\n');
+  const hasDockerfile = await existsAny(cwd, ['Dockerfile', 'dockerfile']);
   const hasNextConfig = await existsAny(cwd, ['next.config.js', 'next.config.mjs', 'next.config.cjs', 'next.config.ts']);
   const hasGlashConfig = await existsAny(cwd, ['glash.config.mjs', 'glash.config.js', 'glash.config.cjs']);
-  const scriptText = Object.values(scripts).join('\n');
-  if (deps.next || hasNextConfig || /\bnext\s+(build|dev|start)\b/i.test(scriptText)) return { framework: 'next', label: 'Next.js' };
-  if (deps.glashjs || hasGlashConfig || /\bglash\s+(build|serve|dev)\b/i.test(scriptText)) return { framework: 'glashjs', label: 'glashjs' };
+  const scriptCalls = {
+    build: scriptFrameworkCalls(scripts.build),
+    start: scriptFrameworkCalls(scripts.start),
+    dev: scriptFrameworkCalls(scripts.dev),
+  };
+  return {
+    pkg,
+    deps,
+    scripts,
+    scriptText,
+    hasDockerfile,
+    hasNextConfig,
+    hasGlashConfig,
+    buildFramework: scriptCalls.build[0] || '',
+    startFramework: scriptCalls.start[0] || '',
+    devFramework: scriptCalls.dev[0] || '',
+    buildCalls: scriptCalls.build,
+    startCalls: scriptCalls.start,
+    devCalls: scriptCalls.dev,
+  };
+}
+
+function inferFrameworkFromRuntime(runtime) {
+  const { deps, scriptText } = runtime;
+  if (runtime.hasDockerfile) return { framework: 'dockerfile', label: 'Dockerfile' };
+  if (deps.next || runtime.hasNextConfig || /\bnext\s+(build|dev|start)\b/i.test(scriptText)) return { framework: 'next', label: 'Next.js' };
+  if (deps.glashjs || runtime.hasGlashConfig || /\bglash(?:db)?\s+(build|serve|dev|start)\b/i.test(scriptText)) return { framework: 'glashjs', label: 'glashjs' };
   if (deps.nuxt || deps.nuxt3) return { framework: 'nuxt', label: 'Nuxt' };
   if (deps.vite) return { framework: 'vite', label: 'Vite' };
   if (deps['@remix-run/dev'] || deps.remix) return { framework: 'remix', label: 'Remix' };
   if (deps.astro) return { framework: 'astro', label: 'Astro' };
   if (deps.svelte || deps['@sveltejs/kit']) return { framework: 'sveltekit', label: 'SvelteKit' };
   if (deps.express || deps.fastify || deps['@nestjs/core']) return { framework: 'node', label: 'Node.js' };
-  if (pkg) return { framework: 'node', label: 'Node.js' };
+  if (runtime.pkg) return { framework: 'node', label: 'Node.js' };
   return { framework: 'static', label: 'Static' };
 }
 
+function summarizeRuntimeCompatibility(profile, runtime) {
+  const runtimeFramework = runtime.startFramework || runtime.buildFramework || runtime.devFramework || (runtime.hasDockerfile ? 'dockerfile' : '');
+  const buildFramework = runtime.buildFramework || '';
+  const summary = runtimeFramework
+    ? `${frameworkLabel(runtimeFramework)}${runtime.startFramework ? ' start' : runtime.buildFramework ? ' build' : runtime.devFramework ? ' dev' : ''}`
+    : runtime.hasDockerfile ? 'Dockerfile' : 'auto';
+  const mismatch = frameworkRuntimeMismatch(profile.framework, runtimeFramework, buildFramework, runtime);
+  return {
+    ...runtime,
+    runtimeFramework,
+    summary,
+    mismatch,
+  };
+}
+
+function frameworkRuntimeMismatch(framework, runtimeFramework, buildFramework, runtime) {
+  if (!framework || framework === 'auto' || framework === 'dockerfile' || framework === 'static') return null;
+  if (!runtimeFramework || runtimeFramework === 'dockerfile') return null;
+  if (frameworksCompatible(framework, runtimeFramework)) return null;
+  const buildStillCallsFramework = buildFramework && frameworksCompatible(framework, buildFramework);
+  if (runtime.startFramework === 'node' && buildStillCallsFramework) return null;
+  if (!runtime.startFramework && buildStillCallsFramework) return null;
+  return {
+    framework,
+    runtimeFramework,
+    buildFramework,
+    buildScript: runtime.scripts?.build || '',
+    startScript: runtime.scripts?.start || '',
+    devScript: runtime.scripts?.dev || '',
+  };
+}
+
+function frameworksCompatible(a, b) {
+  const left = normalizeFrameworkName(a);
+  const right = normalizeFrameworkName(b);
+  if (!left || !right) return false;
+  if (left === right) return true;
+  if (left === 'sveltekit' && right === 'vite') return true;
+  if (left === 'vite' && right === 'sveltekit') return true;
+  return false;
+}
+
+function scriptFrameworkCalls(command = '') {
+  const text = String(command || '');
+  if (!text.trim()) return [];
+  const patterns = [
+    ['next', /\bnext\s+(?:build|start|dev|export)\b/ig],
+    ['glashjs', /\bglash(?:db)?\s+(?:build|serve|dev|start)\b/ig],
+    ['nuxt', /\b(?:nuxt|nuxi)\s*(?:build|start|preview|dev|generate)?\b/ig],
+    ['astro', /\bastro\s+(?:build|dev|preview)\b/ig],
+    ['remix', /\b(?:remix-serve|remix)\b/ig],
+    ['sveltekit', /\bsvelte-kit\s+(?:build|dev|preview)\b/ig],
+    ['vite', /\bvite(?:\s+(?:build|preview|dev|--host))?\b/ig],
+    ['node', /\b(?:node|tsx|ts-node)\b/ig],
+    ['node', /\bnest\s+start\b/ig],
+  ];
+  const matches = [];
+  for (const [framework, regex] of patterns) {
+    for (const match of text.matchAll(regex)) {
+      matches.push({ framework, index: match.index ?? 0 });
+    }
+  }
+  matches.sort((a, b) => a.index - b.index);
+  const out = [];
+  for (const match of matches) {
+    if (!out.includes(match.framework)) out.push(match.framework);
+  }
+  return out;
+}
+
+function normalizeFrameworkName(value) {
+  const raw = String(value || '').trim().toLowerCase();
+  const aliases = {
+    glash: 'glashjs',
+    glashdb: 'glashjs',
+    nextjs: 'next',
+    svelte: 'sveltekit',
+    docker: 'dockerfile',
+    dockerfile: 'dockerfile',
+  };
+  return aliases[raw] ?? raw;
+}
+
+function frameworkLabel(value) {
+  const labels = {
+    next: 'Next.js',
+    glashjs: 'glashjs',
+    nuxt: 'Nuxt',
+    vite: 'Vite',
+    remix: 'Remix',
+    astro: 'Astro',
+    sveltekit: 'SvelteKit',
+    node: 'Node.js',
+    static: 'Static',
+    dockerfile: 'Dockerfile',
+    auto: 'auto',
+  };
+  return labels[normalizeFrameworkName(value)] ?? String(value || 'auto');
+}
+
+async function confirmFrameworkRuntimeCompatibility(profile, flags = {}) {
+  const mismatch = profile?.runtime?.mismatch;
+  if (!mismatch) return true;
+
+  const detected = frameworkLabel(mismatch.framework);
+  const runtime = frameworkLabel(mismatch.runtimeFramework);
+  warn('');
+  warn('Framework/runtime mismatch detected');
+  warn(`Your framework is ${color.bold(detected)} while your runtime calls on ${color.bold(runtime)}.`);
+  if (mismatch.buildScript) warn(`build: ${color.dim(mismatch.buildScript)}`);
+  if (mismatch.startScript) warn(`start: ${color.dim(mismatch.startScript)}`);
+  warn('Consider moving to one framework, or ignore this warning to continue building.');
+
+  if (ignoreFrameworkMismatch(flags)) {
+    warn('Continuing because --ignore-framework-mismatch was set.');
+    return true;
+  }
+  if (!stdin.isTTY) return false;
+  const answer = await prompt('Ignore mismatch and continue building? [y/N] ');
+  return ['y', 'yes', 'ignore', 'continue'].includes(answer.toLowerCase());
+}
+
+function ignoreFrameworkMismatch(flags = {}) {
+  return Boolean(
+    flags['ignore-framework-mismatch']
+    || flags['ignore-runtime-mismatch']
+    || String(flags['framework-mismatch'] || '').toLowerCase() === 'ignore'
+  );
+}
+
 async function packageOverridesForProfile(cwd, profile) {
-  if (profile?.framework !== 'glashjs') return {};
+  const overrides = await glashRuntimeOverrides(cwd);
+  if (profile?.framework !== 'glashjs') return overrides;
   const pkg = await readPackageJson(cwd);
-  if (!pkg) return {};
+  if (!pkg) return overrides;
   const scripts = { ...(pkg.scripts ?? {}) };
   let changed = false;
   if (!scripts.build) {
@@ -747,17 +916,42 @@ async function packageOverridesForProfile(cwd, profile) {
     scripts.start = 'glash serve --port ${PORT:-3000}';
     changed = true;
   }
-  if (!changed) return {};
+  if (!changed) return overrides;
   return {
+    ...overrides,
     'package.json': `${JSON.stringify({ ...pkg, scripts }, null, 2)}\n`,
   };
 }
 
+const GLASH_PUBLIC_RUNTIME_FILES = [
+  'glash-sw.js',
+  'glash-offline.mjs',
+  'glash-favicon.mjs',
+  'glash-assets.manifest.json',
+  'manifest.webmanifest',
+  'favicon.svg',
+  'favicon-animated.svg',
+];
+
+async function glashRuntimeOverrides(cwd) {
+  const overrides = {};
+  for (const name of GLASH_PUBLIC_RUNTIME_FILES) {
+    const publicPath = `public/${name}`;
+    const candidates = [publicPath, `.glash/out/${name}`];
+    for (const candidate of candidates) {
+      try {
+        overrides[publicPath] = await readFile(join(cwd, candidate));
+        break;
+      } catch {}
+    }
+  }
+  return overrides;
+}
+
 function frameworkHint(flags = {}) {
   const raw = String(flags.framework ?? flags.runtime ?? '').trim().toLowerCase();
   if (!raw) return '';
-  const aliases = { nextjs: 'next', glash: 'glashjs', glashdb: 'glashjs', react: 'vite' };
-  const normalized = aliases[raw] ?? raw;
+  const normalized = normalizeFrameworkName(raw === 'react' ? 'vite' : raw);
   return /^[a-z0-9._-]{1,40}$/.test(normalized) ? normalized : '';
 }
 
@@ -1043,6 +1237,7 @@ function printDeployReport(report) {
     ['Target', report.target || 'production'],
     ['Source', report.source || '-'],
     ['Framework', report.framework || 'auto'],
+    ['Runtime', report.runtime || '-'],
     ['Packages uploaded', formatPackagesUploaded(report)],
     ['Public assets', formatAssetSummary(report.assetSummary)],
     ['Deployment size', formatDeploymentSize(report)],

package/commands/login.mjs

@@ -1,14 +1,107 @@
+import { spawn } from 'node:child_process';
+import { platform } from 'node:process';
+import { hostname } from 'node:os';
 import { apiPost } from '../lib/api.mjs';
 import { writeCreds } from '../lib/config.mjs';
-import { prompt, ok, fail } from '../lib/ui.mjs';
+import { prompt, ok, fail, info, warn, color } from '../lib/ui.mjs';
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+function openBrowser(url) {
+  try {
+    const opener = platform === 'darwin' ? 'open' : platform === 'win32' ? 'cmd' : 'xdg-open';
+    const args = platform === 'win32' ? ['/c', 'start', '', url] : [url];
+    spawn(opener, args, { stdio: 'ignore', detached: true }).unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
 
 export async function login({ flags }) {
+  // Explicit password login (headless/CI). Otherwise use browser-based approval.
+  if (flags.email || flags.password) {
+    return passwordLogin(flags);
+  }
+  return browserLogin(flags);
+}
+
+async function browserLogin(flags) {
+  let start;
+  try {
+    start = await apiPost('/auth/cli/device/start', { deviceName: hostname() });
+  } catch (e) {
+    // Older backend without device auth — fall back to password login.
+    warn('Browser login is unavailable; falling back to email/password.');
+    return passwordLogin(flags);
+  }
+
+  const { deviceCode, userCode, verificationUri, verificationUriComplete, interval = 5, expiresIn = 600 } = start;
+  const approveUrl = verificationUriComplete || verificationUri;
+
+  info('');
+  info(`  To sign in, approve this request in your browser:`);
+  info(`    ${color.cyan(approveUrl)}`);
+  info(`  Verification code: ${color.bold(userCode)}`);
+  info('');
+
+  if (flags['no-browser']) {
+    info('  Open the link above to continue.');
+  } else if (openBrowser(approveUrl)) {
+    info(color.dim('  Opened your browser… waiting for approval.'));
+  } else {
+    info('  Could not open a browser automatically — open the link above.');
+  }
+
+  const deadline = Date.now() + expiresIn * 1000;
+  let delay = Math.max(2, interval) * 1000;
+  try {
+    while (Date.now() < deadline) {
+      await sleep(delay);
+      let r;
+      try {
+        r = await apiPost('/auth/cli/device/poll', { deviceCode });
+      } catch (e) {
+        return fail(e.message);
+      }
+      if (r?.status === 'approved' && r.accessToken) {
+        await writeCreds({ token: r.accessToken, email: r.user?.email });
+        return ok(`Signed in as ${r.user?.email ?? 'your account'}`);
+      }
+      if (r?.status === 'denied') return fail('Sign-in was denied in the browser.');
+      if (r?.status === 'expired') return fail('Sign-in request expired. Run `glash login` again.');
+      // status === 'pending' → keep polling.
+    }
+    return fail('Timed out waiting for approval. Run `glash login` again.');
+  } catch (e) {
+    return fail(e.message);
+  }
+}
+
+async function passwordLogin(flags) {
   const email = flags.email || (await prompt('Email: '));
   const password = flags.password || (await prompt('Password: ', { mask: true }));
   if (!email || !password) return fail('email and password required');
 
   try {
-    const r = await apiPost('/auth/login', { email, password });
+    let r = await apiPost('/auth/login', { email, password });
+
+    // Second factor is always required. Complete the email-OTP challenge.
+    if (!r?.accessToken && r?.secondFactorRequired && !r?.challengeId) {
+      r = await apiPost('/auth/login', { email, password, secondFactorMethod: 'email_otp' });
+    }
+    if (!r?.accessToken && (r?.otpRequired || r?.challengeId)) {
+      const code = flags.otp || (await prompt('Enter the 6-digit code sent to your email: '));
+      if (!code) throw new Error('A verification code is required to sign in.');
+      r = await apiPost('/auth/login', {
+        email,
+        password,
+        emailOtpCode: String(code).trim(),
+        loginOtpChallengeId: r.challengeId,
+        secondFactorMethod: 'email_otp',
+      });
+    }
+
     if (!r?.accessToken || !r?.user?.email) {
       throw new Error('Login response was missing a session token. Please try again.');
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glash/cli",
-  "version": "0.2.34",
+  "version": "0.2.36",
   "description": "glashDB command-line interface — deploy projects, pull source + env, manage env vars.",
   "license": "Apache-2.0",
   "homepage": "https://glashdb.com",