@glash/cli 0.2.21 → 0.2.23

package/commands/deploy.mjs

@@ -129,22 +129,28 @@ export async function deploy({ flags }) {
   const target = flags.prod || flags.production ? 'production' : (flags.target || 'production');
 
   let dep;
+  let envSummary = { count: 0, skipped: Boolean(flags['no-env']) };
+  let currentPhase = 'doing';
+  const start = Date.now();
+  const indicator = createDeployIndicator();
+  indicator.start(currentPhase);
 
   if (!flags['no-env']) {
+    indicator.setPhase('syncing');
     try {
-      await syncEnvBeforeDeploy(projectId, target, flags);
+      envSummary = await syncEnvBeforeDeploy(projectId, target, flags);
     } catch (e) {
+      indicator.stop();
       return fail(`Env sync failed: ${e.message}`);
     }
   }
   
   if (!remoteDeploy) {
-    info(color.dim(`→ uploading local source for project ${projectId} (${target})`));
+    indicator.setPhase('packaging');
     const zipPath = join(tmpdir(), `glash-deploy-${Date.now()}.zip`);
     try {
       await zipDirectory(process.cwd(), zipPath);
-      const zipStat = await stat(zipPath);
-      info(color.dim(`→ source bundle ${(zipStat.size / 1024 / 1024).toFixed(1)} MB`));
+      await stat(zipPath);
       const formData = new FormData();
       formData.append('projectId', projectId);
       formData.append('file', await openAsBlob(zipPath, { type: 'application/zip' }), 'project.zip');
@@ -153,38 +159,37 @@ export async function deploy({ flags }) {
       formData.append('gitBranch', gitBranch || '');
       formData.append('target', target);
 
+      indicator.setPhase('glashing');
       dep = await apiPost('/deployments/upload', formData);
       await rm(zipPath, { force: true }).catch(() => {});
     } catch (e) {
       await rm(zipPath, { force: true }).catch(() => {});
+      indicator.stop();
       return fail(`Upload failed: ${e.message}`);
     }
   } else {
-    info(color.dim(`→ deploying connected repo for project ${projectId}${commitHash ? ` @ ${commitHash.slice(0, 7)}` : ''} (${target})`));
+    indicator.setPhase('hatching');
     try {
       dep = await apiPost('/deployments', { projectId, commitHash, gitBranch, target });
     } catch (e) {
+      indicator.stop();
       return fail(e.message);
     }
   }
   
-  ok(`Deployment ${color.bold(dep.id)} queued`);
-
   if (flags.detach || flags.D) {
+    indicator.stop();
+    info(`Queued: ${color.dim(dep.id)}`);
     info(`Track it with: ${color.cyan(`glash status ${dep.id}`)}`);
     return;
   }
 
   // Poll the pipeline until it terminates.
   const seen = new Set();
-  let lastStatus = '';
-  const start = Date.now();
   const timeoutMs = deployTimeoutMs(flags);
   let pollDelayMs = 5000;
   let lastProgressAt = Date.now();
-  let currentPhase = 'queued';
-  const indicator = createDeployIndicator({ start, getPhase: () => currentPhase });
-  indicator.start();
+  indicator.setPhase('hatching');
   while (Date.now() - start < timeoutMs) {
     let pipe;
     try {
@@ -197,7 +202,7 @@ export async function deploy({ flags }) {
         continue;
       }
       if (Date.now() - lastProgressAt > 60_000) {
-        info(color.dim(`  • deploy   Still working; waiting for the next deployment update…`));
+        indicator.setPhase('waiting');
         lastProgressAt = Date.now();
       }
       pollDelayMs = Math.min(Math.max(pollDelayMs * 1.5, 5000), 30000);
@@ -209,19 +214,22 @@ export async function deploy({ flags }) {
       const key = `${ev.id ?? ev.createdAt}:${ev.step}:${ev.status}`;
       if (seen.has(key)) continue;
       seen.add(key);
-      indicator.clear();
-      const tag = stepBadge(ev.status);
-      info(`  ${tag} ${color.dim(ev.step.padEnd(8))} ${ev.message ?? ''}`);
       lastProgressAt = Date.now();
       currentPhase = phaseFromEvent(ev);
+      indicator.setPhase(currentPhase);
     }
 
     const status = pipe.deployStatus ?? pipe.buildStatus ?? '';
-    if (status && status !== lastStatus) lastStatus = status;
     if (['ready', 'live', 'success'].includes(status)) {
       indicator.stop();
       const url = pipe.hostings?.[0]?.domains?.[0]?.domain;
-      ok(`Live${url ? ` → ${color.cyan(`https://${url.replace(/^https?:\/\//, '')}`)}` : ''}`);
+      if (url) {
+        const problem = await detectLiveUrlProblem(`https://${url.replace(/^https?:\/\//, '')}`);
+        if (problem) {
+          return fail(`Deployment finished, but the hostname is still not serving your app: ${problem}. Run \`glash logs ${dep.id}\` for details.`);
+        }
+      }
+      printDeploySuccess({ url, envSummary });
       return;
     }
     if (status === 'placeholder') {
@@ -238,6 +246,7 @@ export async function deploy({ flags }) {
       return fail(`Deployment failed (${status})${detail}. Run \`glash logs ${dep.id}\` for details.`);
     }
     currentPhase = phaseFromPipeline(pipe, currentPhase);
+    indicator.setPhase(currentPhase);
     pollDelayMs = nextPollDelay(pipe);
     await indicator.wait(pollDelayMs);
   }
@@ -247,7 +256,7 @@ export async function deploy({ flags }) {
 
 async function syncEnvBeforeDeploy(projectId, target, flags) {
   const files = await resolveEnvFiles(target, flags);
-  if (!files.length) return;
+  if (!files.length) return { count: 0, files: [] };
 
   const merged = new Map();
   for (const file of files) {
@@ -258,9 +267,9 @@ async function syncEnvBeforeDeploy(projectId, target, flags) {
     .filter(([key]) => !key.startsWith('GLASH_'))
     .map(([key, value]) => ({ key, value, environment: target }));
 
-  if (!vars.length) return;
+  if (!vars.length) return { count: 0, files };
   await apiPost(`/projects/${projectId}/env-vars/bulk`, { vars });
-  info(color.dim(`→ synced ${vars.length} env vars from ${files.join(', ')}`));
+  return { count: vars.length, files };
 }
 
 async function resolveEnvFiles(target, flags) {
@@ -305,13 +314,6 @@ function parseDotenv(text) {
   return out;
 }
 
-function stepBadge(status) {
-  if (status === 'success' || status === 'issued' || status === 'active' || status === 'ready') return color.green('✓');
-  if (status === 'error' || status === 'failed') return color.red('✗');
-  if (status === 'warning') return color.yellow('!');
-  return color.cyan('•');
-}
-
 function nextPollDelay(pipe) {
   const status = pipe.deployStatus ?? pipe.buildStatus ?? '';
   const last = [...(pipe.events ?? [])].reverse().find(Boolean);
@@ -339,19 +341,19 @@ function formatDuration(ms) {
 }
 
 function phaseFromEvent(ev) {
-  if (ev.step === 'detect') return 'detecting';
-  if (ev.step === 'host') return 'assigning host';
-  if (ev.step === 'package') return ev.status === 'queued' ? 'queued' : 'packaging';
+  if (ev.step === 'detect') return 'doing';
+  if (ev.step === 'host') return 'hatching';
+  if (ev.step === 'package') return ev.status === 'queued' ? 'hatching' : 'packaging';
   if (ev.step === 'build') return 'building';
-  if (ev.step === 'deploy') return ev.status === 'ready' ? 'finalizing' : 'deploying';
+  if (ev.step === 'deploy') return ev.status === 'ready' ? 'checking' : 'deploying';
   if (ev.step === 'route' || ev.step === 'edge' || ev.step === 'ssl') return 'routing';
-  if (ev.step === 'runtime') return 'checking runtime';
-  return ev.step || 'deploying';
+  if (ev.step === 'runtime') return 'checking';
+  return ev.step || 'glashing';
 }
 
 function phaseFromPipeline(pipe, fallback) {
   const status = pipe.deployStatus ?? pipe.buildStatus ?? '';
-  if (status === 'queued') return 'queued';
+  if (status === 'queued') return 'hatching';
   if (status === 'building') return 'building';
   if (status === 'rolling-out') return 'deploying';
   const last = [...(pipe.events ?? [])].reverse().find(Boolean);
@@ -368,23 +370,60 @@ function deploymentFailureHint(message = '') {
   return '';
 }
 
-function createDeployIndicator({ start, getPhase }) {
+async function detectLiveUrlProblem(url) {
+  try {
+    const res = await fetch(url, {
+      redirect: 'manual',
+      signal: AbortSignal.timeout(10_000),
+      headers: { 'User-Agent': `glash-cli-live-check` },
+    });
+    const text = await res.clone().text().catch(() => '');
+    if (/glashDB:\s*no application is deployed at this hostname/i.test(text)) {
+      return 'the edge reached the host, but no nginx route exists for this hostname';
+    }
+    if (/Glash\s+Site reserved|Site reserved/i.test(text)) {
+      return 'the hostname is still showing the glashDB parked page';
+    }
+    if (res.status >= 500) {
+      return `the live URL returned HTTP ${res.status}`;
+    }
+    return '';
+  } catch (e) {
+    return `the live URL check failed (${e.message})`;
+  }
+}
+
+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 terminalLink(url) {
+  const label = color.cyan(url);
+  if (!stdout.isTTY) return label;
+  return `\x1b]8;;${url}\x07${label}\x1b]8;;\x07`;
+}
+
+function createDeployIndicator() {
   const interactive = Boolean(stdout.isTTY);
   let frame = 0;
   let timer;
-  let plainLast = 0;
+  let phase = 'doing';
+  let printedPhase = '';
   const frames = ['.', '..', '...'];
 
   function message() {
-    const elapsed = Math.floor((Date.now() - start) / 1000);
     const dots = frames[frame++ % frames.length].padEnd(3, ' ');
-    return `  ${color.cyan('•')} ${color.dim('deploy'.padEnd(8))} ${getPhase()}${dots} ${color.dim(`${elapsed}s elapsed`)}`;
+    return color.dim(`${phase}${dots}`);
   }
 
-  function render() {
+  function render({ force = false } = {}) {
     if (!interactive) {
-      if (Date.now() - plainLast > 30_000) {
-        plainLast = Date.now();
+      if (force && phase !== printedPhase) {
+        printedPhase = phase;
         info(message().trimEnd());
       }
       return;
@@ -393,12 +432,15 @@ function createDeployIndicator({ start, getPhase }) {
   }
 
   return {
-    start() {
+    start(initialPhase = 'doing') {
+      phase = initialPhase;
       render();
       timer = setInterval(render, 1000);
     },
-    clear() {
-      if (interactive) stdout.write('\r\x1b[2K');
+    setPhase(nextPhase) {
+      if (!nextPhase || nextPhase === phase) return;
+      phase = nextPhase;
+      render({ force: true });
     },
     stop() {
       if (timer) clearInterval(timer);

package/lib/api.mjs

@@ -28,6 +28,12 @@ const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 // proxies across machines.
 const RETRYABLE_STATUS = new Set([408, 425, 429, 500, 502, 503, 504, 522, 524]);
 const DEFAULT_RETRIES = 4;
+// Per-request wall-clock ceiling. Without this a contended/wedged backend
+// leaves `glash deploy` hanging forever after "source bundle X MB" with no
+// output. On timeout we abort and retry instead of hanging. Uploads (FormData)
+// stream a bundle and register a deployment, so they get a longer ceiling.
+const DEFAULT_TIMEOUT_MS = 60_000;
+const UPLOAD_TIMEOUT_MS = 180_000;
 
 function backoffMs(attempt, retryAfter) {
   if (retryAfter && Number.isFinite(retryAfter)) return Math.min(Math.max(retryAfter, 1000), 60000);
@@ -37,7 +43,7 @@ function backoffMs(attempt, retryAfter) {
   return Math.round(jitter);
 }
 
-export async function api(method, path, { body, token, query, retries = DEFAULT_RETRIES, signal } = {}) {
+export async function api(method, path, { body, token, query, retries = DEFAULT_RETRIES, signal, timeoutMs } = {}) {
   const headers = {
     Accept: 'application/json',
     'User-Agent': `glash-cli/${VERSION}`,
@@ -62,25 +68,44 @@ export async function api(method, path, { body, token, query, retries = DEFAULT_
   // re-streamable — fetch reads them fresh on each attempt, which lets us
   // retry uploads without re-zipping.
   const requestBody = isForm ? body : (body === undefined ? undefined : JSON.stringify(body));
+  const effectiveTimeout = timeoutMs ?? (isForm ? UPLOAD_TIMEOUT_MS : DEFAULT_TIMEOUT_MS);
 
   let attempt = 0;
   // eslint-disable-next-line no-constant-condition
   while (true) {
+    // Each attempt gets a fresh AbortController so the timeout can fire
+    // independently. If the caller passed their own signal, chain it.
+    const ctrl = new AbortController();
+    let timedOut = false;
+    const timer = setTimeout(() => { timedOut = true; ctrl.abort(); }, effectiveTimeout);
+    const onCallerAbort = () => ctrl.abort();
+    if (signal) {
+      if (signal.aborted) ctrl.abort();
+      else signal.addEventListener('abort', onCallerAbort, { once: true });
+    }
+
     let res;
     try {
-      res = await fetch(url, { method, headers, body: requestBody, signal });
+      res = await fetch(url, { method, headers, body: requestBody, signal: ctrl.signal });
     } catch (e) {
-      if (signal?.aborted) throw e;
-      const detail = e?.cause?.message || e?.message || String(e);
-      // Network-level failure: the request did not complete, so retrying is
-      // always safe. This covers DNS, TLS, connection-reset and timeout errors.
+      clearTimeout(timer);
+      signal?.removeEventListener?.('abort', onCallerAbort);
+      // A caller-initiated cancel (not our timeout) must not be retried.
+      if (signal?.aborted && !timedOut) throw e;
+      const detail = timedOut
+        ? `timed out after ${Math.round(effectiveTimeout / 1000)}s`
+        : (e?.cause?.message || e?.message || String(e));
+      // Network failure or timeout: the request did not complete, so retrying
+      // is safe. Covers DNS, TLS, connection-reset, and wedged-server hangs.
       if (attempt < retries) {
         await sleep(backoffMs(attempt));
         attempt += 1;
         continue;
       }
-      throw new GlashApiError(0, `Network request failed while calling ${method} ${path}: ${detail}`);
+      throw new GlashApiError(0, `Request failed while calling ${method} ${path}: ${detail}`);
     }
+    clearTimeout(timer);
+    signal?.removeEventListener?.('abort', onCallerAbort);
 
     if (!res.ok) {
       const retryAfter = retryAfterMs(res.headers);

package/lib/version.mjs

@@ -1 +1 @@
-export const VERSION = '0.2.21';
+export const VERSION = '0.2.22';

package/package.json

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