@blaxel/core 0.3.1-preview.210 → 0.3.1-preview.212

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.210";
-const BUILD_COMMIT = "1cf2f890404700f7be699c0a1ef0cf137db7efcf";
+const BUILD_VERSION = "0.3.1-preview.212";
+const BUILD_COMMIT = "06b4bb451ef8797cbc2cd3e3a957d62c45f2cc12";
 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);
@@ -352,6 +373,12 @@ export class SandboxInstance {
     static async createIfNotExists(sandbox) {
         const ATTEMPTS = 3;
         let lastStatus = "unknown";
+        // The 'vanished' window (create 409s while get 404s) is driven by the same
+        // transient causes as 'dying': an in-flight delete finishing, or a
+        // concurrent create whose row is not readable yet. Give it the same time
+        // budget as waitWhileSandboxDying instead of burning the attempt budget
+        // 500ms apart (~1s total), which threw on deletes taking >1s (ENG-3667).
+        const vanishedDeadline = Date.now() + TRANSIENT_STATUS_MAX_WAIT_MS;
         for (let i = 0; i < ATTEMPTS; ++i) {
             const finalAttempt = i === ATTEMPTS - 1;
             try {
@@ -363,6 +390,12 @@ export class SandboxInstance {
                     if (!name) {
                         throw new Error("Sandbox name is required");
                     }
+                    // The controlplane tags the creation-lock 409 with
+                    // reason=CREATION_IN_PROGRESS when the conflict comes from a
+                    // concurrent create still in flight (ENG-3776). The field is absent
+                    // on older controlplanes and on real row conflicts, so it only
+                    // sharpens the give-up error; the polling behavior is the same.
+                    const creationInProgress = e.reason === "CREATION_IN_PROGRESS";
                     // Get the existing sandbox to check its status
                     let sandboxInstance;
                     try {
@@ -370,10 +403,14 @@ export class SandboxInstance {
                     }
                     catch (getError) {
                         if (isSandboxNotFound(getError)) {
-                            // The record vanished between the create conflict and this status check
-                            // (its deletion just finished); give the control plane a beat and retry.
-                            lastStatus = "vanished";
-                            if (!finalAttempt) {
+                            // The record vanished between the create conflict and this status check.
+                            lastStatus = creationInProgress ? "creation in progress" : "vanished";
+                            if (Date.now() < vanishedDeadline) {
+                                // Inside the transient window: poll without consuming attempts.
+                                await new Promise((resolve) => setTimeout(resolve, TRANSIENT_STATUS_POLL_MS));
+                                --i;
+                            }
+                            else if (!finalAttempt) {
                                 await new Promise((resolve) => setTimeout(resolve, TRANSIENT_STATUS_POLL_MS));
                             }
                             continue;
@@ -399,6 +436,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.