@glash/cli 0.2.30 → 0.2.32

package/README.md

@@ -104,6 +104,9 @@ glash deploy --asset-mode offload
 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
 
 | Command | Purpose |
@@ -174,8 +177,10 @@ The commands require PostgreSQL client tools locally: `pg_dump` for dumps,
 | Variable | Default | Notes |
 | --- | --- | --- |
 | `GLASH_API_URL` | `https://api.glashdb.com/api` | Override the API base (self-hosted, staging) |
+| `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

@@ -135,6 +135,8 @@ 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 monitorStartedAt = Date.now();
+  const initialStatusUrl = deployMonitorUrl({ projectId, after: monitorStartedAt });
 
   let dep;
   let envSummary = { count: 0, skipped: Boolean(flags['no-env']) };
@@ -154,9 +156,11 @@ export async function deploy({ flags }) {
     envSummary,
     assetSummary,
     liveUrl: '',
+    statusUrl: initialStatusUrl,
     error: '',
     start,
   };
+  info(`Live status: ${terminalLink(initialStatusUrl)}`);
   indicator.start(currentPhase);
 
   if (!flags['no-env']) {
@@ -211,6 +215,7 @@ export async function deploy({ flags }) {
       indicator.setPhase('glashing');
       dep = await apiPost('/deployments/upload', formData);
       report.deploymentId = dep?.id ?? '';
+      report.statusUrl = deployMonitorUrl({ deploymentId: dep?.id, projectId, after: monitorStartedAt });
       report.packagesUploaded = 1;
       await rm(zipPath, { force: true }).catch(() => {});
     } catch (e) {
@@ -224,6 +229,7 @@ export async function deploy({ flags }) {
     try {
       dep = await apiPost('/deployments', { projectId, commitHash, gitBranch, target });
       report.deploymentId = dep?.id ?? '';
+      report.statusUrl = deployMonitorUrl({ deploymentId: dep?.id, projectId, after: monitorStartedAt });
     } catch (e) {
       indicator.fail('failed');
       printDeployReport({ ...report, status: 'failed', error: e.message });
@@ -235,6 +241,7 @@ export async function deploy({ flags }) {
     indicator.fail('queued');
     printDeployReport({ ...report, status: 'queued' });
     info(`Queued: ${color.dim(dep.id)}`);
+    info(`Watch live: ${terminalLink(report.statusUrl)}`);
     info(`Track it with: ${color.cyan(`glash status ${dep.id}`)}`);
     return;
   }
@@ -363,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 });
     }
@@ -375,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 });
     }
@@ -411,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);
@@ -504,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();
@@ -667,6 +779,23 @@ function normalizeLiveUrl(url) {
   return url ? `https://${String(url).replace(/^https?:\/\//, '')}` : '';
 }
 
+function deployMonitorUrl({ deploymentId, projectId, after } = {}) {
+  const base = appBaseUrl();
+  if (deploymentId) return `${base}/app/deploy/live/${encodeURIComponent(deploymentId)}`;
+  const url = new URL(`${base}/app/deploy/live`);
+  if (projectId) url.searchParams.set('projectId', projectId);
+  if (after) url.searchParams.set('after', String(after));
+  return url.toString();
+}
+
+function appBaseUrl() {
+  const configured = process.env.GLASH_APP_URL?.trim().replace(/\/$/, '');
+  if (configured) return configured;
+  const api = process.env.GLASH_API_URL || '';
+  if (/^https?:\/\/(localhost|127\.0\.0\.1|\[::1\])/i.test(api)) return 'http://localhost:3000';
+  return 'https://glashdb.com';
+}
+
 function printDeployReport(report) {
   const elapsedMs = Date.now() - report.start;
   const liveUrl = report.liveUrl ? terminalLink(report.liveUrl) : '-';
@@ -680,6 +809,7 @@ function printDeployReport(report) {
     ['Public assets', formatAssetSummary(report.assetSummary)],
     ['Deployment size', formatDeploymentSize(report)],
     ['Total time spent', formatMinutes(elapsedMs)],
+    ['Status link', report.statusUrl ? terminalLink(report.statusUrl) : '-'],
     ['Live URL', liveUrl],
     ['Environment', formatEnvSummary(report.envSummary)],
   ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glash/cli",
-  "version": "0.2.30",
+  "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",