@blaxel/core 0.2.69 → 0.2.70

package/dist/esm/client/sdk.gen.js

@@ -219,6 +219,120 @@ export const verifyCustomDomain = (options) => {
         ...options
     });
 };
+/**
+ * List drives
+ * Returns all drives in the workspace. Drives provide persistent storage that can be attached to agents, functions, and sandboxes.
+ */
+export const listDrives = (options) => {
+    return (options?.client ?? _heyApiClient).get({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/drives',
+        ...options
+    });
+};
+/**
+ * Create a drive
+ * Creates a new drive in the workspace. Drives are backed by SeaweedFS buckets and can be mounted at runtime to sandboxes.
+ */
+export const createDrive = (options) => {
+    return (options.client ?? _heyApiClient).post({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/drives',
+        ...options,
+        headers: {
+            'Content-Type': 'application/json',
+            ...options?.headers
+        }
+    });
+};
+/**
+ * Delete a drive
+ * Deletes a drive immediately. The drive record is removed from the database synchronously.
+ */
+export const deleteDrive = (options) => {
+    return (options.client ?? _heyApiClient).delete({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/drives/{driveName}',
+        ...options
+    });
+};
+/**
+ * Get a drive
+ * Retrieves details of a specific drive including its status and events.
+ */
+export const getDrive = (options) => {
+    return (options.client ?? _heyApiClient).get({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/drives/{driveName}',
+        ...options
+    });
+};
+/**
+ * Update a drive
+ * Updates an existing drive. Metadata fields like displayName and labels can be changed. Size can be set if not already configured.
+ */
+export const updateDrive = (options) => {
+    return (options.client ?? _heyApiClient).put({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/drives/{driveName}',
+        ...options,
+        headers: {
+            'Content-Type': 'application/json',
+            ...options?.headers
+        }
+    });
+};
+/**
+ * Create drive access token
+ * Issues a short-lived JWT access token scoped to a specific drive. The token can be used as Bearer authentication for direct S3 operations against the drive's SeaweedFS bucket.
+ */
+export const createDriveAccessToken = (options) => {
+    return (options.client ?? _heyApiClient).post({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/drives/{driveName}/access-token',
+        ...options
+    });
+};
+/**
+ * Get drive token JWKS
+ * Returns the JSON Web Key Set containing the Ed25519 public key used to verify drive access tokens. SeaweedFS or other S3-compatible storage can use this endpoint to validate Bearer tokens.
+ */
+export const getDriveJwks = (options) => {
+    return (options?.client ?? _heyApiClient).get({
+        url: '/drives/jwks.json',
+        ...options
+    });
+};
 /**
  * List all egress gateways across all VPCs in the workspace
  */

package/dist/esm/common/settings.js

@@ -3,8 +3,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.69";
-const BUILD_COMMIT = "a5d782ced9baa4585eefb6643399e73e504d3184";
+const BUILD_VERSION = "0.2.70";
+const BUILD_COMMIT = "a3bbb13aa4ec149d33f1662d30dfb10ce3683baf";
 const BUILD_SENTRY_DSN = "https://fd5e60e1c9820e1eef5ccebb84a07127@o4508714045276160.ingest.us.sentry.io/4510465864564736";
 // Cache for config.yaml tracking value
 let configTrackingValue = null;

package/dist/esm/drive/index.js

