@glash/cli 0.2.32 → 0.2.33

package/README.md

@@ -68,6 +68,7 @@ Common Node and frontend targets:
 
 | Framework or runtime | Notes |
 | --- | --- |
+| glashjs | Native glashDB framework support; the CLI detects `glashjs`/`glash.config.*` and packages build/start scripts when missing |
 | Next.js | Built and started with the Next runtime when no custom start script is present |
 | React | Works with Vite, Create React App, Gatsby, Remix, and custom React servers |
 | Vue | Works with Vue apps and Nuxt projects |
@@ -93,6 +94,7 @@ Deployment checklist:
 - Set required secrets with `glash env:add` or the dashboard before deploying.
 - Make sure the app listens on the expected runtime port.
 - For large `public/` folders, deploy with `--asset-mode offload` to upload public assets to glashDB object storage/CDN and keep the source bundle small.
+- Source bundles over 90 MB automatically use chunked source upload, keeping each request below Cloudflare Free's 100 MB upload limit.
 
 Large public folders:
 
@@ -107,6 +109,21 @@ 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.
 
+Large source bundles:
+
+```bash
+# Default: direct upload below 90 MB, chunked upload above it
+glash deploy
+
+# Force chunked upload even for a smaller bundle
+glash deploy --source-upload chunked
+
+# Tune the auto-chunk threshold
+glash deploy --source-threshold 75mb
+```
+
+For glashjs projects, `glash deploy` detects `glashjs` or `glash.config.mjs`, marks the project as `glashjs`, keeps deploy-safe `.glash` output, and adds missing `build` / `start` scripts inside the deployment bundle without editing your local `package.json`.
+
 ## Commands
 
 | Command | Purpose |
@@ -123,6 +140,7 @@ Public asset offload prepares assets in small batches and uses multipart uploads
 | `glash open` | Open the linked project's primary domain |
 | `glash deploy [--prod] [--detach]` | Deploy the linked project; streams the pipeline until live |
 | `glash deploy --asset-mode offload` | Upload `public/` assets to object storage/CDN before zipping source |
+| `glash deploy --source-upload chunked` | Stage the source zip through multipart object storage to bypass Cloudflare's single-request cap |
 | `glash deployments` | List recent deployments |
 | `glash status <id>` | Show a deployment's pipeline + events |
 | `glash logs <id>` | Alias of `status` |
@@ -181,6 +199,8 @@ The commands require PostgreSQL client tools locally: `pg_dump` for dumps,
 | `GLASH_TOKEN` | — | Use this token instead of `~/.glash/credentials.json` (useful in CI) |
 | `GLASH_ASSET_OFFLOAD_THRESHOLD` | `100mb` | Default threshold for `glash deploy --asset-mode auto` |
 | `GLASH_ASSET_BATCH_SIZE` | `50` | Number of public assets prepared per request during `--asset-mode offload` |
+| `GLASH_SOURCE_UPLOAD_MODE` | `auto` | Source upload mode: `auto`, `direct`, or `chunked` |
+| `GLASH_SOURCE_UPLOAD_THRESHOLD` | `90mb` | Default threshold for automatic chunked source upload |
 
 ## Requirements
 

package/bin/glash.mjs

@@ -100,6 +100,9 @@ ${color.bold('FLAGS')}
   --no-env                    Skip automatic env sync during deploy
   --asset-mode <mode>         Public asset handling: inline, auto, offload
   --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)
+  --framework <name>          Override framework detection (glashjs, next, vite, etc.)
   --help, -h                  Show this help
   --version, -v               Show CLI version
 

package/commands/deploy.mjs

