@blaxel/core 0.3.26-preview.314 → 0.3.26

package/dist/esm/common/settings.js

@@ -24,8 +24,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/esm/image/image.js

@@ -11,6 +11,37 @@ function ensureNodeEnvironment() {
 }
 export const SANDBOX_API_IMAGE = "ghcr.io/blaxel-ai/sandbox";
 export const 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}`];
@@ -616,9 +647,10 @@ export 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,
@@ -660,12 +692,16 @@ export 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) {
@@ -736,6 +772,16 @@ export 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
@@ -744,7 +790,7 @@ export 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) {
@@ -754,8 +800,18 @@ export 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/esm/image/image.test.js

@@ -4,7 +4,8 @@
 import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "fs";
 import { tmpdir } from "os";
 import { join } from "path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { settings } from "../common/settings.js";
 import { ImageInstance } from "./image.js";
 // Test fixtures
 let tempDir;
@@ -541,3 +542,76 @@ describe("Dockerfile instruction order", () => {
         expect(runIdx).toBeLessThan(thirdIdx);
     });
 });
+describe("ImageInstance.build worker resources", () => {
+    async function buildWith(options, storedLabels) {
+        const calls = [];
+        vi.spyOn(settings, "authenticate").mockResolvedValue(undefined);
+        vi.spyOn(settings, "headers", "get").mockReturnValue({});
+        vi.spyOn(settings, "baseUrl", "get").mockReturnValue("https://api.test");
+        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 = ImageInstance.fromRegistry("alpine:3.20");
+        // @ts-expect-error - private method
+        vi.spyOn(image, "_prepareForSandbox").mockReturnValue(image);
+        // @ts-expect-error - private method
+        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")),
+        };
+    }
+    afterEach(() => {
+        vi.restoreAllMocks();
+        vi.unstubAllGlobals();
+    });
+    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;
+        expect(labels?.["x-blaxel-build-memory"]).toBe("16384");
+        expect(labels?.["x-blaxel-build-volume"]).toBe("32768");
+        expect(create.body.spec?.runtime?.memory).toBe(4096);
+        expect(upload.headers["x-amz-meta-x-blaxel-build-memory"]).toBe("16384");
+        expect(upload.headers["x-amz-meta-x-blaxel-build-volume"]).toBe("32768");
+        expect(upload.headers["x-amz-meta-x-blaxel-auto-generated"]).toBeUndefined();
+    });
+    it("keeps an explicit zero volume", async () => {
+        const { upload } = await buildWith({ buildVolumeMb: 0 });
+        expect(upload.headers["x-amz-meta-x-blaxel-build-volume"]).toBe("0");
+        expect(upload.headers["x-amz-meta-x-blaxel-build-memory"]).toBeUndefined();
+    });
+    it("sends no build headers by default", async () => {
+        const { upload } = await buildWith({});
+        expect(Object.keys(upload.headers).filter((name) => name.startsWith("x-amz-meta-"))).toEqual([]);
+    });
+    it("mirrors build labels the control plane already stored", async () => {
+        const { upload } = await buildWith({}, { "x-blaxel-auto-generated": "true", "x-blaxel-build-memory": "8192" });
+        expect(upload.headers["x-amz-meta-x-blaxel-build-memory"]).toBe("8192");
+    });
+    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 = vi.fn();
+        vi.stubGlobal("fetch", fetchSpy);
+        await expect(ImageInstance.fromRegistry("alpine:3.20").build({ name: "img", ...options })).rejects.toThrow(option);
+        expect(fetchSpy).not.toHaveBeenCalled();
+    });
+});