@yadurajfleetos/cli 0.9.1 → 0.10.0

package/dist/commands/up.js

@@ -147,7 +147,18 @@ async function deployOne(service, opts) {
             const result = (await request('POST', `/services/${service.id}/deploy`, {
                 body: { gitSha: opts.gitSha, contextId },
             })).body;
-            walker.finish(`scheduled onto ${result.placedOn.name}`);
+            // Deliberately not walker.finish().
+            //
+            // The control plane answers as soon as a node is chosen and builds
+            // afterwards, so this response arrives before the build starts.
+            // Finishing here marked build, push, schedule and container as "not
+            // needed" — while the build ran for three minutes — and left a silent
+            // counter that reads as a hang. The steps are real; only the reply is
+            // early. Progress keeps driving the ladder until the phases are
+            // genuinely done.
+            walker.advance(2, `scheduled onto ${result.placedOn.name}`);
+            await progress.untilSettled({ deadlineMs: 45 * 60_000 });
+            walker.finish();
             return result;
         }
         finally {

package/dist/progress.js

@@ -14,6 +14,7 @@
  * a persistently unreachable control plane as an error.
  */
 import { request, CliError, EXIT } from './api.js';
+import { bar } from './ui.js';
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 /** A failure reason can be a build log tail; a one-line error gets one line of it. */
 export const firstLine = (text) => text.split('\n')[0].trim().slice(0, 200);
@@ -30,7 +31,51 @@ export function progressLine(p) {
         return undefined;
     const counter = p.step && p.ofSteps ? `${p.step}/${p.ofSteps} ` : '';
     const platform = p.platform ? `${p.platform.replace(/^linux\//, '')} ` : '';
-    return `${counter}${platform}${p.detail}`;
+    // Emulation is the answer to "why is this taking so long", and a build that
+    // takes three minutes instead of twenty seconds is almost always this. Said
+    // once, on the line already being drawn, rather than as a separate warning.
+    const how = p.emulated ? ' (emulated — slow)' : '';
+    return `${counter}${platform}${p.detail}${how}`;
+}
+/**
+ * A duration a person reads, not a step suffix.
+ *
+ * ui.ts has `duration`, which is dim, colour-wrapped, prefixed with a space
+ * and renders three minutes as "180s" — right for the end of a finished step,
+ * wrong for a sentence about how long is left.
+ */
+function human(ms) {
+    const total = Math.max(0, Math.round(ms / 1000));
+    if (total < 60)
+        return `${total}s`;
+    const minutes = Math.floor(total / 60);
+    const seconds = total % 60;
+    if (minutes < 60)
+        return seconds ? `${minutes}m ${seconds}s` : `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    return `${hours}h ${minutes % 60}m`;
+}
+/**
+ * Elapsed against what this service usually takes.
+ *
+ * Only from real history: on a first deploy there is nothing honest to say,
+ * and a bar filled from a number nobody measured is the same lie as the "not
+ * needed" it replaces. Overrunning is shown as overrunning rather than parked
+ * at the end of the bar — a deploy that is genuinely slow today is exactly
+ * when somebody needs to know.
+ */
+export function etaLine(p, now = Date.now()) {
+    if (!p.typicalMs || !p.since)
+        return undefined;
+    const elapsed = now - new Date(p.since).getTime();
+    if (elapsed < 0)
+        return undefined;
+    const fraction = Math.min(1, elapsed / p.typicalMs);
+    const left = p.typicalMs - elapsed;
+    const tail = left > 0
+        ? `~${human(left)} left`
+        : `${human(-left)} over the usual ${human(p.typicalMs)}`;
+    return `${bar(fraction)} ${human(elapsed)} · ${tail}`;
 }
 /**
  * Poll `/progress` in the background while something else is being awaited.
@@ -45,6 +90,11 @@ export function follow(serviceId, sink, opts = {}) {
     let stopped = false;
     let misses = 0;
     let wake = null;
+    /** Resolves once the deploy has left the phases this ladder draws. */
+    let settled = () => { };
+    const settledWhen = new Promise((resolve) => {
+        settled = resolve;
+    });
     const rest = (ms) => new Promise((resolve) => {
         const timer = setTimeout(resolve, ms);
         wake = () => {
@@ -60,8 +110,24 @@ export function follow(serviceId, sink, opts = {}) {
             try {
                 const progress = await fetchProgress(serviceId);
                 misses = 0;
-                if (progress)
+                if (progress) {
                     sink(progress);
+                    // `deploying` means the build and push are behind us and the node
+                    // has been told; everything after that is the rollout, which the
+                    // caller reports on separately.
+                    // `status` carries the phase: queued → building → pushing →
+                    // scheduling → deploying. Anything at or past `deploying` means the
+                    // build and push are behind us; the rest is the rollout, which the
+                    // caller reports on separately.
+                    if (progress.status === 'deploying' || progress.status === 'running')
+                        settled();
+                }
+                else {
+                    // No progress row at all means the build phases are over: the row is
+                    // dropped once a deploy leaves them, and a deploy that never wrote
+                    // one had nothing to build.
+                    settled();
+                }
             }
             catch {
                 // A control plane that predates the endpoint answers 404 every time, so
@@ -73,12 +139,35 @@ export function follow(serviceId, sink, opts = {}) {
             }
         }
     })();
+    // The loop ending for any reason — including a control plane with no
+    // progress endpoint — has to release anybody waiting, or a missing feature
+    // becomes a hang.
+    void loop.then(() => settled()).catch(() => settled());
     return {
         stop: async () => {
             stopped = true;
             wake?.();
             await loop.catch(() => { });
         },
+        /**
+         * Wait until the build phases are done.
+         *
+         * Bounded: a deploy whose progress never arrives must not hold the ladder
+         * open for ever. On the deadline this returns rather than throwing — the
+         * caller's own wait is what decides whether the deploy failed, and two
+         * things reporting the same failure is worse than one.
+         */
+        untilSettled: async ({ deadlineMs = 45 * 60_000 } = {}) => {
+            let timer;
+            await Promise.race([
+                settledWhen,
+                new Promise((resolve) => {
+                    timer = setTimeout(resolve, deadlineMs);
+                }),
+            ]);
+            if (timer)
+                clearTimeout(timer);
+        },
     };
 }
 /** Ladder steps for a deploy, in the order the control plane reports them. */
@@ -140,7 +229,14 @@ export function phaseWalker(l, steps = DEPLOY_STEPS) {
                 // poll, and it belongs on the step that decided it.
                 advance(target, at === 0 ? (p.nodeName ?? undefined) : undefined);
             }
-            const line = progressLine(p);
+            // The build line, or the estimate when there is no build line to show.
+            //
+            // Both on one row rather than two: the ladder redraws a fixed region and
+            // a row that appears and disappears makes the whole block jump. During a
+            // build the sub-step is the more useful of the two — it is proof of
+            // movement — and the estimate carries the rest of the wait, when the
+            // node is pulling an image and nothing is being logged at all.
+            const line = progressLine(p) ?? etaLine(p);
             if (line && at < steps.length)
                 l.detail(steps[at].key, line);
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yadurajfleetos/cli",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "description": "Fleet OS command-line interface for deploying and orchestrating services on user-owned hardware",
   "type": "module",
   "license": "MIT",