@@ -118,9 +118,10 @@ async function createNewProjectFromCurrentDirectory() {
   const dirName = basename(process.cwd());
   const name = (await prompt(`What's your project's name? [${dirName}] `)) || dirName;
   const slug = name.toLowerCase().replace(/[^a-z0-9-]+/g, '-').replace(/^-+|-+$/g, '');
+  const profile = await detectProjectProfile(process.cwd());
   
   info(color.dim(`Creating project "${name}"...`));
-  const p = await apiPost('/projects', { name, slug });
+  const p = await apiPost('/projects', { name, slug, framework: profile.framework });
   await writeProjectLink({ projectId: p.id, slug: p.slug, name: p.name });
   ok(`Created and linked to ${p.name} (${p.slug})`);
   return p.id;
@@ -135,6 +136,7 @@ export async function deploy({ flags }) {
   const gitBranch = flags.branch || currentBranch();
   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);
   const monitorStartedAt = Date.now();
   const initialStatusUrl = deployMonitorUrl({ projectId, after: monitorStartedAt });
 
@@ -150,6 +152,8 @@ export async function deploy({ flags }) {
     deploymentId: '',
     target,
     source: remoteDeploy ? 'remote git deploy' : 'local upload',
+    framework: projectProfile.framework,
+    sourceUpload: { mode: remoteDeploy ? 'remote' : 'pending', parts: 0 },
     packagesUploaded: 0,
     filesIncluded: 0,
     deploymentSizeBytes: 0,
@@ -200,23 +204,45 @@ export async function deploy({ flags }) {
     indicator.setPhase('packaging');
     const zipPath = join(tmpdir(), `glash-deploy-${Date.now()}.zip`);
     try {
-      const bundle = await zipDirectory(process.cwd(), zipPath, { ignore: assetSummary.offloaded ? ['public/**'] : [] });
+      const packageOverrides = await packageOverridesForProfile(process.cwd(), projectProfile);
+      const bundle = await zipDirectory(process.cwd(), zipPath, {
+        ignore: assetSummary.offloaded ? ['public/**'] : [],
+        includeGlashOutput: projectProfile.framework === 'glashjs',
+        overrides: packageOverrides,
+      });
       const zipStat = await stat(zipPath);
       report.filesIncluded = bundle.fileCount ?? 0;
       report.deploymentSizeBytes = zipStat.size || bundle.bytes || 0;
-      const formData = new FormData();
-      formData.append('projectId', projectId);
-      formData.append('file', await openAsBlob(zipPath, { type: 'application/zip' }), 'project.zip');
-      
-      formData.append('commitHash', commitHash || 'local-upload');
-      formData.append('gitBranch', gitBranch || '');
-      formData.append('target', target);
-
-      indicator.setPhase('glashing');
-      dep = await apiPost('/deployments/upload', formData);
+      const uploadMeta = {
+        commitHash: commitHash || 'local-upload',
+        gitBranch: gitBranch || '',
+        target,
+        framework: projectProfile.framework,
+      };
+
+      if (shouldUseChunkedSourceUpload(zipStat.size, flags)) {
+        indicator.setPhase('uploading');
+        const staged = await uploadSourceBundleStaged(projectId, zipPath, zipStat, uploadMeta, indicator);
+        dep = staged.deployment;
+        report.source = 'local upload (chunked)';
+        report.sourceUpload = { mode: 'chunked', parts: staged.partsUploaded, sha256: staged.sha256 };
+        report.packagesUploaded = staged.partsUploaded;
+      } else {
+        const formData = new FormData();
+        formData.append('projectId', projectId);
+        formData.append('file', await openAsBlob(zipPath, { type: 'application/zip' }), 'project.zip');
+        formData.append('commitHash', uploadMeta.commitHash);
+        formData.append('gitBranch', uploadMeta.gitBranch);
+        formData.append('target', uploadMeta.target);
+        if (uploadMeta.framework) formData.append('framework', uploadMeta.framework);
+
+        indicator.setPhase('glashing');
+        dep = await apiPost('/deployments/upload', formData);
+        report.sourceUpload = { mode: 'direct', parts: 1 };
+        report.packagesUploaded = 1;
+      }
       report.deploymentId = dep?.id ?? '';
       report.statusUrl = deployMonitorUrl({ deploymentId: dep?.id, projectId, after: monitorStartedAt });
-      report.packagesUploaded = 1;
       await rm(zipPath, { force: true }).catch(() => {});
     } catch (e) {
       await rm(zipPath, { force: true }).catch(() => {});
@@ -227,7 +253,7 @@ export async function deploy({ flags }) {
   } else {
     indicator.setPhase('hatching');
     try {
-      dep = await apiPost('/deployments', { projectId, commitHash, gitBranch, target });
+      dep = await apiPost('/deployments', { projectId, commitHash, gitBranch, target, framework: projectProfile.framework });
       report.deploymentId = dep?.id ?? '';
       report.statusUrl = deployMonitorUrl({ deploymentId: dep?.id, projectId, after: monitorStartedAt });
     } catch (e) {
@@ -470,6 +496,96 @@ async function uploadMultipartPublicAsset(asset, local) {
   }
 }
 
+async function uploadSourceBundleStaged(projectId, zipPath, zipStat, meta, indicator) {
+  const sizeBytes = zipStat.size;
+  const sha256 = await hashFile(zipPath);
+  let prepared;
+  try {
+    prepared = await apiPost('/deployments/source-upload/prepare', {
+      projectId,
+      fileName: 'project.zip',
+      sizeBytes,
+      sha256,
+      contentType: 'application/zip',
+      framework: meta.framework,
+    }, { timeoutMs: 120_000 });
+  } catch (e) {
+    throw sourceUploadFailure(e);
+  }
+
+  if (!prepared?.uploadPartUrl || !prepared?.completeUrl || !prepared?.uploadId) {
+    throw new Error('Chunked source upload was not prepared by this GlashDB API.');
+  }
+
+  const partSize = sourceUploadPartSize(prepared.partSize);
+  const blob = await openAsBlob(zipPath, { type: 'application/zip' });
+  const parts = [];
+  let partNumber = 1;
+  for (let offset = 0; offset < sizeBytes; offset += partSize) {
+    const end = Math.min(offset + partSize, sizeBytes);
+    const partUrl = withQueryParam(prepared.uploadPartUrl, 'partNumber', String(partNumber));
+    const res = await fetchWithRetries(partUrl, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/octet-stream' },
+      body: blob.slice(offset, end, 'application/octet-stream'),
+    }, { timeoutMs: uploadTimeoutMsFor(end - offset) });
+    if (!res.ok) {
+      const detail = await res.text().catch(() => '');
+      throw new Error(`Chunked source upload part ${partNumber} failed with HTTP ${res.status}${detail ? `: ${detail.slice(0, 200)}` : ''}`);
+    }
+    let data;
+    try { data = await res.json(); } catch { data = {}; }
+    const part = data?.part;
+    if (!part?.etag || !Number.isInteger(Number(part.partNumber))) {
+      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);
+    indicator?.setProgress?.(percent, 'uploading');
+    partNumber += 1;
+  }
+
+  const completed = await fetchWithRetries(prepared.completeUrl, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ parts }),
+  }, { timeoutMs: 120_000 });
+  if (!completed.ok) {
+    const detail = await completed.text().catch(() => '');
+    throw new Error(`Completing chunked source upload failed with HTTP ${completed.status}${detail ? `: ${detail.slice(0, 200)}` : ''}`);
+  }
+  let completion;
+  try { completion = await completed.json(); } catch { completion = {}; }
+  if (!completion?.sourceUrl) {
+    throw new Error('Chunked source upload completed without a staged source URL.');
+  }
+
+  indicator?.setProgress?.(43, 'hatching');
+  const deployment = await apiPost('/deployments/source-upload/commit', {
+    projectId,
+    sourceUrl: completion.sourceUrl,
+    sha256,
+    sizeBytes: String(sizeBytes),
+    commitHash: meta.commitHash,
+    gitBranch: meta.gitBranch,
+    target: meta.target,
+    framework: meta.framework,
+  }, { timeoutMs: 120_000 });
+
+  return { deployment, partsUploaded: parts.length, sha256 };
+}
+
+function sourceUploadFailure(error) {
+  const message = error?.message || String(error);
+  if (error?.status === 404 && /source-upload|Cannot POST/i.test(message)) {
+    return new Error('This GlashDB edge does not support chunked source upload yet. Deploy the router/backend source-upload update, then retry.');
+  }
+  if (error?.status === 503 && /storage is not configured/i.test(message)) {
+    return new Error('Chunked source upload storage is not configured on this GlashDB API.');
+  }
+  return error instanceof Error ? error : new Error(message);
+}
+
 async function fetchWithRetries(url, init, { retries = 3, timeoutMs = 120_000 } = {}) {
   let attempt = 0;
   // eslint-disable-next-line no-constant-condition
@@ -542,6 +658,93 @@ function assetMode(flags) {
   throw new Error(`Unsupported --asset-mode "${raw}". Use inline, auto, or offload.`);
 }
 
+function sourceUploadMode(flags) {
+  const raw = String(flags['source-upload'] ?? process.env.GLASH_SOURCE_UPLOAD_MODE ?? 'auto').toLowerCase();
+  if (['auto', 'direct', 'chunked'].includes(raw)) return raw;
+  throw new Error(`Unsupported --source-upload "${raw}". Use auto, direct, or chunked.`);
+}
+
+function shouldUseChunkedSourceUpload(sizeBytes, flags) {
+  const mode = sourceUploadMode(flags);
+  if (mode === 'direct') return false;
+  if (mode === 'chunked') return true;
+  return Number(sizeBytes) >= sourceUploadThresholdBytes(flags);
+}
+
+function sourceUploadThresholdBytes(flags) {
+  return parseByteSize(flags['source-threshold'] ?? process.env.GLASH_SOURCE_UPLOAD_THRESHOLD ?? '90mb');
+}
+
+function sourceUploadPartSize(value) {
+  const parsed = Number(value);
+  if (Number.isFinite(parsed) && parsed >= 5 * 1024 * 1024) return Math.round(parsed);
+  return 16 * 1024 * 1024;
+}
+
+async function detectProjectProfile(cwd, flags = {}) {
+  const forced = frameworkHint(flags);
+  if (forced) return { framework: forced, label: forced };
+  const pkg = await readPackageJson(cwd);
+  const deps = { ...(pkg?.dependencies ?? {}), ...(pkg?.devDependencies ?? {}) };
+  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' };
+  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' };
+  return { framework: 'static', label: 'Static' };
+}
+
+async function packageOverridesForProfile(cwd, profile) {
+  if (profile?.framework !== 'glashjs') return {};
+  const pkg = await readPackageJson(cwd);
+  if (!pkg) return {};
+  const scripts = { ...(pkg.scripts ?? {}) };
+  let changed = false;
+  if (!scripts.build) {
+    scripts.build = 'glash build';
+    changed = true;
+  }
+  if (!scripts.start) {
+    scripts.start = 'glash serve --port ${PORT:-3000}';
+    changed = true;
+  }
+  if (!changed) return {};
+  return {
+    'package.json': `${JSON.stringify({ ...pkg, scripts }, null, 2)}\n`,
+  };
+}
+
+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;
+  return /^[a-z0-9._-]{1,40}$/.test(normalized) ? normalized : '';
+}
+
+async function readPackageJson(cwd) {
+  try {
+    return JSON.parse(await readFile(join(cwd, 'package.json'), 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+async function existsAny(cwd, files) {
+  for (const file of files) {
+    try {
+      await access(join(cwd, file));
+      return true;
+    } catch {}
+  }
+  return false;
+}
+
 async function publicAssetFiles(cwd) {
   const entries = await fg('public/**/*', {
     cwd,
@@ -620,7 +823,7 @@ function parseByteSize(value) {
   if (typeof value === 'number') return value;
   const raw = String(value || '').trim().toLowerCase();
   const match = raw.match(/^(\d+(?:\.\d+)?)\s*(b|kb|kib|mb|mib|gb|gib)?$/);
-  if (!match) throw new Error(`Invalid asset threshold "${value}"`);
+  if (!match) throw new Error(`Invalid size "${value}"`);
   const amount = Number(match[1]);
   const unit = match[2] || 'b';
   const multiplier = unit === 'gb' || unit === 'gib'
@@ -805,6 +1008,7 @@ function printDeployReport(report) {
     ['Deployment ID', report.deploymentId || '-'],
     ['Target', report.target || 'production'],
     ['Source', report.source || '-'],
+    ['Framework', report.framework || 'auto'],
     ['Packages uploaded', formatPackagesUploaded(report)],
     ['Public assets', formatAssetSummary(report.assetSummary)],
     ['Deployment size', formatDeploymentSize(report)],
@@ -833,6 +1037,14 @@ function formatReportStatus(status) {
 
 function formatPackagesUploaded(report) {
   const count = report.packagesUploaded ?? 0;
+  if (report.sourceUpload?.mode === 'chunked') {
+    const files = report.filesIncluded ? ` (${report.filesIncluded.toLocaleString()} files included)` : '';
+    return `${count.toLocaleString()} source chunk${count === 1 ? '' : 's'}${files}`;
+  }
+  if (report.sourceUpload?.mode === 'direct') {
+    const files = report.filesIncluded ? ` (${report.filesIncluded.toLocaleString()} files included)` : '';
+    return `1 source bundle${files}`;
+  }
   const label = count === 1 ? 'source bundle' : 'source bundles';
   const files = report.filesIncluded
     ? ` (${report.filesIncluded.toLocaleString()} files included)`
@@ -949,6 +1161,9 @@ function createDeployIndicator() {
       if (!nextPhase) return;
       setProgress(progressFromPhase(nextPhase), nextPhase);
     },
+    setProgress(nextProgress, nextPhase = phase) {
+      setProgress(nextProgress, nextPhase);
+    },
     finish(finalPhase = 'complete') {
       stopTimer();
       phase = finalPhase;
@@ -978,6 +1193,7 @@ function progressFromPhase(phase) {
     syncing: 8,
     assets: 15,
     packaging: 22,
+    uploading: 28,
     glashing: 35,
     hatching: 45,
     waiting: 48,

package/lib/zip.mjs

@@ -4,7 +4,7 @@ import { createWriteStream } from 'node:fs';
 import { join, relative } from 'node:path';
 import fs from 'fs-extra';
 
-export async function zipDirectory(sourceDir, outPath, { ignore = [] } = {}) {
+export async function zipDirectory(sourceDir, outPath, { ignore = [], includeGlashOutput = false, overrides = {} } = {}) {
   // Default ignores
   const defaultIgnore = [
     'node_modules/**',
@@ -32,7 +32,7 @@ export async function zipDirectory(sourceDir, outPath, { ignore = [] } = {}) {
     'build/**',
     '**/build/**',
     'out/**',
-    '**/out/**',
+    ...(includeGlashOutput ? [] : ['**/out/**']),
     'coverage/**',
     '**/coverage/**',
     '.turbo/**',
@@ -43,8 +43,19 @@ export async function zipDirectory(sourceDir, outPath, { ignore = [] } = {}) {
     '**/.parcel-cache/**',
     '.vite/**',
     '**/.vite/**',
-    '.glash/**',
-    '**/.glash/**',
+    ...(includeGlashOutput
+      ? [
+          '.glash/project.json',
+          '**/.glash/project.json',
+          '.glash/credentials.json',
+          '**/.glash/credentials.json',
+          '.glash/cache/**',
+          '**/.glash/cache/**',
+        ]
+      : [
+          '.glash/**',
+          '**/.glash/**',
+        ]),
     '*.log',
     '**/*.log',
     'npm-debug.log*',
@@ -63,20 +74,21 @@ export async function zipDirectory(sourceDir, outPath, { ignore = [] } = {}) {
     '**/.env.development',
   ];
   const allIgnore = [...new Set([...defaultIgnore, ...loadIgnorePatterns(sourceDir), ...ignore])];
-  const files = await fg('**/*', {
+  const overridePaths = new Set(Object.keys(overrides));
+  const files = (await fg('**/*', {
     cwd: sourceDir,
     ignore: allIgnore,
     dot: true,
     onlyFiles: true,
     followSymbolicLinks: false,
-  });
+  })).filter((file) => !overridePaths.has(file));
 
   return new Promise((resolve, reject) => {
     const zip = new yazl.ZipFile();
     const output = createWriteStream(outPath);
     let bytes = 0;
 
-    output.on('close', () => resolve({ bytes, fileCount: files.length, files }));
+    output.on('close', () => resolve({ bytes, fileCount: files.length + overridePaths.size, files: [...files, ...overridePaths] }));
     output.on('error', reject);
     zip.outputStream.on('data', (chunk) => { bytes += chunk.length; });
     zip.outputStream.on('error', reject);
@@ -85,6 +97,9 @@ export async function zipDirectory(sourceDir, outPath, { ignore = [] } = {}) {
     for (const file of files) {
       zip.addFile(join(sourceDir, file), file);
     }
+    for (const [file, content] of Object.entries(overrides)) {
+      zip.addBuffer(Buffer.isBuffer(content) ? content : Buffer.from(String(content)), file);
+    }
     zip.end();
   });
 }

package/package.json

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