@blaxel/core 0.3.1-preview.209 → 0.3.1-preview.211

package/dist/esm/common/settings.js

@@ -22,8 +22,8 @@ function missingCredentialsMessage() {
     return "No Blaxel credentials found. Set the BL_API_KEY and BL_WORKSPACE environment variables, or run `bl login`.";
 }
 // Build info - these placeholders are replaced at build time by build:replace-imports
-const BUILD_VERSION = "0.3.1-preview.209";
-const BUILD_COMMIT = "5f62366813deadb7a97b6088b32852bfbb046cf8";
+const BUILD_VERSION = "0.3.1-preview.211";
+const BUILD_COMMIT = "bec14a486d933a8311bb7cc2c7e4720c14ce2b44";
 const BUILD_SENTRY_DSN = "https://fd5e60e1c9820e1eef5ccebb84a07127@o4508714045276160.ingest.us.sentry.io/4510465864564736";
 const BLAXEL_API_VERSION = "2026-04-28";
 // Cache for config.yaml tracking value

package/dist/esm/common/transient-retry.js

@@ -103,8 +103,9 @@ const DEFAULT_MAX_DELAY_MS = 2000;
 // single wait never blocks unreasonably long. Exponential (rather than linear)
 // gives a later attempt room to span a multi-second sandbox cold-start/standby
 // wake, which is the window a first-call reset falls into, while early attempts
-// stay fast for the common quick-reset case.
-function backoffDelayMs(attempt, baseDelayMs, maxDelayMs) {
+// stay fast for the common quick-reset case. Exported so other polling paths
+// (e.g. the create-504 wait in sandbox.ts) share the same delay curve.
+export function backoffDelayMs(attempt, baseDelayMs, maxDelayMs) {
     const exponential = baseDelayMs * Math.pow(2, attempt - 1);
     const capped = Math.min(exponential, maxDelayMs);
     const jitter = Math.floor(Math.random() * baseDelayMs);

package/dist/esm/sandbox/sandbox.js

@@ -1,6 +1,7 @@
 import { v4 as uuidv4 } from "uuid";
 import { createSandbox, deleteSandbox, getSandbox, getSandboxByExternalId, listSandboxes, updateSandbox } from "../client/index.js";
 import { logger } from "../common/logger.js";
+import { backoffDelayMs } from "../common/transient-retry.js";
 import { createPaginatedList } from "../common/pagination.js";
 import { settings } from "../common/settings.js";
 import { SandboxCodegen } from "./codegen/index.js";
@@ -31,6 +32,15 @@ const TRANSIENT_SANDBOX_STATUSES = new Set([
 ]);
 const TRANSIENT_STATUS_MAX_WAIT_MS = 30_000;
 const TRANSIENT_STATUS_POLL_MS = 500;
+// A create that outlives the edge's 60s origin-read timeout gets a 504 from
+// CloudFront while the control plane keeps deploying the sandbox for up to
+// 300s (ENG-3662 timeout ladder inversion). The 504 body is edge HTML with no
+// usable payload, so the record is polled instead until it settles.
+// Polling backs off exponentially (1s, 2s, 4s, then 5s + jitter) so a fleet of
+// clients stuck in this window does not hammer the control plane every second.
+const CREATE_GATEWAY_TIMEOUT_MAX_WAIT_MS = 120_000;
+const CREATE_GATEWAY_TIMEOUT_BASE_POLL_MS = 1_000;
+const CREATE_GATEWAY_TIMEOUT_MAX_POLL_MS = 5_000;
 const isSandboxNotFound = (e) => {
     if (typeof e !== "object" || e === null)
         return false;
@@ -205,14 +215,25 @@ export class SandboxInstance {
         if (edgeDomain && !settings.disableH2) {
             import("../common/h2pool.js").then(({ h2Pool }) => h2Pool.warm(edgeDomain)).catch(() => { });
         }
-        const [{ data }, h2Session] = await Promise.all([
+        const [createResult, h2Session] = await Promise.all([
             createSandbox({
                 body: sandbox,
                 query: createIfNotExist ? { createIfNotExist } : undefined,
-                throwOnError: true,
             }),
             edgeDomain && !settings.disableH2 ? import("../common/h2pool.js").then(({ h2Pool }) => h2Pool.get(edgeDomain)).catch(() => null) : Promise.resolve(null),
         ]);
+        let data = createResult.data;
+        if (createResult.error !== undefined) {
+            const name = sandbox.metadata.name;
+            if (createResult.response.status === 504 && name) {
+                // The edge gave up on the connection but the creation is still running
+                // server-side; wait for the record instead of failing (ENG-3662).
+                data = await SandboxInstance.waitAfterCreateGatewayTimeout(name, createResult.error);
+            }
+            else {
+                throw createResult.error;
+            }
+        }
         // Inject the H2 session into the config so subsystems can use it
         const config = { ...data, h2Session, h2Domain: settings.disableH2 ? null : edgeDomain };
         const instance = new SandboxInstance(config);
@@ -399,6 +420,35 @@ export class SandboxInstance {
         }
         throw new Error(`Unable to create sandbox after ${ATTEMPTS} attempts. Last conflicting status: ${lastStatus}.`);
     }
+    // Poll the record after a create was cut by the edge with a 504 while the
+    // control plane is still deploying it. Resolves with the sandbox once it
+    // reaches DEPLOYED; throws on FAILED or once the wait budget is spent.
+    static async waitAfterCreateGatewayTimeout(name, createError) {
+        logger.debug(`Sandbox ${name} creation timed out at the edge (504); polling the record while it finishes deploying`);
+        const deadline = Date.now() + CREATE_GATEWAY_TIMEOUT_MAX_WAIT_MS;
+        let attempt = 0;
+        while (Date.now() < deadline) {
+            attempt++;
+            await new Promise((resolve) => setTimeout(resolve, backoffDelayMs(attempt, CREATE_GATEWAY_TIMEOUT_BASE_POLL_MS, CREATE_GATEWAY_TIMEOUT_MAX_POLL_MS)));
+            let current;
+            try {
+                const { data } = await getSandbox({ path: { sandboxName: name }, throwOnError: true });
+                current = data;
+            }
+            catch (e) {
+                // The record can lag behind the accepted create; keep waiting on 404.
+                if (isSandboxNotFound(e))
+                    continue;
+                throw e;
+            }
+            if (current.status === "DEPLOYED")
+                return current;
+            if (current.status === "FAILED") {
+                throw new Error(`Sandbox ${name} failed to deploy after the create timed out at the edge (504).`);
+            }
+        }
+        throw createError;
+    }
     // Poll the record until an in-flight delete/deactivation settles (or the record
     // disappears), bounded by TRANSIENT_STATUS_MAX_WAIT_MS. Errors from get (e.g. 404
     // once the record is gone) end the wait: the caller's create retry decides next.