@yadurajfleetos/cli 0.9.0 → 0.9.2

package/dist/commands/services.js

@@ -52,7 +52,10 @@ export const applyCommand = {
                 return console.log(JSON.stringify(body, null, 2));
             if (!body.valid) {
                 for (const issue of body.issues ?? []) {
-                    console.log(`${glyph.fail} ${c.red('invalid')}  ${issue}`);
+                    const text = typeof issue === 'string'
+                        ? issue
+                        : [issue.path, issue.message].filter(Boolean).join(': ');
+                    console.log(`${glyph.fail} ${c.red('invalid')}  ${text}`);
                 }
                 throw new CliError('The manifest was not applied.', EXIT.usage);
             }

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

@@ -45,6 +45,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 +65,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 +94,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. */

package/package.json

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