@glash/cli 0.2.31 → 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:
 
@@ -105,6 +107,22 @@ 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
 
@@ -122,6 +140,7 @@ Every deploy prints a live monitor link. Open it to watch the black-screen deplo
 | `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` |
@@ -179,6 +198,9 @@ The commands require PostgreSQL client tools locally: `pg_dump` for dumps,
 | `GLASH_APP_URL` | `https://glashdb.com` | Override the dashboard base used for live monitor links |
 | `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) {
@@ -370,10 +396,10 @@ async function offloadPublicAssetsBeforeDeploy(projectId, flags) {
 
   let uploaded = 0;
   let skipped = 0;
-  for (const batch of chunk(assets, 100)) {
+  for (const batch of chunk(assets, publicAssetBatchSize(flags))) {
     let prepared;
     try {
-      prepared = await apiPost(`/projects/${projectId}/public-assets/prepare`, { assets: batch });
+      prepared = await apiPost(`/projects/${projectId}/public-assets/prepare`, { assets: batch }, { timeoutMs: 120_000 });
     } catch (e) {
       throw assetOffloadFailure(e, { mode, status: 'prepare-failed', offloaded: false, count: assets.length, uploaded, skipped, bytes: totalBytes });
     }
@@ -382,26 +408,20 @@ async function offloadPublicAssetsBeforeDeploy(projectId, flags) {
         skipped += 1;
         continue;
       }
-      if (!asset.uploadUrl) throw new Error(`No upload URL returned for ${asset.path}`);
       const local = assets.find((item) => item.path === asset.path);
       if (!local) throw new Error(`Prepared unknown asset ${asset.path}`);
-      const blob = await openAsBlob(join(process.cwd(), 'public', asset.path), { type: local.contentType });
-      const res = await fetch(asset.uploadUrl, {
-        method: asset.method || 'PUT',
-        headers: { 'Content-Type': local.contentType },
-        body: blob,
-      });
-      if (!res.ok) {
-        const detail = await res.text().catch(() => '');
+      try {
+        await uploadPreparedPublicAsset(asset, local);
+      } catch (e) {
         throw assetOffloadFailure(
-          new Error(`Upload ${asset.path} failed with HTTP ${res.status}${detail ? `: ${detail.slice(0, 200)}` : ''}`),
+          e,
           { mode, status: 'upload-failed', offloaded: false, count: assets.length, uploaded, skipped, bytes: totalBytes },
         );
       }
       uploaded += 1;
     }
     try {
-      await apiPost(`/projects/${projectId}/public-assets/complete`, { assets: batch });
+      await apiPost(`/projects/${projectId}/public-assets/complete`, { assets: batch }, { timeoutMs: 120_000 });
     } catch (e) {
       throw assetOffloadFailure(e, { mode, status: 'complete-failed', offloaded: false, count: assets.length, uploaded, skipped, bytes: totalBytes });
     }
@@ -418,6 +438,200 @@ async function offloadPublicAssetsBeforeDeploy(projectId, flags) {
   };
 }
 
+async function uploadPreparedPublicAsset(asset, local) {
+  if (asset.uploadKind === 'multipart' || asset.uploadPartUrl || asset.completeMultipartUrl) {
+    return uploadMultipartPublicAsset(asset, local);
+  }
+  if (!asset.uploadUrl) throw new Error(`No upload URL returned for ${asset.path}`);
+  const blob = await openAsBlob(join(process.cwd(), 'public', asset.path), { type: local.contentType });
+  const res = await fetchWithRetries(asset.uploadUrl, {
+    method: asset.method || 'PUT',
+    headers: { 'Content-Type': local.contentType },
+    body: blob,
+  }, { timeoutMs: uploadTimeoutMsFor(local.sizeBytes) });
+  if (!res.ok) {
+    const detail = await res.text().catch(() => '');
+    throw new Error(`Upload ${asset.path} failed with HTTP ${res.status}${detail ? `: ${detail.slice(0, 200)}` : ''}`);
+  }
+}
+
+async function uploadMultipartPublicAsset(asset, local) {
+  if (!asset.uploadPartUrl || !asset.completeMultipartUrl || !asset.uploadId) {
+    throw new Error(`Multipart upload details missing for ${asset.path}`);
+  }
+  const partSize = publicAssetPartSize(asset.partSize);
+  const blob = await openAsBlob(join(process.cwd(), 'public', asset.path), { type: local.contentType });
+  const parts = [];
+  let partNumber = 1;
+  for (let offset = 0; offset < local.sizeBytes; offset += partSize) {
+    const end = Math.min(offset + partSize, local.sizeBytes);
+    const partUrl = withQueryParam(asset.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(`Upload ${asset.path} 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(`Upload ${asset.path} part ${partNumber} did not return a multipart ETag`);
+    }
+    parts.push({ partNumber: Number(part.partNumber), etag: String(part.etag) });
+    partNumber += 1;
+  }
+
+  const complete = await fetchWithRetries(asset.completeMultipartUrl, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ parts }),
+  }, { timeoutMs: 120_000 });
+  if (!complete.ok) {
+    const detail = await complete.text().catch(() => '');
+    throw new Error(`Completing multipart upload for ${asset.path} failed with HTTP ${complete.status}${detail ? `: ${detail.slice(0, 200)}` : ''}`);
+  }
+}
+
+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
+  while (true) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+    try {
+      const res = await fetch(url, { ...init, signal: ctrl.signal });
+      clearTimeout(timer);
+      if (res.ok || !isRetryableUploadStatus(res.status) || attempt >= retries) return res;
+      await res.body?.cancel?.().catch(() => {});
+    } catch (error) {
+      clearTimeout(timer);
+      if (attempt >= retries) throw error;
+    }
+    await sleep(uploadBackoffMs(attempt));
+    attempt += 1;
+  }
+}
+
+function isRetryableUploadStatus(status) {
+  return [408, 425, 429, 500, 502, 503, 504, 522, 524].includes(Number(status));
+}
+
+function uploadBackoffMs(attempt) {
+  const base = Math.min(1000 * 2 ** attempt, 10000);
+  return Math.round(base * (0.75 + Math.random() * 0.5));
+}
+
+function withQueryParam(url, key, value) {
+  const next = new URL(url);
+  next.searchParams.set(key, value);
+  return next.toString();
+}
+
+function uploadTimeoutMsFor(bytes) {
+  const size = Number(bytes) || 0;
+  return Math.max(120_000, Math.min(15 * 60_000, Math.ceil(size / (1024 * 1024)) * 15_000));
+}
+
+function publicAssetPartSize(value) {
+  const parsed = Number(value);
+  if (Number.isFinite(parsed) && parsed >= 5 * 1024 * 1024) return Math.round(parsed);
+  return 16 * 1024 * 1024;
+}
+
 function assetOffloadFailure(error, assetSummary) {
   const message = friendlyAssetOffloadError(error);
   const wrapped = new Error(message);
@@ -444,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,
@@ -511,11 +812,18 @@ function assetOffloadThresholdBytes(flags) {
   return parseByteSize(flags['asset-threshold'] ?? process.env.GLASH_ASSET_OFFLOAD_THRESHOLD ?? '100mb');
 }
 
+function publicAssetBatchSize(flags) {
+  const raw = flags['asset-batch-size'] ?? process.env.GLASH_ASSET_BATCH_SIZE ?? '50';
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < 1) return 50;
+  return Math.max(1, Math.min(250, Math.floor(parsed)));
+}
+
 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'
@@ -700,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)],
@@ -728,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)`
@@ -844,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;
@@ -873,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.31",
+  "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",