@glash/cli 0.2.27 → 0.2.29

package/README.md

@@ -60,6 +60,50 @@ source ~/.zshrc
 npm install -g glashdb
 ```
 
+## Deployable frameworks
+
+`glash deploy` works with more than Next.js. For Node projects, glashDB can infer a build from `package.json` and your lockfile. For anything else, include a `Dockerfile` and glashDB will build and run the container.
+
+Common Node and frontend targets:
+
+| Framework or runtime | Notes |
+| --- | --- |
+| 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 |
+| Svelte | Works with Svelte and SvelteKit projects |
+| Astro | Works for static or server-rendered Astro projects when the start command is configured |
+| Static sites | Plain HTML/CSS/JS, generated static output, and Hugo-style sites |
+| Node servers | Express, Fastify, NestJS, Hono, and other servers that expose a start script |
+
+Containerized targets:
+
+| Framework or runtime | Requirement |
+| --- | --- |
+| Django, FastAPI, Flask | Add a `Dockerfile` that starts the Python app |
+| Laravel, Rails | Add a `Dockerfile` with the app server and required runtime setup |
+| Go, Rust, Java, Spring | Add a `Dockerfile` that builds and runs the service |
+| Any custom runtime | Add a valid `Dockerfile` and expose the listening port |
+
+Deployment checklist:
+
+- Add a `build` script if your app needs a production build.
+- Add a `start` script for Node apps, or provide `server.js` / `index.js`.
+- Add a `Dockerfile` for non-Node apps or custom runtime needs.
+- 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.
+
+Large public folders:
+
+```bash
+# Always offload public/ before building
+glash deploy --asset-mode offload
+
+# Offload only when public/ exceeds the threshold
+glash deploy --asset-mode auto --asset-threshold 100mb
+```
+
 ## Commands
 
 | Command | Purpose |
@@ -75,6 +119,7 @@ npm install -g glashdb
 | `glash link <slug>` | Link the current directory to an existing project |
 | `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 deployments` | List recent deployments |
 | `glash status <id>` | Show a deployment's pipeline + events |
 | `glash logs <id>` | Alias of `status` |
@@ -130,6 +175,7 @@ The commands require PostgreSQL client tools locally: `pg_dump` for dumps,
 | --- | --- | --- |
 | `GLASH_API_URL` | `https://api.glashdb.com/api` | Override the API base (self-hosted, staging) |
 | `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` |
 
 ## Requirements
 

package/bin/glash.mjs

@@ -98,6 +98,8 @@ ${color.bold('FLAGS')}
   --environment <name>        Env-var environment (default: production)
   --env-file <file[,file]>    Env file(s) to sync before deploy
   --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)
   --help, -h                  Show this help
   --version, -v               Show CLI version
 

package/commands/deploy.mjs

@@ -1,11 +1,13 @@
 import { apiGet, apiPost } from '../lib/api.mjs';
 import { readProjectLink, writeProjectLink } from '../lib/config.mjs';
 import { ok, fail, info, warn, color, prompt } from '../lib/ui.mjs';
