@faable/faable 1.20.0 → 1.21.0

package/dist/commands/deploy/index.js

@@ -9,6 +9,7 @@ import { git_context } from './git_context.js';
 import { deploy_remote } from './remote/index.js';
 import { resolve_app_id } from './resolve_app_id.js';
 import { secrets } from './secrets/index.js';
+import { is_superseded } from './superseded.js';
 import { mark_build_failure, start_log_sync, upload_logs } from './upload_logs.js';
 import { upload_tag } from './upload_tag.js';
 
@@ -179,6 +180,10 @@ const deploy = {
         log.info(`⏳ Waiting for deployment to be promoted...`);
         let promoted = false;
         let failure = null;
+        let superseded = null;
+        // The pointer at wait-start is the PREVIOUS deployment (older than ours)
+        // — only a pointer CHANGE to something that isn't us needs a look.
+        const initialActiveId = app.status?.deployment;
         while (Date.now() - start < timeoutMs) {
             await wait(intervalMs);
             try {
@@ -187,6 +192,18 @@ const deploy = {
                     promoted = true;
                     break;
                 }
+                // Superseded: the pointer moved to a deployment at least as new as
+                // ours (twin workflows on the same push, or a rapid follow-up
+                // deploy). It only moves forward — waiting longer can never succeed.
+                const activeId = current.status?.deployment;
+                if (activeId && activeId !== initialActiveId) {
+                    const active = await api.getDeployment(activeId).catch(() => null);
+                    if (active &&
+                        is_superseded(deployment, active)) {
+                        superseded = activeId;
+                        break;
+                    }
+                }
                 // Watch for a terminal runtime failure so we fail fast (and red)
                 // instead of timing out green. The controller marks a crash-looping
                 // deployment ERROR — with a reason (e.g. a missing module) — within
@@ -197,6 +214,12 @@ const deploy = {
                     failure = { phase, reason: dep.status?.reason };
                     break;
                 }
+                // CANCELED: the platform superseded this build before it produced a
+                // runnable (a sibling deployment of the app won the promotion).
+                if (phase === "CANCELED") {
+                    superseded = dep.status?.reason ?? "canceled";
+                    break;
+                }
             }
             catch (_error) {
                 // Ignore transient errors while polling and keep waiting
@@ -206,6 +229,12 @@ const deploy = {
         if (promoted) {
             log.info(`🌍 Deployment promoted and live, visit: https://${app.url}`);
         }
+        else if (superseded) {
+            // Not a failure: the app IS live, just on a sibling deployment (e.g.
+            // duplicated workflows firing on the same push). Green exit — there is
+            // nothing for the user to fix in THIS run.
+            log.warn(`⚠️ Deployment superseded — a newer deployment of this app was promoted (${superseded}). The app is live: https://${app.url}`);
+        }
         else if (failure) {
             // Fail the command (non-zero exit → red GitHub Action) and surface the
             // reason the controller captured so the user sees WHY without digging.

package/dist/commands/deploy/superseded.js

@@ -0,0 +1,17 @@
+/**
+ * Superseded detection for the promotion wait (deploy v3, twin-workflow
+ * case): the app's promoted pointer only ever moves FORWARD (the controller
+ * refuses to promote a deployment older than the active one), so once a
+ * deployment at-least-as-new as ours is promoted, waiting longer can never
+ * succeed. Twins from duplicated workflows land here — one wins the pointer,
+ * the other must exit cleanly instead of hanging to the timeout.
+ *
+ * `>=` on purpose: same-instant twins (created ms apart) supersede each
+ * other in whichever order the promoter resolved them.
+ */
+const is_superseded = (mine, active) => Boolean(active &&
+    active.id !== mine.id &&
+    new Date(active.createdAt).getTime() >=
+        new Date(mine.createdAt).getTime());
+
+export { is_superseded };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@faable/faable",
-  "version": "1.20.0",
+  "version": "1.21.0",
   "main": "dist/index.js",
   "license": "MIT",
   "author": "Marc Pomar <marc@faable.com>",