@blaxel/core 0.2.87 → 0.2.88

package/dist/cjs/common/settings.js

@@ -28,8 +28,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.2.87";
-const BUILD_COMMIT = "31085636cd9c2557198ee7399e7794e945c21687";
+const BUILD_VERSION = "0.2.88";
+const BUILD_COMMIT = "3d4dcbfdf0ac479adef35da9cd8523954af3e7f7";
 const BUILD_SENTRY_DSN = "https://fd5e60e1c9820e1eef5ccebb84a07127@o4508714045276160.ingest.us.sentry.io/4510465864564736";
 const BLAXEL_API_VERSION = "2026-04-16";
 // Cache for config.yaml tracking value

package/dist/cjs/sandbox/sandbox.js

@@ -54,6 +54,23 @@ const NON_REUSABLE_SANDBOX_STATUSES = new Set([
     "DELETING",
     "DEACTIVATING",
 ]);
+// Statuses that resolve on their own (a delete or deactivation in flight). The control
+// plane keeps answering 409 to creates while the record is in one of these, so retrying
+// instantly burns the whole attempt budget inside the window. Terminal statuses
+// (FAILED, TERMINATED) accept a create immediately and are not listed here.
+const TRANSIENT_SANDBOX_STATUSES = new Set([
+    "TERMINATING",
+    "DELETING",
+    "DEACTIVATING",
+]);
+const TRANSIENT_STATUS_MAX_WAIT_MS = 30_000;
+const TRANSIENT_STATUS_POLL_MS = 500;
+const isSandboxNotFound = (e) => {
+    if (typeof e !== "object" || e === null)
+        return false;
+    const candidate = e;
+    return candidate.code === 404 || candidate.code === "404" || candidate.status === 404;
+};
 class SandboxInstance {
     sandbox;
     fs;
@@ -322,7 +339,9 @@ class SandboxInstance {
     }
     static async createIfNotExists(sandbox) {
         const ATTEMPTS = 3;
+        let lastStatus = "unknown";
         for (let i = 0; i < ATTEMPTS; ++i) {
+            const finalAttempt = i === ATTEMPTS - 1;
             try {
                 return await this.create(sandbox, { createIfNotExist: true });
             }
@@ -333,18 +352,59 @@ class SandboxInstance {
                         throw new Error("Sandbox name is required");
                     }
                     // Get the existing sandbox to check its status
-                    const sandboxInstance = await this.get(name);
+                    let sandboxInstance;
+                    try {
+                        sandboxInstance = await this.get(name);
+                    }
+                    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) {
+                                await new Promise((resolve) => setTimeout(resolve, TRANSIENT_STATUS_POLL_MS));
+                            }
+                            continue;
+                        }
+                        throw getError;
+                    }
                     // Recreate instead of returning sandbox records that cannot be reused.
                     if (!NON_REUSABLE_SANDBOX_STATUSES.has(sandboxInstance.status ?? "")) {
                         return sandboxInstance;
                     }
+                    // A delete or deactivation in flight rejects creates until it finishes;
+                    // wait it out instead of burning the remaining attempts inside the window.
+                    // No point waiting after the last attempt: nothing will use the result.
+                    lastStatus = sandboxInstance.status ?? "unknown";
+                    if (TRANSIENT_SANDBOX_STATUSES.has(lastStatus) && !finalAttempt) {
+                        await this.waitWhileSandboxDying(name);
+                    }
                     // Retry creation. We want the same error handling on the retry as creates can race.
                     continue;
                 }
                 throw e;
             }
         }
-        throw new Error(`Unable to create sandbox after ${ATTEMPTS} attempts.`);
+        throw new Error(`Unable to create sandbox after ${ATTEMPTS} attempts. Last conflicting status: ${lastStatus}.`);
+    }
+    // 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.
+    static async waitWhileSandboxDying(name) {
+        const deadline = Date.now() + TRANSIENT_STATUS_MAX_WAIT_MS;
+        while (Date.now() < deadline) {
+            await new Promise((resolve) => setTimeout(resolve, TRANSIENT_STATUS_POLL_MS));
+            try {
+                const current = await this.get(name);
+                if (!TRANSIENT_SANDBOX_STATUSES.has(current.status ?? "")) {
+                    return;
+                }
+                logger_js_1.logger.debug(`Sandbox ${name} still ${current.status}; waiting for the record to settle before recreating`);
+            }
+            catch {
+                return;
+            }
+        }
     }
     /* eslint-disable */
     static async fromSession(session) {

package/dist/cjs/types/sandbox/sandbox.d.ts

@@ -59,5 +59,6 @@ export declare class SandboxInstance {
     static updateLifecycle(sandboxName: string, lifecycle: SandboxLifecycle): Promise<SandboxInstance>;
     static updateNetwork(sandboxName: string, network: SandboxUpdateNetwork): Promise<SandboxInstance>;
     static createIfNotExists(sandbox: SandboxModel | SandboxCreateConfiguration): Promise<SandboxInstance>;
+    private static waitWhileSandboxDying;
     static fromSession(session: SessionWithToken): Promise<SandboxInstance>;
 }