@glash/cli 0.2.26 → 0.2.28

package/commands/deploy.mjs

@@ -138,14 +138,31 @@ export async function deploy({ flags }) {
   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,
+    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}`);
     }
   }
@@ -154,8 +171,10 @@ export async function deploy({ flags }) {
     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);
+      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 +185,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 +228,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 +236,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 +254,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 +289,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}\`.`);
 }
 
@@ -416,12 +448,74 @@ 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)],
+    ['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 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 +526,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 +599,20 @@ function createDeployIndicator() {
   };
 }
 
+function progressFromPhase(phase) {
+  const progressByPhase = {
+    doing: 2,
+    syncing: 8,
+    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.26",
+  "version": "0.2.28",
   "description": "glashDB command-line interface — deploy projects, pull source + env, manage env vars.",
   "license": "Apache-2.0",
   "homepage": "https://glashdb.com",