@blaxel/core 0.3.26-preview.314 → 0.3.26

package/dist/cjs/common/settings.js

@@ -30,8 +30,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.26-preview.314";
-const BUILD_COMMIT = "2df08257850abd6854feb6b7c412bd74c06f3592";
+const BUILD_VERSION = "0.3.26";
+const BUILD_COMMIT = "18c2c73526c47b9ebc09aa3e16497b19854a02d0";
 const BUILD_SENTRY_DSN = "https://fd5e60e1c9820e1eef5ccebb84a07127@o4508714045276160.ingest.us.sentry.io/4510465864564736";
 const BLAXEL_API_VERSION = "2026-09-22";
 // Bun < 1.3.11 never sends connection-level WINDOW_UPDATE: the pooled h2

package/dist/cjs/image/image.js

@@ -17,6 +17,37 @@ function ensureNodeEnvironment() {
 }
 exports.SANDBOX_API_IMAGE = "ghcr.io/blaxel-ai/sandbox";
 exports.SANDBOX_API_PATH = "/usr/local/bin/sandbox-api";
+// Build settings travel as sandbox labels. The control plane signs the allowed
+// ones into the upload URL, and the upload must send them back as matching
+// x-amz-meta-* headers or storage rejects it.
+const BUILD_UPLOAD_LABELS = [
+    "x-blaxel-builder",
+    "x-blaxel-experimental",
+    "x-blaxel-build-memory",
+    "x-blaxel-build-volume",
+    "x-blaxel-build-region",
+    "x-blaxel-build-cache",
+];
+const MAX_BUILD_UPLOAD_LABEL_VALUE = 64;
+function buildSizeLabel(option, value, min, max) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!Number.isInteger(value) || value < min || value > max) {
+        throw new Error(`${option} must be an integer between ${min} and ${max} MiB`);
+    }
+    return String(value);
+}
+function buildUploadMetadata(labels) {
+    const metadata = {};
+    for (const name of BUILD_UPLOAD_LABELS) {
+        const value = labels?.[name];
+        if (typeof value === "string" && value !== "" && value.length <= MAX_BUILD_UPLOAD_LABEL_VALUE) {
+            metadata[name] = value;
+        }
+    }
+    return metadata;
+}
 function generateDockerfile(context) {
     // Build the raw Dockerfile content
     const lines = [`FROM ${context.baseImage}`];
@@ -622,9 +653,10 @@ class ImageInstance {
             void archive.finalize();
         });
     }
