@blaxel/core 0.2.83 → 0.2.84-preview.155

package/dist/esm/common/settings.js

@@ -5,8 +5,8 @@ import { authentication } from "../authentication/index.js";
 import { env } from "../common/env.js";
 import { fs, os, path } from "../common/node.js";
 // Build info - these placeholders are replaced at build time by build:replace-imports
-const BUILD_VERSION = "0.2.83";
-const BUILD_COMMIT = "d6f07458e0f766e5ef3c547eec3b0e00cf3297f7";
+const BUILD_VERSION = "0.2.84-preview.155";
+const BUILD_COMMIT = "b37c7bd0ef1257de732b54a2f784c6c91a8d450d";
 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
@@ -66,6 +66,10 @@ function getOsArch() {
     }
     return "browser/unknown";
 }
+function isDenoRuntime() {
+    const runtime = globalThis;
+    return typeof runtime.Deno !== "undefined";
+}
 class Settings {
     _credentials;
     config;
@@ -217,9 +221,10 @@ class Settings {
             return this.config.disableH2;
         }
         const value = env.BL_DISABLE_H2;
-        if (!value)
-            return false;
-        return ["1", "true", "yes", "on"].includes(value.toLowerCase());
+        if (value) {
+            return ["1", "true", "yes", "on"].includes(value.toLowerCase());
+        }
+        return isDenoRuntime();
     }
     async authenticate() {
         await this.credentials.authenticate();

package/dist/esm/sandbox/action.js

@@ -61,7 +61,7 @@ export class SandboxAction {
             });
         }
         const h2Domain = this.sandbox.h2Domain;
