octwin-cli 0.8.3 → 0.8.4

package/CHANGELOG.md

@@ -5,6 +5,25 @@ Format: [Keep a Changelog](https://keepachangelog.com/) — newest first, bucket
 **Added · Changed · Deprecated · Removed · Fixed · Security**. The platform-wide view lives in the
 repo root [`CHANGELOG.md`](../../CHANGELOG.md); this file is the CLI-only cut that ships with the package.
 
+## [0.8.4] - 2026-09-02
+
+### Fixed
+- **A deploy whose seed failed still led with `✓ Deployed`.** The step errors were never
+  missing — `readDeployProgress` has collected every `status:'error'` frame into `stepErrors`
+  since 0.1.14, printed them, and exited non-zero. They were printed *after* `printDeploySuccess`,
+  so the first and largest line said `✓ Deployed` and the ⚠ came underneath. A pack author
+  reported their deploy as a clean success while its demo seed had failed; they were reading the
+  transcript exactly as written. The count now goes INTO the headline, which reads
+  `⚠ Deployed <id>@<v> onto <target> WITH n failure(s) — data may be incomplete`. `octwin seed`
+  gets the same treatment. *A signal that arrives after the verdict is not a signal.*
+- **The non-streaming deploy and seed paths had no step-error check at all.** With no SSE frames
+  to read, a failed seed printed a clean `✓` on that path even after the streaming one was fixed
+  in 0.1.14. Both now read `seed_failed` from the response body (new in the platform alongside
+  this release), print each failed kind with its reason, and exit non-zero.
+- **A partial demo seed is now reported as partial.** The platform no longer abandons the rest of
+  the seed when one demo row throws, so `Seeded:` gains an `n row(s) FAILED` part — without it a
+  partial seed reads as a complete one that simply had fewer records than the author wrote.
+
 ## [0.8.3] - 2026-09-02
 
 ### Fixed

package/dist/index.js

@@ -1535,8 +1535,22 @@ function printPublicListing(state, note, live, justAsked = false) {
             break;
     }
 }