@@ -0,0 +1,178 @@
+import { v4 as uuidv4 } from "uuid";
+import { createDrive, deleteDrive, getDrive, listDrives, updateDrive } from "../client/index.js";
+import { settings } from "../common/settings.js";
+export class DriveInstance {
+    drive;
+    constructor(drive) {
+        this.drive = drive;
+    }
+    get metadata() {
+        return this.drive.metadata;
+    }
+    get spec() {
+        return this.drive.spec;
+    }
+    get state() {
+        return this.drive.state;
+    }
+    get status() {
+        return this.drive.status;
+    }
+    get name() {
+        return this.drive.metadata.name;
+    }
+    get displayName() {
+        return this.drive.metadata.displayName;
+    }
+    get size() {
+        return this.drive.spec.size;
+    }
+    get region() {
+        return this.drive.spec.region;
+    }
+    static async create(config) {
+        const defaultName = `drive-${uuidv4().replace(/-/g, '').substring(0, 8)}`;
+        let drive;
+        // Handle DriveCreateConfiguration or simple config object
+        if ('spec' in config && 'metadata' in config) {
+            // It's already a Drive object
+            drive = config;
+        }
+        else {
+            drive = {
+                metadata: {
+                    name: config.name || defaultName,
+                    displayName: config.displayName || config.name || defaultName,
+                    labels: config.labels
+                },
+                spec: {
+                    size: config.size,
+                    region: config.region || settings.region
+                }
+            };
+        }
+        // Ensure required fields have defaults
+        if (!drive.metadata) {
+            drive.metadata = { name: defaultName };
+        }
+        if (!drive.metadata.name) {
+            drive.metadata.name = defaultName;
+        }
+        if (!drive.spec) {
+            drive.spec = {};
+        }
+        if (!drive.spec.region && settings.region) {
+            drive.spec.region = settings.region;
+        }
+        if (!drive.spec.region) {
+            console.warn("DriveInstance.create: 'region' is not set. In a future version, 'region' will be a required parameter. " +
+                "Please specify a region (e.g. 'us-pdx-1', 'eu-lon-1', 'eu-dub-1') in the drive configuration or set the BL_REGION environment variable.");
+        }
+        const { data } = await createDrive({
+            body: drive,
+            throwOnError: true,
+        });
+        return new DriveInstance(data);
+    }
+    static async get(driveName) {
+        const { data } = await getDrive({
+            path: {
+                driveName,
+            },
+            throwOnError: true,
+        });
+        return new DriveInstance(data);
+    }
+    static async list() {
+        const { data } = await listDrives({ throwOnError: true });
+        return data.map((drive) => new DriveInstance(drive));
+    }
+    static async delete(driveName) {
+        const { data } = await deleteDrive({
+            path: {
+                driveName,
+            },
+            throwOnError: true,
+        });
+        return data;
+    }
+    async delete() {
+        return await DriveInstance.delete(this.metadata.name);
+    }
+    static async update(driveName, updates) {
+        const drive = await DriveInstance.get(driveName);
+        const metadataUpdates = {};
+        const specUpdates = {};
+        if ('spec' in updates && 'metadata' in updates) {
+            // It's a Drive object - only include defined fields
+            if (updates.metadata) {
+                if (updates.metadata.displayName !== undefined)
+                    metadataUpdates.displayName = updates.metadata.displayName;
+                if (updates.metadata.labels !== undefined)
+                    metadataUpdates.labels = updates.metadata.labels;
+            }
+            if (updates.spec) {
+                if (updates.spec.size !== undefined)
+                    specUpdates.size = updates.spec.size;
+                if (updates.spec.region !== undefined)
+                    specUpdates.region = updates.spec.region;
+            }
+        }
+        else {
+            // It's a DriveCreateConfiguration - only include defined fields
+            if (updates.displayName !== undefined)
+                metadataUpdates.displayName = updates.displayName;
+            if (updates.labels !== undefined)
+                metadataUpdates.labels = updates.labels;
+            if (updates.size !== undefined)
+                specUpdates.size = updates.size;
+            if (updates.region !== undefined)
+                specUpdates.region = updates.region;
+        }
+        const body = {
+            metadata: {
+                ...drive.metadata,
+                ...metadataUpdates,
+            },
+            spec: {
+                ...drive.spec,
+                ...specUpdates,
+            },
+        };
+        const { data } = await updateDrive({
+            path: { driveName },
+            body,
+            throwOnError: true,
+        });
+        const newDrive = {
+            metadata: data.metadata,
+            spec: data.spec,
+            events: data.events,
+            state: data.state,
+            status: data.status,
+        };
+        // This is for safe update
+        await new Promise(resolve => setTimeout(resolve, 500));
+        return new DriveInstance(newDrive);
+    }
+    async update(updates) {
+        const updated = await DriveInstance.update(this.metadata.name, updates);
+        return updated;
+    }
+    static async createIfNotExists(config) {
+        try {
+            return await DriveInstance.create(config);
+        }
+        catch (e) {
+            if (typeof e === "object" && e !== null && "code" in e && (e.code === 409 || e.code === 'DRIVE_ALREADY_EXISTS')) {
+                const name = 'name' in config ? config.name : config.metadata.name;
+                if (!name) {
+                    throw new Error("Drive name is required");
+                }
+                const driveInstance = await DriveInstance.get(name);
+                return driveInstance;
+            }
+            throw e;
+        }
+    }
+}

