@glash/cli 0.2.33 → 0.2.35

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

@@ -102,7 +102,9 @@ ${color.bold('FLAGS')}
   --asset-threshold <size>    Auto-offload threshold (default: 100mb)
   --source-upload <mode>      Source upload: auto, direct, chunked
   --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,
@@ -218,6 +223,7 @@ export async function deploy({ flags }) {
         gitBranch: gitBranch || '',
         target,
         framework: projectProfile.framework,
+        flags,
       };
 
       if (shouldUseChunkedSourceUpload(zipStat.size, flags)) {
@@ -519,10 +525,19 @@ async function uploadSourceBundleStaged(projectId, zipPath, zipStat, meta, indic
 
   const partSize = sourceUploadPartSize(prepared.partSize);
   const blob = await openAsBlob(zipPath, { type: 'application/zip' });
+  const chunks = [];
+  for (let offset = 0, partNumber = 1; offset < sizeBytes; offset += partSize, partNumber += 1) {
+    chunks.push({
+      partNumber,
+      offset,
+      end: Math.min(offset + partSize, sizeBytes),
+    });
+  }
+
   const parts = [];
-  let partNumber = 1;
-  for (let offset = 0; offset < sizeBytes; offset += partSize) {
-    const end = Math.min(offset + partSize, sizeBytes);
+  let uploadedBytes = 0;
+  const concurrency = sourceUploadConcurrency(meta.flags);
+  await mapWithConcurrency(chunks, concurrency, async ({ partNumber, offset, end }) => {
     const partUrl = withQueryParam(prepared.uploadPartUrl, 'partNumber', String(partNumber));
     const res = await fetchWithRetries(partUrl, {
       method: 'PUT',
@@ -540,10 +555,11 @@ async function uploadSourceBundleStaged(projectId, zipPath, zipStat, meta, indic
       throw new Error(`Chunked source upload part ${partNumber} did not return a multipart ETag`);
     }
     parts.push({ partNumber: Number(part.partNumber), etag: String(part.etag) });
-    const percent = 28 + Math.round((end / sizeBytes) * 14);
+    uploadedBytes += (end - offset);
+    const percent = 28 + Math.round((uploadedBytes / sizeBytes) * 14);
     indicator?.setProgress?.(percent, 'uploading');
-    partNumber += 1;
-  }
+  });
+  parts.sort((a, b) => a.partNumber - b.partNumber);
 
   const completed = await fetchWithRetries(prepared.completeUrl, {
     method: 'POST',
@@ -575,6 +591,19 @@ async function uploadSourceBundleStaged(projectId, zipPath, zipStat, meta, indic
   return { deployment, partsUploaded: parts.length, sha256 };
 }
 
+async function mapWithConcurrency(items, concurrency, worker) {
+  const limit = Math.max(1, Math.min(Number(concurrency) || 1, items.length || 1));
+  let next = 0;
+  const runners = Array.from({ length: limit }, async () => {
+    while (next < items.length) {
+      const item = items[next];
+      next += 1;
+      await worker(item);
+    }
+  });
+  await Promise.all(runners);
+}
+
 function sourceUploadFailure(error) {
   const message = error?.message || String(error);
   if (error?.status === 404 && /source-upload|Cannot POST/i.test(message)) {
@@ -629,7 +658,7 @@ function uploadTimeoutMsFor(bytes) {
 function publicAssetPartSize(value) {
   const parsed = Number(value);
   if (Number.isFinite(parsed) && parsed >= 5 * 1024 * 1024) return Math.round(parsed);
-  return 16 * 1024 * 1024;
+  return 80 * 1024 * 1024;
 }
 
 function assetOffloadFailure(error, assetSummary) {
@@ -678,31 +707,205 @@ function sourceUploadThresholdBytes(flags) {
 function sourceUploadPartSize(value) {
   const parsed = Number(value);
   if (Number.isFinite(parsed) && parsed >= 5 * 1024 * 1024) return Math.round(parsed);
-  return 16 * 1024 * 1024;
+  return 80 * 1024 * 1024;
+}
+
+function sourceUploadConcurrency(flags = {}) {
+  const raw = flags['source-concurrency'] ?? process.env.GLASH_SOURCE_UPLOAD_CONCURRENCY ?? '4';
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < 1) return 4;
+  return Math.max(1, Math.min(8, Math.floor(parsed)));
 }
 
 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']);
-  if (deps.glashjs || hasGlashConfig) return { framework: 'glashjs', label: 'glashjs' };
-  if (deps.next) return { framework: 'next', label: 'Next.js' };
+  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) {
@@ -713,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 : '';
 }
 
@@ -1009,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/package.json

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