-        if (h2Domain) {
+        if (h2Domain && !settings.disableH2) {
             if (!this._h2Client || this._h2ClientDomain !== h2Domain) {
                 this._h2Client = createClient({
                     fetch: createPoolBackedH2Fetch(h2Pool, h2Domain),
@@ -82,13 +82,22 @@ export class SandboxAction {
         this._h2ClientDomain = null;
         return defaultClient;
     }
+    withClient(options) {
+        const requestOptions = { ...options };
+        Object.defineProperty(requestOptions, 'client', {
+            value: this.client,
+            enumerable: false,
+            configurable: true,
+        });
+        return requestOptions;
+    }
     /**
      * Routes through the H2 session when available, falling back to
      * globalThis.fetch. Uses a direct H2 path that avoids Request allocation.
      */
     h2Fetch(input, init) {
         const h2Domain = this.sandbox.h2Domain;
-        if (h2Domain) {
+        if (h2Domain && !settings.disableH2) {
             return h2RequestDirectFromPool(h2Pool, h2Domain, input.toString(), init);
         }
         return globalThis.fetch(input, init);

package/dist/esm/sandbox/codegen/codegen.js

@@ -5,22 +5,20 @@ export class SandboxCodegen extends SandboxAction {
         super(sandbox);
     }
     async fastapply(path, codeEdit, model) {
-        const result = await putCodegenFastapplyByPath({
+        const result = await putCodegenFastapplyByPath(this.withClient({
             path: { path },
             body: { codeEdit, model },
             baseUrl: this.url,
-            client: this.client,
-        });
+        }));
         this.handleResponseError(result.response, result.data, result.error);
         return result.data;
     }
     async reranking(path, query, scoreThreshold, tokenLimit, filePattern) {
-        const result = await getCodegenRerankingByPath({
+        const result = await getCodegenRerankingByPath(this.withClient({
             path: { path },
             query: { query, scoreThreshold, tokenLimit, filePattern },
             baseUrl: this.url,
-            client: this.client,
-        });
+        }));
         this.handleResponseError(result.response, result.data, result.error);
         return result.data;
     }

package/dist/esm/sandbox/drive/drive.js

@@ -8,11 +8,10 @@ export class SandboxDrive extends SandboxAction {
      * Mount a drive to the sandbox at a specific mount path
      */
     async mount(request) {
-        const { response, data, error } = await postDrivesMount({
+        const { response, data, error } = await postDrivesMount(this.withClient({
             baseUrl: this.url,
-            client: this.client,
             body: request,
-        });
+        }));
         this.handleResponseError(response, data, error);
         return data;
     }
@@ -23,11 +22,10 @@ export class SandboxDrive extends SandboxAction {
         // Strip leading slash for the path parameter since the URL template
         // already includes the slash: /drives/mount/{mountPath}
         const paramPath = mountPath.startsWith("/") ? mountPath.substring(1) : mountPath;
-        const { response, data, error } = await deleteDrivesMountByMountPath({
+        const { response, data, error } = await deleteDrivesMountByMountPath(this.withClient({
             baseUrl: this.url,
-            client: this.client,
             path: { mountPath: paramPath },
-        });
+        }));
         this.handleResponseError(response, data, error);
         return data;
     }
@@ -35,10 +33,9 @@ export class SandboxDrive extends SandboxAction {
      * List all mounted drives in the sandbox
      */
     async list() {
-        const { response, data, error } = await getDrivesMount({
+        const { response, data, error } = await getDrivesMount(this.withClient({
             baseUrl: this.url,
-            client: this.client,
-        });
+        }));
         this.handleResponseError(response, data, error);
         const result = data;
         return result.mounts ?? [];

package/dist/esm/sandbox/filesystem/filesystem.js

@@ -15,12 +15,11 @@ export class SandboxFileSystem extends SandboxAction {
     }
     async mkdir(path, permissions = "0755") {
         path = this.formatPath(path);
-        const { response, data, error } = await putFilesystemByPath({
+        const { response, data, error } = await putFilesystemByPath(this.withClient({
             path: { path },
             body: { isDirectory: true, permissions },
             baseUrl: this.url,
-            client: this.client,
-        });
+        }));
         this.handleResponseError(response, data, error);
         return data;
     }
@@ -34,12 +33,11 @@ export class SandboxFileSystem extends SandboxAction {
             return await this.uploadWithMultipart(path, blob, "0644");
         }
         // Use regular upload for small files
-        const { response, data, error } = await putFilesystemByPath({
+        const { response, data, error } = await putFilesystemByPath(this.withClient({
             path: { path },
             body: { content },
             baseUrl: this.url,
-            client: this.client,
-        });
+        }));
         this.handleResponseError(response, data, error);
         return data;
     }
@@ -120,7 +118,6 @@ export class SandboxFileSystem extends SandboxAction {
                 }, {}),
             },
             baseUrl: this.url,
-            client: this.client,
         };
         const path = this.formatPath(destinationPath ?? "");
         const { response, data, error } = await this.client.put({
@@ -135,11 +132,10 @@ export class SandboxFileSystem extends SandboxAction {
     }
     async read(path) {
         path = this.formatPath(path);
-        const { response, data, error } = await getFilesystemByPath({
+        const { response, data, error } = await getFilesystemByPath(this.withClient({
             path: { path },
             baseUrl: this.url,
-            client: this.client,
-        });
+        }));
         this.handleResponseError(response, data, error);
         if (data && 'content' in data) {
             return data.content;
@@ -148,14 +144,13 @@ export class SandboxFileSystem extends SandboxAction {
     }
     async readBinary(path) {
         path = this.formatPath(path);
-        const { response, data, error } = await getFilesystemByPath({
+        const { response, data, error } = await getFilesystemByPath(this.withClient({
             path: { path },
             baseUrl: this.url,
-            client: this.client,
             headers: {
                 'Accept': 'application/octet-stream',
             },
-        });
+        }));
         this.handleResponseError(response, data, error);
         if (typeof data === 'string') {
             return new Blob([data]);
@@ -173,22 +168,20 @@ export class SandboxFileSystem extends SandboxAction {
     }
     async rm(path, recursive = false) {
         path = this.formatPath(path);
-        const { response, data, error } = await deleteFilesystemByPath({
+        const { response, data, error } = await deleteFilesystemByPath(this.withClient({
             path: { path },
             query: { recursive },
             baseUrl: this.url,
-            client: this.client,
-        });
+        }));
         this.handleResponseError(response, data, error);
         return data;
     }
     async ls(path) {
         path = this.formatPath(path);
-        const { response, data, error } = await getFilesystemByPath({
+        const { response, data, error } = await getFilesystemByPath(this.withClient({
             path: { path },
             baseUrl: this.url,
-            client: this.client,
-        });
+        }));
         this.handleResponseError(response, data, error);
         if (!data || !('files' in data || 'subdirectories' in data)) {
             throw new Error(JSON.stringify({ error: "Directory not found" }));
@@ -210,12 +203,11 @@ export class SandboxFileSystem extends SandboxAction {
         if (options?.excludeHidden !== undefined) {
             queryParams.excludeHidden = options.excludeHidden;
         }
-        const result = await getFilesystemSearchByPath({
+        const result = await getFilesystemSearchByPath(this.withClient({
             path: { path: formattedPath },
             query: queryParams,
             baseUrl: this.url,
-            client: this.client,
-        });
+        }));
         this.handleResponseError(result.response, result.data, result.error);
         return result.data;
     }
@@ -237,12 +229,11 @@ export class SandboxFileSystem extends SandboxAction {
         if (options?.excludeHidden !== undefined) {
             queryParams.excludeHidden = options.excludeHidden;
         }
-        const result = await getFilesystemFindByPath({
+        const result = await getFilesystemFindByPath(this.withClient({
             path: { path: formattedPath },
             query: queryParams,
             baseUrl: this.url,
-            client: this.client,
-        });
+        }));
         this.handleResponseError(result.response, result.data, result.error);
         return result.data;
     }
@@ -266,12 +257,11 @@ export class SandboxFileSystem extends SandboxAction {
         if (options?.excludeDirs && options.excludeDirs.length > 0) {
             queryParams.excludeDirs = options.excludeDirs.join(',');
         }
-        const result = await getFilesystemContentSearchByPath({
+        const result = await getFilesystemContentSearchByPath(this.withClient({
             path: { path: formattedPath },
             query: queryParams,
             baseUrl: this.url,
-            client: this.client,
-        });
+        }));
         this.handleResponseError(result.response, result.data, result.error);
         return result.data;
     }
@@ -298,14 +288,13 @@ export class SandboxFileSystem extends SandboxAction {
             if (options?.ignore) {
                 query.ignore = options.ignore.join(",");
             }
-            const { response, data, error } = await getWatchFilesystemByPath({
-                client: this.client,
+            const { response, data, error } = await getWatchFilesystemByPath(this.withClient({
                 path: { path },
                 query,
                 baseUrl: this.url,
                 parseAs: 'stream',
                 signal: controller.signal,
-            });
+            }));
             if (error)
                 throw new Error(error instanceof Error ? error.message : JSON.stringify(error));
             const stream = data ?? response.body;
@@ -380,43 +369,39 @@ export class SandboxFileSystem extends SandboxAction {
     // Multipart upload helper methods
     async initiateMultipartUpload(path, permissions = "0644") {
         path = this.formatPath(path);
-        const { data } = await postFilesystemMultipartInitiateByPath({
+        const { data } = await postFilesystemMultipartInitiateByPath(this.withClient({
             path: { path },
             body: { permissions },
             baseUrl: this.url,
-            client: this.client,
             throwOnError: true,
-        });
+        }));
         return data;
     }
     async uploadPart(uploadId, partNumber, fileBlob) {
-        const { data } = await putFilesystemMultipartByUploadIdPart({
+        const { data } = await putFilesystemMultipartByUploadIdPart(this.withClient({
             path: { uploadId },
             query: { partNumber },
             body: { file: fileBlob },
             baseUrl: this.url,
-            client: this.client,
             throwOnError: true,
-        });
+        }));
         return data;
     }
     async completeMultipartUpload(uploadId, parts) {
-        const { data } = await postFilesystemMultipartByUploadIdComplete({
+        const { data } = await postFilesystemMultipartByUploadIdComplete(this.withClient({
             path: { uploadId },
             body: { parts },
             baseUrl: this.url,
-            client: this.client,
             throwOnError: true,
-        });
+        }));
         return data;
     }
     async abortMultipartUpload(uploadId) {
-        const { data } = await deleteFilesystemMultipartByUploadIdAbort({
+        const { data } = await deleteFilesystemMultipartByUploadIdAbort(this.withClient({
             path: { uploadId },
             baseUrl: this.url,
-            client: this.client,
             throwOnError: true,
-        });
+        }));
         return data;
     }
     async uploadWithMultipart(path, blob, permissions = "0644") {

package/dist/esm/sandbox/interpreter.js

@@ -30,7 +30,7 @@ export class CodeInterpreter extends SandboxInstance {
         };
         return new CodeInterpreter(config);
     }
-    static async create(sandbox, { safe = true } = {}) {
+    static async create(sandbox, { safe = true, createIfNotExist = false } = {}) {
         // Build a SandboxCreateConfiguration with CodeInterpreter defaults
         const defaults = {
             image: CodeInterpreter.DEFAULT_IMAGE,
@@ -63,7 +63,7 @@ export class CodeInterpreter extends SandboxInstance {
         else {
             merged = defaults;
         }
-        const baseInstance = await super.create(merged, { safe });
+        const baseInstance = await super.create(merged, { safe, createIfNotExist });
         // Create config from the instance
         const config = {
             metadata: baseInstance.metadata,

package/dist/esm/sandbox/process/process.js

@@ -108,11 +108,10 @@ export class SandboxProcess extends SandboxAction {
             return await this.execWithStreaming(process, { onLog, onStdout, onStderr });
         }
         else {
-            const { response, data, error } = await postProcess({
+            const { response, data, error } = await postProcess(this.withClient({
                 body: process,
                 baseUrl: this.url,
-                client: this.client,
-            });
+            }));
             this.handleResponseError(response, data, error);
             const result = data;
             if (onLog || onStdout || onStderr) {
@@ -300,46 +299,41 @@ export class SandboxProcess extends SandboxAction {
         return data;
     }
     async get(identifier) {
-        const { response, data, error } = await getProcessByIdentifier({
+        const { response, data, error } = await getProcessByIdentifier(this.withClient({
             path: { identifier },
             baseUrl: this.url,
-            client: this.client,
-        });
+        }));
         this.handleResponseError(response, data, error);
         return data;
     }
     async list() {
-        const { response, data, error } = await getProcess({
+        const { response, data, error } = await getProcess(this.withClient({
             baseUrl: this.url,
-            client: this.client,
-        });
+        }));
         this.handleResponseError(response, data, error);
         return data;
     }
     async stop(identifier) {
-        const { response, data, error } = await deleteProcessByIdentifier({
+        const { response, data, error } = await deleteProcessByIdentifier(this.withClient({
             path: { identifier },
             baseUrl: this.url,
-            client: this.client,
-        });
+        }));
         this.handleResponseError(response, data, error);
         return data;
     }
     async kill(identifier) {
-        const { response, data, error } = await deleteProcessByIdentifierKill({
+        const { response, data, error } = await deleteProcessByIdentifierKill(this.withClient({
             path: { identifier },
             baseUrl: this.url,
-            client: this.client,
-        });
+        }));
         this.handleResponseError(response, data, error);
         return data;
     }
     async logs(identifier, type = "all") {
-        const { response, data, error } = await getProcessByIdentifierLogs({
+        const { response, data, error } = await getProcessByIdentifierLogs(this.withClient({
             path: { identifier },
             baseUrl: this.url,
-            client: this.client,
-        });
+        }));
         this.handleResponseError(response, data, error);
         if (type === "all") {
             return data?.logs || "";

package/dist/esm/sandbox/sandbox.js

@@ -11,6 +11,13 @@ import { SandboxProcess } from "./process/index.js";
 import { SandboxSessions } from "./session.js";
 import { SandboxSystem } from "./system.js";
 import { normalizeEnvs, normalizePorts, normalizeVolumes } from "./types.js";
+const NON_REUSABLE_SANDBOX_STATUSES = new Set([
+    "FAILED",
+    "TERMINATED",
+    "TERMINATING",
+    "DELETING",
+    "DEACTIVATING",
+]);
 export class SandboxInstance {
     sandbox;
     fs;
@@ -96,7 +103,7 @@ export class SandboxInstance {
         logger.warn("⚠️  Warning: sandbox.wait() is deprecated. You don't need to wait for the sandbox to be deployed anymore.");
         return this;
     }
-    static async create(sandbox, { safe = false } = {}) {
+    static async create(sandbox, { safe = false, createIfNotExist = false } = {}) {
         const defaultName = `sandbox-${uuidv4().replace(/-/g, '').substring(0, 8)}`;
         const defaultImage = `blaxel/base-image:latest`;
         const defaultMemory = 4096;
@@ -180,6 +187,7 @@ export class SandboxInstance {
         const [{ data }, 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),
@@ -266,27 +274,30 @@ export class SandboxInstance {
         return SandboxInstance.attachH2Session(instance);
     }
     static async createIfNotExists(sandbox) {
-        try {
-            return await this.create(sandbox);
-        }
-        catch (e) {
-            if (typeof e === "object" && e !== null && "code" in e && (e.code === 409 || e.code === 'SANDBOX_ALREADY_EXISTS')) {
-                const name = 'name' in sandbox ? sandbox.name : sandbox.metadata.name;
-                if (!name) {
-                    throw new Error("Sandbox name is required");
-                }
-                // Get the existing sandbox to check its status
-                const sandboxInstance = await this.get(name);
-                // If the sandbox is TERMINATED, treat it as not existing
-                if (sandboxInstance.status === "TERMINATED") {
-                    // Create a new sandbox - backend will handle cleanup of the terminated one
-                    return await this.create(sandbox);
+        const ATTEMPTS = 3;
+        for (let i = 0; i < ATTEMPTS; ++i) {
+            try {
+                return await this.create(sandbox, { createIfNotExist: true });
+            }
+            catch (e) {
+                if (typeof e === "object" && e !== null && "code" in e && (e.code === 409 || e.code === 'SANDBOX_ALREADY_EXISTS')) {
+                    const name = 'name' in sandbox ? sandbox.name : sandbox.metadata.name;
+                    if (!name) {
+                        throw new Error("Sandbox name is required");
+                    }
+                    // Get the existing sandbox to check its status
+                    const sandboxInstance = await this.get(name);
+                    // Recreate instead of returning sandbox records that cannot be reused.
+                    if (!NON_REUSABLE_SANDBOX_STATUSES.has(sandboxInstance.status ?? "")) {
+                        return sandboxInstance;
+                    }
+                    // Retry creation. We want the same error handling on the retry as creates can race.
+                    continue;
                 }
-                // Otherwise return the existing running sandbox
-                return sandboxInstance;
+                throw e;
             }
-            throw e;
         }
+        throw new Error(`Unable to create sandbox after ${ATTEMPTS} attempts.`);
     }
     /* eslint-disable */
     static async fromSession(session) {

package/dist/esm/sandbox/system.js

@@ -5,11 +5,10 @@ export class SandboxSystem extends SandboxAction {
         super(sandbox);
     }
     async upgrade(body) {
-        const { response, data, error } = await postUpgrade({
+        const { response, data, error } = await postUpgrade(this.withClient({
             baseUrl: this.url,
-            client: this.client,
             body,
-        });
+        }));
         this.handleResponseError(response, data, error);
         return data;
     }