package/dist/esm/index.js

@@ -9,6 +9,7 @@ export * from "./common/internal.js";
 export * from "./common/logger.js";
 export * from "./common/settings.js";
 export * from "./common/webhook.js";
+export * from "./drive/index.js";
 export * from "./image/index.js";
 export * from "./jobs/index.js";
 export * from "./mcp/index.js";

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

@@ -0,0 +1,66 @@
+import { settings } from "../../common/settings.js";
+import { SandboxAction } from "../action.js";
+export class SandboxDrive extends SandboxAction {
+    constructor(sandbox) {
+        super(sandbox);
+    }
+    /**
+     * Mount a drive to the sandbox at a specific mount path
+     */
+    async mount(request) {
+        const headers = this.sandbox.forceUrl ? this.sandbox.headers : settings.headers;
+        const body = {
+            driveName: request.driveName,
+            mountPath: request.mountPath,
+            drivePath: request.drivePath || "/",
+        };
+        const response = await fetch(`${this.url}/drives/mount`, {
+            method: 'POST',
+            headers: {
+                ...headers,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to mount drive: ${errorText}`);
+        }
+        return await response.json();
+    }
+    /**
+     * Unmount a drive from the sandbox by mount path
+     */
+    async unmount(mountPath) {
+        const headers = this.sandbox.forceUrl ? this.sandbox.headers : settings.headers;
+        // Ensure mountPath starts with /
+        const normalizedPath = mountPath.startsWith('/') ? mountPath : `/${mountPath}`;
+        // Remove leading slash for URL (DELETE /drives/mnt/test not /drives//mnt/test)
+        const urlPath = normalizedPath.substring(1);
+        const response = await fetch(`${this.url}/drives/mount/${urlPath}`, {
+            method: 'DELETE',
+            headers,
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to unmount drive: ${errorText}`);
+        }
+        return await response.json();
+    }
+    /**
+     * List all mounted drives in the sandbox
+     */
+    async list() {
+        const headers = this.sandbox.forceUrl ? this.sandbox.headers : settings.headers;
+        const response = await fetch(`${this.url}/drives/mount`, {
+            method: 'GET',
+            headers,
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to list drives: ${errorText}`);
+        }
+        const data = await response.json();
+        return data.mounts || [];
+    }
+}

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

@@ -0,0 +1 @@
+export * from "./drive.js";

package/dist/esm/sandbox/sandbox.js

@@ -3,6 +3,7 @@ import { createSandbox, deleteSandbox, getSandbox, listSandboxes, updateSandbox
 import { logger } from "../common/logger.js";
 import { settings } from "../common/settings.js";
 import { SandboxCodegen } from "./codegen/index.js";
+import { SandboxDrive } from "./drive/index.js";
 import { SandboxFileSystem } from "./filesystem/index.js";
 import { SandboxNetwork } from "./network/index.js";
 import { SandboxPreviews } from "./preview.js";
@@ -19,6 +20,7 @@ export class SandboxInstance {
     sessions;
     codegen;
     system;
+    drives;
     constructor(sandbox) {
         this.sandbox = sandbox;
         this.process = new SandboxProcess(sandbox);
@@ -28,6 +30,7 @@ export class SandboxInstance {
         this.sessions = new SandboxSessions(sandbox);
         this.codegen = new SandboxCodegen(sandbox);
         this.system = new SandboxSystem(sandbox);
+        this.drives = new SandboxDrive(sandbox);
     }
     get metadata() {
         return this.sandbox.metadata;