+import fg from 'fast-glob';
 import { execSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
 import { zipDirectory } from '../lib/zip.mjs';
-import { join, basename } from 'node:path';
+import { join, basename, extname } from 'node:path';
 import { tmpdir } from 'node:os';
-import { openAsBlob } from 'node:fs';
+import { createReadStream, openAsBlob } from 'node:fs';
 import { access, readFile, rm, stat } from 'node:fs/promises';
 import { stdout } from 'node:process';
 
@@ -135,27 +137,65 @@ export async function deploy({ flags }) {
 
   let dep;
   let envSummary = { count: 0, skipped: Boolean(flags['no-env']) };
+  let assetSummary = { mode: assetMode(flags), offloaded: false, count: 0, bytes: 0, skipped: 0 };
   let currentPhase = 'doing';
   const start = Date.now();
   const indicator = createDeployIndicator();
+  const report = {
+    status: 'running',
+    projectId,
+    deploymentId: '',
+    target,
+    source: remoteDeploy ? 'remote git deploy' : 'local upload',
+    packagesUploaded: 0,
+    filesIncluded: 0,
+    deploymentSizeBytes: 0,
+    envSummary,
+    assetSummary,
+    liveUrl: '',
+    error: '',
+    start,
+  };
   indicator.start(currentPhase);
 
   if (!flags['no-env']) {
     indicator.setPhase('syncing');
     try {
       envSummary = await syncEnvBeforeDeploy(projectId, target, flags);
+      report.envSummary = envSummary;
     } catch (e) {
-      indicator.stop();
+      indicator.fail('failed');
+      report.envSummary = envSummary;
+      printDeployReport({ ...report, status: 'failed', error: `Env sync failed: ${e.message}` });
       return fail(`Env sync failed: ${e.message}`);
     }
   }
+
+  if (!remoteDeploy && assetSummary.mode !== 'inline') {
+    indicator.setPhase('assets');
+    try {
+      assetSummary = await offloadPublicAssetsBeforeDeploy(projectId, flags);
+      report.assetSummary = assetSummary;
+    } catch (e) {
+      indicator.fail('failed');
+      printDeployReport({ ...report, assetSummary, status: 'failed', error: `Public asset offload failed: ${e.message}` });
+      return fail(`Public asset offload failed: ${e.message}`);
+    }
+  } else if (assetSummary.mode !== 'inline') {
+    indicator.fail('failed');
+    const message = '--asset-mode is only available for local source uploads, not remote git deploys.';
+    printDeployReport({ ...report, status: 'failed', error: message });
+    return fail(message);
+  }
   
   if (!remoteDeploy) {
     indicator.setPhase('packaging');
     const zipPath = join(tmpdir(), `glash-deploy-${Date.now()}.zip`);
     try {
-      await zipDirectory(process.cwd(), zipPath);
-      await stat(zipPath);
+      const bundle = await zipDirectory(process.cwd(), zipPath, { ignore: assetSummary.offloaded ? ['public/**'] : [] });
+      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');
@@ -166,24 +206,30 @@ export async function deploy({ flags }) {
 
       indicator.setPhase('glashing');
       dep = await apiPost('/deployments/upload', formData);
+      report.deploymentId = dep?.id ?? '';
+      report.packagesUploaded = 1;
       await rm(zipPath, { force: true }).catch(() => {});
     } catch (e) {
       await rm(zipPath, { force: true }).catch(() => {});
-      indicator.stop();
+      indicator.fail('failed');
+      printDeployReport({ ...report, status: 'failed', error: `Upload failed: ${e.message}` });
       return fail(`Upload failed: ${e.message}`);
     }
   } else {
     indicator.setPhase('hatching');
     try {
       dep = await apiPost('/deployments', { projectId, commitHash, gitBranch, target });
+      report.deploymentId = dep?.id ?? '';
     } catch (e) {
-      indicator.stop();
+      indicator.fail('failed');
+      printDeployReport({ ...report, status: 'failed', error: e.message });
       return fail(e.message);
     }
   }
   
   if (flags.detach || flags.D) {
-    indicator.stop();
+    indicator.fail('queued');
+    printDeployReport({ ...report, status: 'queued' });
     info(`Queued: ${color.dim(dep.id)}`);
     info(`Track it with: ${color.cyan(`glash status ${dep.id}`)}`);
     return;
@@ -203,7 +249,7 @@ export async function deploy({ flags }) {
       if (e.status === 429) {
         const wait = Math.min(Math.max(e.retryAfterMs ?? pollDelayMs * 2, 10000), 60000);
         pollDelayMs = wait;
-        await sleep(wait);
+        await indicator.wait(wait);
         continue;
       }
       if (Date.now() - lastProgressAt > 60_000) {
@@ -211,7 +257,7 @@ export async function deploy({ flags }) {
         lastProgressAt = Date.now();
       }
       pollDelayMs = Math.min(Math.max(pollDelayMs * 1.5, 5000), 30000);
-      await sleep(pollDelayMs);
+      await indicator.wait(pollDelayMs);
       continue;
     }
 
@@ -229,28 +275,34 @@ export async function deploy({ flags }) {
       const url = pipe.hostings?.[0]?.domains?.[0]?.domain;
       if (url) {
         indicator.setPhase('checking');
-        const problem = await waitForLiveUrlProblem(`https://${url.replace(/^https?:\/\//, '')}`);
-        indicator.stop();
+        report.liveUrl = normalizeLiveUrl(url);
+        const problem = await waitForLiveUrlProblem(report.liveUrl);
         if (problem) {
+          indicator.fail('failed');
+          printDeployReport({ ...report, status: 'failed', error: `Live URL check failed: ${problem}` });
           return fail(`Deployment finished, but the hostname is still not serving your app: ${problem}. Run \`glash logs ${dep.id}\` for details.`);
         }
       } else {
-        indicator.stop();
+        report.liveUrl = '';
       }
-      printDeploySuccess({ url, envSummary });
+      indicator.finish('complete');
+      printDeployReport({ ...report, status: 'successful' });
+      ok('Deployment live');
       return;
     }
     if (status === 'placeholder') {
-      indicator.stop();
       const lastPlaceholder = [...(pipe.events ?? [])].reverse().find((ev) => ev.status === 'placeholder' || ev.step === 'deploy');
       const detail = lastPlaceholder?.message ? `: ${lastPlaceholder.message}` : '';
+      indicator.fail('failed');
+      printDeployReport({ ...report, status: 'failed', error: `Deployment reached the glashDB parked page, not your app${detail}` });
       return fail(`Deployment reached the glashDB parked page, not your app${detail}. Run \`glash logs ${dep.id}\` for details.`);
     }
     if (['error', 'failed'].includes(status)) {
-      indicator.stop();
       const lastError = [...(pipe.events ?? [])].reverse().find((ev) => ev.status === 'error' || ev.status === 'failed');
       const rawDetail = lastError?.message ? `: ${lastError.message}` : '';
       const detail = `${rawDetail}${deploymentFailureHint(lastError?.message)}`;
+      indicator.fail('failed');
+      printDeployReport({ ...report, status: 'failed', error: `Deployment failed (${status})${rawDetail}` });
       return fail(`Deployment failed (${status})${detail}. Run \`glash logs ${dep.id}\` for details.`);
     }
     currentPhase = phaseFromPipeline(pipe, currentPhase);
@@ -258,7 +310,8 @@ export async function deploy({ flags }) {
     pollDelayMs = nextPollDelay(pipe);
     await indicator.wait(pollDelayMs);
   }
-  indicator.stop();
+  indicator.fail('timed out');
+  printDeployReport({ ...report, status: 'timed out', error: `Waited ${formatDuration(timeoutMs)} for deployment to finish` });
   warn(`Timed out after ${formatDuration(timeoutMs)} waiting for deployment. Check \`glash status ${dep.id}\`.`);
 }
 
@@ -280,6 +333,163 @@ async function syncEnvBeforeDeploy(projectId, target, flags) {
   return { count: vars.length, files };
 }
 
+async function offloadPublicAssetsBeforeDeploy(projectId, flags) {
+  const mode = assetMode(flags);
+  const empty = { mode, offloaded: false, count: 0, bytes: 0, skipped: 0 };
+  if (mode === 'inline') return empty;
+
+  const files = await publicAssetFiles(process.cwd());
+  if (!files.length) return empty;
+
+  const totalBytes = files.reduce((sum, file) => sum + file.sizeBytes, 0);
+  const threshold = assetOffloadThresholdBytes(flags);
+  if (mode === 'auto' && totalBytes < threshold) {
+    return { ...empty, bytes: totalBytes };
+  }
+
+  const assets = [];
+  for (const file of files) {
+    assets.push({
+      path: file.path,
+      sizeBytes: file.sizeBytes,
+      sha256: await hashFile(file.absolutePath),
+      contentType: contentTypeFor(file.path),
+    });
+  }
+
+  let uploaded = 0;
+  let skipped = 0;
+  for (const batch of chunk(assets, 100)) {
+    const prepared = await apiPost(`/projects/${projectId}/public-assets/prepare`, { assets: batch });
+    for (const asset of prepared.assets ?? []) {
+      if (asset.skipped) {
+        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(() => '');
+        throw new Error(`Upload ${asset.path} failed with HTTP ${res.status}${detail ? `: ${detail.slice(0, 200)}` : ''}`);
+      }
+      uploaded += 1;
+    }
+    await apiPost(`/projects/${projectId}/public-assets/complete`, { assets: batch });
+  }
+
+  return {
+    mode,
+    offloaded: true,
+    count: assets.length,
+    uploaded,
+    skipped,
+    bytes: totalBytes,
+  };
+}
+
+function assetMode(flags) {
+  const raw = String(flags['asset-mode'] ?? flags.assets ?? flags['public-assets'] ?? 'inline').toLowerCase();
+  if (['inline', 'offload', 'auto'].includes(raw)) return raw;
+  throw new Error(`Unsupported --asset-mode "${raw}". Use inline, auto, or offload.`);
+}
+
+async function publicAssetFiles(cwd) {
+  const entries = await fg('public/**/*', {
+    cwd,
+    onlyFiles: true,
+    dot: true,
+    followSymbolicLinks: false,
+  });
+  const out = [];
+  for (const entry of entries) {
+    const absolutePath = join(cwd, entry);
+    const s = await stat(absolutePath);
+    out.push({
+      path: entry.replace(/^public\//, ''),
+      absolutePath,
+      sizeBytes: s.size,
+    });
+  }
+  return out;
+}
+
+function hashFile(file) {
+  return new Promise((resolve, reject) => {
+    const hash = createHash('sha256');
+    const stream = createReadStream(file);
+    stream.on('data', (chunk) => hash.update(chunk));
+    stream.on('error', reject);
+    stream.on('end', () => resolve(hash.digest('hex')));
+  });
+}
+
+function contentTypeFor(path) {
+  const ext = extname(path).toLowerCase();
+  const types = {
+    '.avif': 'image/avif',
+    '.css': 'text/css; charset=utf-8',
+    '.gif': 'image/gif',
+    '.html': 'text/html; charset=utf-8',
+    '.ico': 'image/x-icon',
+    '.jpeg': 'image/jpeg',
+    '.jpg': 'image/jpeg',
+    '.js': 'text/javascript; charset=utf-8',
+    '.json': 'application/json',
+    '.m4v': 'video/x-m4v',
+    '.map': 'application/json',
+    '.mp3': 'audio/mpeg',
+    '.mp4': 'video/mp4',
+    '.ogg': 'audio/ogg',
+    '.otf': 'font/otf',
+    '.pdf': 'application/pdf',
+    '.png': 'image/png',
+    '.svg': 'image/svg+xml',
+    '.ttf': 'font/ttf',
+    '.txt': 'text/plain; charset=utf-8',
+    '.wav': 'audio/wav',
+    '.webm': 'video/webm',
+    '.webp': 'image/webp',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.xml': 'application/xml',
+  };
+  return types[ext] || 'application/octet-stream';
+}
+
+function assetOffloadThresholdBytes(flags) {
+  return parseByteSize(flags['asset-threshold'] ?? process.env.GLASH_ASSET_OFFLOAD_THRESHOLD ?? '100mb');
+}
+
+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}"`);
+  const amount = Number(match[1]);
+  const unit = match[2] || 'b';
+  const multiplier = unit === 'gb' || unit === 'gib'
+    ? 1024 ** 3
+    : unit === 'mb' || unit === 'mib'
+      ? 1024 ** 2
+      : unit === 'kb' || unit === 'kib'
+        ? 1024
+        : 1;
+  return Math.round(amount * multiplier);
+}
+
+function chunk(items, size) {
+  const out = [];
+  for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));
+  return out;
+}
+
 async function resolveEnvFiles(target, flags) {
   if (flags['env-file']) {
     const files = String(flags['env-file']).split(',').map((f) => f.trim()).filter(Boolean);
@@ -416,12 +626,86 @@ function isTransientLiveUrlProblem(problem) {
   return /no nginx route|parked page|HTTP 5\d\d|live URL check failed/i.test(problem);
 }
 
-function printDeploySuccess({ url, envSummary }) {
-  const liveUrl = url ? `https://${url.replace(/^https?:\/\//, '')}` : '';
-  if (liveUrl) info(`Live: ${terminalLink(liveUrl)}`);
-  const envText = envSummary?.skipped ? 'skipped' : `${envSummary?.count ?? 0} moved to glash`;
-  info(`Env: ${envText}`);
-  ok('Success');
+function normalizeLiveUrl(url) {
+  return url ? `https://${String(url).replace(/^https?:\/\//, '')}` : '';
+}
+
+function printDeployReport(report) {
+  const elapsedMs = Date.now() - report.start;
+  const liveUrl = report.liveUrl ? terminalLink(report.liveUrl) : '-';
+  const rows = [
+    ['Status', formatReportStatus(report.status)],
+    ['Deployment ID', report.deploymentId || '-'],
+    ['Target', report.target || 'production'],
+    ['Source', report.source || '-'],
+    ['Packages uploaded', formatPackagesUploaded(report)],
+    ['Public assets', formatAssetSummary(report.assetSummary)],
+    ['Deployment size', formatDeploymentSize(report)],
+    ['Total time spent', formatMinutes(elapsedMs)],
+    ['Live URL', liveUrl],
+    ['Environment', formatEnvSummary(report.envSummary)],
+  ];
+  if (report.error) rows.push(['Error', report.error]);
+
+  const width = rows.reduce((max, [label]) => Math.max(max, label.length), 0);
+  info('');
+  info(color.bold('Deployment report'));
+  for (const [label, value] of rows) {
+    info(`  ${color.dim(label.padEnd(width))}  ${value}`);
+  }
+}
+
+function formatReportStatus(status) {
+  if (status === 'successful') return color.green('successful');
+  if (status === 'queued') return color.yellow('queued');
+  if (status === 'timed out') return color.yellow('timed out');
+  if (status === 'failed') return color.red('failed');
+  return status || '-';
+}
+
+function formatPackagesUploaded(report) {
+  const count = report.packagesUploaded ?? 0;
+  const label = count === 1 ? 'source bundle' : 'source bundles';
+  const files = report.filesIncluded
+    ? ` (${report.filesIncluded.toLocaleString()} files included)`
+    : (report.source === 'remote git deploy' ? ' (remote source)' : '');
+  return `${count.toLocaleString()} ${label}${files}`;
+}
+
+function formatAssetSummary(assetSummary) {
+  if (!assetSummary || assetSummary.mode === 'inline') return 'inline';
+  if (!assetSummary.offloaded) {
+    const size = assetSummary.bytes ? ` (${formatBytes(assetSummary.bytes)})` : '';
+    return `${assetSummary.mode}, no offload${size}`;
+  }
+  const uploaded = assetSummary.uploaded ?? Math.max(0, (assetSummary.count ?? 0) - (assetSummary.skipped ?? 0));
+  const skipped = assetSummary.skipped ? `, ${assetSummary.skipped.toLocaleString()} reused` : '';
+  return `${assetSummary.count.toLocaleString()} offloaded (${formatBytes(assetSummary.bytes)}; ${uploaded.toLocaleString()} uploaded${skipped})`;
+}
+
+function formatDeploymentSize(report) {
+  if (report.deploymentSizeBytes) return formatBytes(report.deploymentSizeBytes);
+  return report.source === 'remote git deploy' ? 'not measured for remote deploy' : '-';
+}
+
+function formatEnvSummary(envSummary) {
+  if (envSummary?.skipped) return 'skipped';
+  const count = envSummary?.count ?? 0;
+  return `${count.toLocaleString()} variable${count === 1 ? '' : 's'} synced`;
+}
+
+function formatMinutes(ms) {
+  const minutes = ms / 60_000;
+  const rounded = minutes < 10 ? minutes.toFixed(2) : minutes.toFixed(1);
+  return `${rounded} min (${formatDuration(ms)})`;
+}
+
+function formatBytes(bytes) {
+  if (!Number.isFinite(bytes) || bytes <= 0) return '-';
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+  return `${(bytes / 1024 / 1024 / 1024).toFixed(2)} GB`;
 }
 
 function terminalLink(url) {
@@ -432,42 +716,71 @@ function terminalLink(url) {
 
 function createDeployIndicator() {
   const interactive = Boolean(stdout.isTTY);
-  let frame = 0;
   let timer;
   let phase = 'doing';
-  let printedPhase = '';
-  const frames = ['.', '..', '...'];
+  let progress = 0;
+  let lastPrinted = '';
 
   function message() {
-    const dots = frames[frame++ % frames.length].padEnd(3, ' ');
-    return color.dim(`${phase}${dots}`);
+    const width = 24;
+    const filled = Math.round((progress / 100) * width);
+    const bar = `${'#'.repeat(filled)}${'-'.repeat(width - filled)}`;
+    const percent = `${String(Math.round(progress)).padStart(3, ' ')}%`;
+    return `${color.dim(`[${bar}]`)} ${percent} ${phase}`;
   }
 
   function render({ force = false } = {}) {
+    const next = message();
     if (!interactive) {
-      if (force && phase !== printedPhase) {
-        printedPhase = phase;
-        info(message().trimEnd());
+      if (force && next !== lastPrinted) {
+        lastPrinted = next;
+        info(next);
       }
       return;
     }
-    stdout.write(`\r\x1b[2K${message()}`);
+    stdout.write(`\r\x1b[2K${next}`);
+  }
+
+  function stopTimer() {
+    if (timer) clearInterval(timer);
+    timer = undefined;
+  }
+
+  function setProgress(nextProgress, nextPhase = phase) {
+    const bounded = Math.max(0, Math.min(100, Number(nextProgress) || 0));
+    const advanced = Math.max(progress, bounded);
+    const changed = nextPhase !== phase || advanced !== progress;
+    phase = nextPhase;
+    progress = advanced;
+    if (changed) render({ force: true });
   }
 
   return {
     start(initialPhase = 'doing') {
       phase = initialPhase;
-      render();
+      progress = 0;
+      render({ force: true });
       timer = setInterval(render, 1000);
     },
     setPhase(nextPhase) {
-      if (!nextPhase || nextPhase === phase) return;
-      phase = nextPhase;
+      if (!nextPhase) return;
+      setProgress(progressFromPhase(nextPhase), nextPhase);
+    },
+    finish(finalPhase = 'complete') {
+      stopTimer();
+      phase = finalPhase;
+      progress = 100;
       render({ force: true });
+      if (interactive) stdout.write('\n');
+    },
+    fail(finalPhase = 'failed') {
+      stopTimer();
+      phase = finalPhase;
+      render({ force: true });
+      if (interactive) stdout.write('\n');
     },
     stop() {
-      if (timer) clearInterval(timer);
-      timer = undefined;
+      stopTimer();
       if (interactive) stdout.write('\r\x1b[2K');
     },
     wait(ms) {
@@ -476,4 +789,21 @@ function createDeployIndicator() {
   };
 }
 
+function progressFromPhase(phase) {
+  const progressByPhase = {
+    doing: 2,
+    syncing: 8,
+    assets: 15,
+    packaging: 22,
+    glashing: 35,
+    hatching: 45,
+    waiting: 48,
+    building: 65,
+    deploying: 82,
+    routing: 90,
+    checking: 96,
+  };
+  return progressByPhase[phase] ?? 50;
+}
+
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

package/lib/zip.mjs

@@ -76,7 +76,7 @@ export async function zipDirectory(sourceDir, outPath, { ignore = [] } = {}) {
     const output = createWriteStream(outPath);
     let bytes = 0;
 
-    output.on('close', () => resolve(bytes));
+    output.on('close', () => resolve({ bytes, fileCount: files.length, files }));
     output.on('error', reject);
     zip.outputStream.on('data', (chunk) => { bytes += chunk.length; });
     zip.outputStream.on('error', reject);

package/package.json

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