@glash/cli 0.2.31 → 0.2.32

package/README.md

@@ -105,6 +105,7 @@ 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.
 
 ## Commands
 
@@ -179,6 +180,7 @@ 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` |
 
 ## Requirements
 

package/commands/deploy.mjs

@@ -370,10 +370,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 +382,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 +412,110 @@ 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 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);
@@ -511,6 +609,13 @@ 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();

package/package.json

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