-function printDeploySuccess(id, version, t, r, listing) {
-    console.log(`✓ Deployed ${id}@${version} and installed onto ${targetLabel(t)}`);
+/**
+ * THE HEADLINE MUST BE HONEST, because it is the line people actually read.
+ *
+ * The step errors were never missing — `readDeployProgress` has collected them since
+ * 0.1.14, and the caller prints them and exits non-zero. But it printed them AFTER this
+ * function, so the first and largest line said `✓ Deployed` and the ⚠ came underneath.
+ * A pack author reported the deploy as a clean success while its demo seed had failed;
+ * they were reading the transcript exactly as it was written.
+ *
+ * So `problems` is passed IN rather than handled by the caller afterwards: a signal that
+ * arrives after the verdict is not a signal.
+ */
+function printDeploySuccess(id, version, t, r, listing, problems = 0) {
+    console.log(problems > 0
+        ? `⚠ Deployed ${id}@${version} onto ${targetLabel(t)} WITH ${problems} failure(s) — data may be incomplete`
+        : `✓ Deployed ${id}@${version} and installed onto ${targetLabel(t)}`);
     if (r?.warning)
         console.log(`  ⚠ ${r.warning}`);
     const s = r?.summary;
@@ -1550,6 +1564,11 @@ function printDeploySuccess(id, version, t, r, listing) {
             parts.push(`${s.images} image(s) generated`);
         if (s.rules)
             parts.push(`${s.rules} availability rule(s)`);
+        // A count of rows that threw. The seed keeps going past a bad row now, so a
+        // partial seed is a real outcome and has to be said out loud — the alternative
+        // reads as a complete one with fewer records than the author wrote.
+        if (s.failed)
+            parts.push(`${s.failed} row(s) FAILED`);
         if (parts.length)
             console.log(`  Seeded: ${parts.join(', ')}`);
     }
@@ -1596,8 +1615,9 @@ async function cmdSeed(flags) {
         const { terminal: final, stepErrors } = await readDeployProgress(res.body);
         if (!final || final.stage === 'error')
             die(`seed failed${final?.message ? `: ${final.message}` : ' (stream ended early)'}`);
-        console.log(`
-✓ ${final.message ?? 'seed complete'}`);
+        // Same rule as `printDeploySuccess`: the verdict leads. A ✓ above the failures
+        // is the line that gets read and quoted.
+        console.log(`\n${stepErrors.length ? '⚠' : '✓'} ${final.message ?? 'seed complete'}`);
         printSeedCounts(final.result?.seeded);
         if (stepErrors.length) {
             // A kind failed but the rest ran — the reconcile softens each step. Say which,
@@ -1623,8 +1643,15 @@ async function cmdSeed(flags) {
         printAuthHint(res.status, url);
         exitNow(1);
     }
-    console.log('✓ seed complete');
+    // No frames on this path — `seed_failed` in the body is the only evidence a kind threw.
+    const failedKinds = Object.entries((json?.seed_failed ?? {}));
+    console.log(failedKinds.length ? `⚠ seed INCOMPLETE — ${failedKinds.length} kind(s) failed` : '✓ seed complete');
     printSeedCounts(json?.seeded);
+    if (failedKinds.length) {
+        for (const [kind, why] of failedKinds)
+            console.error(`   • ${kind}: ${why}`);
+        exitNow(1);
+    }
 }
 /** Per-kind counts, one line each. Prints nothing when the pack declared nothing. */
 function printSeedCounts(seeded) {
@@ -1658,12 +1685,14 @@ async function cmdDeploy(flags) {
         const { terminal: final, stepErrors } = await readDeployProgress(res.body);
         if (!final || final.stage === 'error')
             die(`deploy failed${final?.message ? `: ${final.message}` : ' (stream ended early)'}`);
-        printDeploySuccess(id, version, t, final, { intent: listing, packDir });
+        // The count goes IN, so the headline itself carries the verdict. It used to be
+        // printed underneath a `✓ Deployed` line, which is what a reporting author read.
+        printDeploySuccess(id, version, t, final, { intent: listing, packDir }, stepErrors.length);
         if (stepErrors.length) {
-            // The pack IS installed, but a step (e.g. the demo seed) failed — say so
-            // plainly and exit non-zero so CI / a `deploy && chat` chain doesn't treat
-            // an incomplete install as a clean success.
-            console.error(`\n⚠ Deployed with ${stepErrors.length} warning${stepErrors.length === 1 ? '' : 's'} — data may be incomplete:`);
+            // The pack IS installed, but a step (e.g. the demo seed) failed — list what,
+            // and exit non-zero so CI / a `deploy && chat` chain doesn't treat an
+            // incomplete install as a clean success.
+            console.error(`\nFailures:`);
             for (const e of stepErrors)
                 console.error(`   • ${e}`);
             exitNow(1);
@@ -1686,7 +1715,17 @@ async function cmdDeploy(flags) {
         console.error(typeof json === 'string' ? json : JSON.stringify(json, null, 2));
         exitNow(1);
     }
-    printDeploySuccess(id, version, t, json, { intent: listing, packDir });
+    // This path had NO step-error check at all. With no SSE frames to read, the only
+    // evidence a seed kind threw is `seed_failed` in the body — so a broken seed printed
+    // a clean `✓ Deployed` here even after the streaming path was fixed in 0.1.14.
+    const failedKinds = Object.entries((json?.seed_failed ?? {}));
+    printDeploySuccess(id, version, t, json, { intent: listing, packDir }, failedKinds.length);
+    if (failedKinds.length) {
+        console.error(`\nFailures:`);
+        for (const [kind, why] of failedKinds)
+            console.error(`   • ${kind}: ${why}`);
+        exitNow(1);
+    }
 }
 /**
  * The QUALIFIED pack id (`<owner>.<name>`) for a manifest's bare name.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "octwin-cli",
-  "version": "0.8.3",
+  "version": "0.8.4",
   "description": "Octwin external-pack developer CLI (by CEQUENS) — scaffold, validate, deploy, and check pure-YAML packs on your tenant.",
   "type": "module",
   "bin": {