-    _createSandboxPayload(name, memory = 4096) {
+    _createSandboxPayload(name, memory = 4096, buildLabels = {}) {
         const labels = {
             "x-blaxel-auto-generated": "true",
+            ...buildLabels,
         };
         const metadata = {
             name,
@@ -666,12 +698,16 @@ class ImageInstance {
         const uploadUrl = response.headers.get("x-blaxel-upload-url");
         return { response, uploadUrl };
     }
-    async _uploadZip(uploadUrl, zipContent) {
+    async _uploadZip(uploadUrl, zipContent, metadata = {}) {
+        const headers = {
+            "Content-Type": "application/zip",
+        };
+        for (const [name, value] of Object.entries(metadata)) {
+            headers[`x-amz-meta-${name}`] = value;
+        }
         const response = await fetch(uploadUrl, {
             method: "PUT",
-            headers: {
-                "Content-Type": "application/zip",
-            },
+            headers,
             body: zipContent,
         });
         if (response.status >= 400) {
@@ -742,6 +778,16 @@ class ImageInstance {
      */
     async build(options) {
         const { name, memory = 4096, timeout = 900000, onStatusChange, sandboxVersion = "latest" } = options;
+        const buildLabels = {};
+        const buildMemory = buildSizeLabel("buildMemoryMb", options.buildMemoryMb, 1, 32768);
+        if (buildMemory !== undefined) {
+            buildLabels["x-blaxel-build-memory"] = buildMemory;
+        }
+        // Keep an explicit 0: it asks for memory-backed scratch instead of the default.
+        const buildVolume = buildSizeLabel("buildVolumeMb", options.buildVolumeMb, 0, 131072);
+        if (buildVolume !== undefined) {
+            buildLabels["x-blaxel-build-volume"] = buildVolume;
+        }
         // Prepare image for sandbox deployment (add sandbox-api and entrypoint)
         const preparedImage = this._prepareForSandbox(sandboxVersion);
         // Write the image folder
@@ -750,7 +796,7 @@ class ImageInstance {
             // Create zip
             const zipContent = await this._createZip(buildDir);
             // Create sandbox payload
-            const sandboxPayload = this._createSandboxPayload(name, memory);
+            const sandboxPayload = this._createSandboxPayload(name, memory, buildLabels);
             // Create/update sandbox and get upload URL
             const { response, uploadUrl } = await this._createSandboxWithUpload(sandboxPayload);
             if (response.status >= 400) {
@@ -760,8 +806,18 @@ class ImageInstance {
             if (!uploadUrl) {
                 throw new Error("No upload URL returned from API");
             }
+            // Sign-matching headers come from the labels the control plane stored,
+            // which can include build settings already on an existing sandbox.
+            let storedLabels = sandboxPayload.metadata?.labels;
+            try {
+                const created = (await response.json());
+                storedLabels = created.metadata?.labels ?? storedLabels;
+            }
+            catch {
+                // Fall back to the labels we sent
+            }
             // Upload the zip
-            await this._uploadZip(uploadUrl, zipContent);
+            await this._uploadZip(uploadUrl, zipContent, buildUploadMetadata(storedLabels));
             // Wait for deployment to complete
             await this._waitForDeployment(name, timeout, 3000, onStatusChange);
             // Get the final sandbox state

package/dist/cjs/image/image.test.js

@@ -7,6 +7,7 @@ const fs_1 = require("fs");
 const os_1 = require("os");
 const path_1 = require("path");
 const vitest_1 = require("vitest");
+const settings_js_1 = require("../common/settings.js");
 const image_js_1 = require("./image.js");
 // Test fixtures
 let tempDir;
@@ -543,3 +544,76 @@ let tempSourceDir;
         (0, vitest_1.expect)(runIdx).toBeLessThan(thirdIdx);
     });
 });
+(0, vitest_1.describe)("ImageInstance.build worker resources", () => {
+    async function buildWith(options, storedLabels) {
+        const calls = [];
+        vitest_1.vi.spyOn(settings_js_1.settings, "authenticate").mockResolvedValue(undefined);
+        vitest_1.vi.spyOn(settings_js_1.settings, "headers", "get").mockReturnValue({});
+        vitest_1.vi.spyOn(settings_js_1.settings, "baseUrl", "get").mockReturnValue("https://api.test");
+        vitest_1.vi.stubGlobal("fetch", (url, init = {}) => {
+            const headers = init.headers;
+            const body = typeof init.body === "string" ? JSON.parse(init.body) : undefined;
+            calls.push({ url, method: init.method ?? "GET", headers, body });
+            if (url.includes("upload=true")) {
+                const sent = body.metadata?.labels;
+                return Promise.resolve(new Response(JSON.stringify({ metadata: { name: "img", labels: storedLabels ?? sent } }), {
+                    status: 200,
+                    headers: { "x-blaxel-upload-url": "https://upload.test/object" },
+                }));
+            }
+            if (url.startsWith("https://upload.test")) {
+                return Promise.resolve(new Response("", { status: 200 }));
+            }
+            return Promise.resolve(new Response(JSON.stringify({ metadata: { name: "img" }, status: "DEPLOYED" }), { status: 200 }));
+        });
+        const image = image_js_1.ImageInstance.fromRegistry("alpine:3.20");
+        // @ts-expect-error - private method
+        vitest_1.vi.spyOn(image, "_prepareForSandbox").mockReturnValue(image);
+        // @ts-expect-error - private method
+        vitest_1.vi.spyOn(image, "_waitForDeployment").mockResolvedValue("DEPLOYED");
+        await image.build({ name: "img", ...options });
+        return {
+            create: calls.find((call) => call.url.includes("upload=true")),
+            upload: calls.find((call) => call.url.startsWith("https://upload.test")),
+        };
+    }
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.restoreAllMocks();
+        vitest_1.vi.unstubAllGlobals();
+    });
+    (0, vitest_1.it)("sends build memory and volume as labels and signed upload headers", async () => {
+        const { create, upload } = await buildWith({ buildMemoryMb: 16384, buildVolumeMb: 32768 });
+        const labels = create.body.metadata?.labels;
+        (0, vitest_1.expect)(labels?.["x-blaxel-build-memory"]).toBe("16384");
+        (0, vitest_1.expect)(labels?.["x-blaxel-build-volume"]).toBe("32768");
+        (0, vitest_1.expect)(create.body.spec?.runtime?.memory).toBe(4096);
+        (0, vitest_1.expect)(upload.headers["x-amz-meta-x-blaxel-build-memory"]).toBe("16384");
+        (0, vitest_1.expect)(upload.headers["x-amz-meta-x-blaxel-build-volume"]).toBe("32768");
+        (0, vitest_1.expect)(upload.headers["x-amz-meta-x-blaxel-auto-generated"]).toBeUndefined();
+    });
+    (0, vitest_1.it)("keeps an explicit zero volume", async () => {
+        const { upload } = await buildWith({ buildVolumeMb: 0 });
+        (0, vitest_1.expect)(upload.headers["x-amz-meta-x-blaxel-build-volume"]).toBe("0");
+        (0, vitest_1.expect)(upload.headers["x-amz-meta-x-blaxel-build-memory"]).toBeUndefined();
+    });
+    (0, vitest_1.it)("sends no build headers by default", async () => {
+        const { upload } = await buildWith({});
+        (0, vitest_1.expect)(Object.keys(upload.headers).filter((name) => name.startsWith("x-amz-meta-"))).toEqual([]);
+    });
+    (0, vitest_1.it)("mirrors build labels the control plane already stored", async () => {
+        const { upload } = await buildWith({}, { "x-blaxel-auto-generated": "true", "x-blaxel-build-memory": "8192" });
+        (0, vitest_1.expect)(upload.headers["x-amz-meta-x-blaxel-build-memory"]).toBe("8192");
+    });
+    vitest_1.it.each([
+        [{ buildMemoryMb: 0 }, "buildMemoryMb"],
+        [{ buildMemoryMb: 32769 }, "buildMemoryMb"],
+        [{ buildMemoryMb: 1.5 }, "buildMemoryMb"],
+        [{ buildVolumeMb: -1 }, "buildVolumeMb"],
+        [{ buildVolumeMb: 131073 }, "buildVolumeMb"],
+    ])("rejects out-of-range %o before any request", async (options, option) => {
+        const fetchSpy = vitest_1.vi.fn();
+        vitest_1.vi.stubGlobal("fetch", fetchSpy);
+        await (0, vitest_1.expect)(image_js_1.ImageInstance.fromRegistry("alpine:3.20").build({ name: "img", ...options })).rejects.toThrow(option);
+        (0, vitest_1.expect)(fetchSpy).not.toHaveBeenCalled();
+    });
+});

package/dist/cjs/types/image/image.browser.d.ts

@@ -27,6 +27,8 @@ export interface ImageBuildOptions {
     timeout?: number;
     onStatusChange?: (status: string) => void;
     sandboxVersion?: string;
+    buildMemoryMb?: number;
+    buildVolumeMb?: number;
 }
 /**
  * A fluent builder for creating sandbox images programmatically.

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

@@ -28,6 +28,16 @@ export interface ImageBuildOptions {
     timeout?: number;
     onStatusChange?: (status: string) => void;
     sandboxVersion?: string;
+    /**
+     * Memory for the temporary build worker in MiB (1-32768). Same as
+     * `bl push --memory`. Does not change the deployed sandbox's memory.
+     */
+    buildMemoryMb?: number;
+    /**
+     * Scratch disk for the temporary build worker in MiB (0-131072). Same as
+     * `bl push --volume`; 0 uses memory-backed scratch.
+     */
+    buildVolumeMb?: number;
 }
 export interface PipInstallOptions {
     findLinks?: string;