@blaxel/core 0.2.96-preview.204 → 0.2.96-preview.206

package/dist/cjs/common/pagination.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unwrapListData = unwrapListData;
+exports.createPaginatedList = createPaginatedList;
+function unwrapListData(response) {
+    if (!response) {
+        return [];
+    }
+    if (Array.isArray(response)) {
+        return response;
+    }
+    return response.data ?? [];
+}
+function unwrapListMeta(response) {
+    if (!response || Array.isArray(response)) {
+        return { hasMore: false };
+    }
+    return response.meta ?? { hasMore: false };
+}
+async function createPaginatedList({ response, fetchPage, mapItem, query, seenCursors, }) {
+    const meta = unwrapListMeta(response);
+    const data = await Promise.all(unwrapListData(response).map(mapItem));
+    const cursors = new Set(seenCursors);
+    if (query?.cursor) {
+        cursors.add(query.cursor);
+    }
+    const list = {
+        data,
+        meta,
+        // Derive `hasMore` from cursor presence, not `meta.hasMore`: `nextPage()`
+        // can only advance when there is a `nextCursor`, so a consumer doing
+        // `if (page.hasMore) await page.nextPage()` must never see `hasMore: true`
+        // while `nextPage()` returns null. Keeping the two in sync prevents silent
+        // truncation if the API ever sends `hasMore: true` without a cursor.
+        get hasMore() {
+            return Boolean(list.nextCursor);
+        },
+        get nextCursor() {
+            return meta.nextCursor || undefined;
+        },
+        async nextPage() {
+            const cursor = list.nextCursor;
+            if (!cursor) {
+                return null;
+            }
+            if (cursors.has(cursor)) {
+                throw new Error("Pagination returned a repeated cursor");
+            }
+            const nextQuery = { ...(query ?? {}), cursor };
+            const nextSeenCursors = new Set(cursors);
+            nextSeenCursors.add(cursor);
+            return createPaginatedList({
+                response: await fetchPage(nextQuery),
+                fetchPage,
+                mapItem,
+                query: nextQuery,
+                seenCursors: nextSeenCursors,
+            });
+        },
+        async autoPagingEach(onItem) {
+            for await (const item of list) {
+                const shouldContinue = await onItem(item);
+                if (shouldContinue === false) {
+                    return;
+                }
+            }
+        },
+        async autoPagingToArray(options) {
+            if (!options || !Number.isFinite(options.limit) || options.limit <= 0) {
+                throw new Error("autoPagingToArray requires a positive limit");
+            }
+            const items = [];
+            for await (const item of list) {
+                items.push(item);
+                if (items.length >= options.limit) {
+                    return items;
+                }
+            }
+            return items;
+        },
+        async *[Symbol.asyncIterator]() {
+            let page = list;
+            while (page) {
+                for (const item of page.data) {
+                    yield item;
+                }
+                page = await page.nextPage();
+            }
+        },
+    };
+    return list;
+}

package/dist/cjs/common/pagination.test.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const pagination_js_1 = require("./pagination.js");
+(0, vitest_1.describe)("pagination helpers", () => {
+    (0, vitest_1.it)("unwraps legacy array and paginated list responses", () => {
+        (0, vitest_1.expect)((0, pagination_js_1.unwrapListData)([{ name: "legacy" }])).toEqual([{ name: "legacy" }]);
+        (0, vitest_1.expect)((0, pagination_js_1.unwrapListData)({
+            data: [{ name: "paginated" }],
+            meta: { hasMore: false },
+        })).toEqual([{ name: "paginated" }]);
+    });
+    (0, vitest_1.it)("returns page data and lets callers request the next page", async () => {
+        const cursors = [];
+        const fetchPage = async (query) => {
+            await Promise.resolve();
+            cursors.push(query?.cursor);
+            if (!query?.cursor) {
+                return {
+                    data: ["first"],
+                    meta: { hasMore: true, nextCursor: "next-page" },
+                };
+            }
+            return {
+                data: ["second"],
+                meta: { hasMore: false },
+            };
+        };
+        const page = await (0, pagination_js_1.createPaginatedList)({
+            response: await fetchPage(),
+            fetchPage,
+            mapItem: (item) => item.toUpperCase(),
+        });
+        (0, vitest_1.expect)(page.data).toEqual(["FIRST"]);
+        (0, vitest_1.expect)(page.hasMore).toBe(true);
+        (0, vitest_1.expect)(page.nextCursor).toBe("next-page");
+        const nextPage = await page.nextPage();
+        (0, vitest_1.expect)(nextPage?.data).toEqual(["SECOND"]);
+        (0, vitest_1.expect)(cursors).toEqual([undefined, "next-page"]);
+    });
+    (0, vitest_1.it)("keeps hasMore consistent with nextPage when the API omits a cursor", async () => {
+        const fetchPage = async () => {
+            await Promise.resolve();
+            // API reports more data but gives no cursor to fetch it.
+            return {
+                data: ["only"],
+                meta: { hasMore: true },
+            };
+        };
+        const page = await (0, pagination_js_1.createPaginatedList)({
+            response: await fetchPage(),
+            fetchPage,
+            mapItem: (item) => item,
+        });
+        // hasMore must reflect what nextPage() can actually deliver.
+        (0, vitest_1.expect)(page.hasMore).toBe(false);
+        await (0, vitest_1.expect)(page.nextPage()).resolves.toBeNull();
+        await (0, vitest_1.expect)(page.autoPagingToArray({ limit: 10 })).resolves.toEqual(["only"]);
+    });
+    (0, vitest_1.it)("supports auto paging with an explicit limit", async () => {
+        const fetchPage = async (query) => {
+            await Promise.resolve();
+            if (!query?.cursor) {
+                return {
+                    data: ["first"],
+                    meta: { hasMore: true, nextCursor: "next-page" },
+                };
+            }
+            return {
+                data: ["second"],
+                meta: { hasMore: false },
+            };
+        };
+        const page = await (0, pagination_js_1.createPaginatedList)({
+            response: await fetchPage(),
+            fetchPage,
+            mapItem: (item) => item,
+        });
+        await (0, vitest_1.expect)(page.autoPagingToArray({ limit: 2 })).resolves.toEqual(["first", "second"]);
+    });
+});

package/dist/cjs/common/settings.js

@@ -28,10 +28,10 @@ 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.96-preview.204";
-const BUILD_COMMIT = "05c335edad327feae5ecd407b96b385a7662a701";
+const BUILD_VERSION = "0.2.96-preview.206";
+const BUILD_COMMIT = "f48d4c2e1e8d3bd3ee61decfacc3cd4f3ab0323d";
 const BUILD_SENTRY_DSN = "https://fd5e60e1c9820e1eef5ccebb84a07127@o4508714045276160.ingest.us.sentry.io/4510465864564736";
-const BLAXEL_API_VERSION = "2026-04-16";
+const BLAXEL_API_VERSION = "2026-04-28";
 // Cache for config.yaml tracking value
 let configTrackingValue = null;
 let configTrackingLoaded = false;

package/dist/cjs/common/settings.test.js

@@ -43,10 +43,10 @@ const env_js_1 = require("./env.js");
     (0, vitest_1.afterEach)(() => {
         delete env_js_1.env.BL_API_VERSION;
     });
-    (0, vitest_1.it)('defaults to 2026-04-16 when BL_API_VERSION is not set', async () => {
+    (0, vitest_1.it)('defaults to 2026-04-28 when BL_API_VERSION is not set', async () => {
         delete env_js_1.env.BL_API_VERSION;
         const { settings } = await Promise.resolve().then(() => __importStar(require('./settings.js')));
-        (0, vitest_1.expect)(settings.apiVersion).toBe('2026-04-16');
+        (0, vitest_1.expect)(settings.apiVersion).toBe('2026-04-28');
     });
     (0, vitest_1.it)('headers include Blaxel-Version set to the default', async () => {
         delete env_js_1.env.BL_API_VERSION;
@@ -55,7 +55,7 @@ const env_js_1 = require("./env.js");
         const previous = settings.credentials;
         settings.credentials = new apikey_js_1.ApiKey({ apiKey: 'test-key', workspace: 'test-ws' });
         try {
-            (0, vitest_1.expect)(settings.headers['Blaxel-Version']).toBe('2026-04-16');
+            (0, vitest_1.expect)(settings.headers['Blaxel-Version']).toBe('2026-04-28');
         }
         finally {
             settings.credentials = previous;

package/dist/cjs/drive/index.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DriveInstance = void 0;
 const uuid_1 = require("uuid");
 const index_js_1 = require("../client/index.js");
+const pagination_js_1 = require("../common/pagination.js");
 const settings_js_1 = require("../common/settings.js");
 class DriveInstance {
     drive;
@@ -90,10 +91,44 @@ class DriveInstance {
         });
         return new DriveInstance(data);
     }
-    static async list() {
-        const { data } = await (0, index_js_1.listDrives)({ throwOnError: true });
-        const items = Array.isArray(data) ? data : (data?.data ?? []);
-        return items.map((drive) => new DriveInstance(drive));
+    /**
+     * List one page of drives.
+     *
+     * The returned page exposes `data` for the current page, `meta` for cursor
+     * metadata, and helpers to fetch more pages only when you need them.
+     *
+     * @example
+     * ```ts
+     * const page = await DriveInstance.list({ limit: 50 });
+     *
+     * for (const drive of page.data) {
+     *   console.log(drive.name);
+     * }
+     *
+     * const nextPage = await page.nextPage();
+     * ```
+     *
+     * @example
+     * ```ts
+     * const allDrives = await (await DriveInstance.list()).autoPagingToArray({
+     *   limit: 1000,
+     * });
+     * ```
+     */
+    static async list(query) {
+        const fetchPage = async (pageQuery) => {
+            const { data } = await (0, index_js_1.listDrives)({
+                query: pageQuery,
+                throwOnError: true,
+            });
+            return data;
+        };
+        return (0, pagination_js_1.createPaginatedList)({
+            response: await fetchPage(query),
+            fetchPage,
+            mapItem: (drive) => new DriveInstance(drive),
+            query,
+        });
     }
     static async delete(driveName) {
         const { data } = await (0, index_js_1.deleteDrive)({

package/dist/cjs/index.js

@@ -23,6 +23,7 @@ __exportStar(require("./common/node.js"), exports);
 __exportStar(require("./common/errors.js"), exports);
 __exportStar(require("./common/internal.js"), exports);
 __exportStar(require("./common/logger.js"), exports);
+__exportStar(require("./common/pagination.js"), exports);
 __exportStar(require("./common/settings.js"), exports);
 __exportStar(require("./common/webhook.js"), exports);
 __exportStar(require("./drive/index.js"), exports);

package/dist/cjs/jobs/jobs.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.blJob = void 0;
 const index_js_1 = require("../client/index.js");
 const logger_js_1 = require("../common/logger.js");
+const pagination_js_1 = require("../common/pagination.js");
 const settings_js_1 = require("../common/settings.js");
 const telemetry_js_1 = require("../telemetry/telemetry.js");
 class BlJob {
@@ -78,19 +79,50 @@ class BlJob {
         return data;
     }
     /**
-     * List all executions for this job
+     * List one page of executions for this job.
+     *
+     * The returned page exposes `data` for the current page, `meta` for cursor
+     * metadata, and helpers to fetch more pages only when you need them.
+     *
+     * @example
+     * ```ts
+     * const job = blJob("daily-import");
+     * const page = await job.listExecutions({ limit: 50 });
+     *
+     * for (const execution of page.data) {
+     *   console.log(execution.status);
+     * }
+     *
+     * const nextPage = await page.nextPage();
+     * ```
+     *
+     * @example
+     * ```ts
+     * const job = blJob("daily-import");
+     * const executions = await (await job.listExecutions()).autoPagingToArray({
+     *   limit: 1000,
+     * });
+     * ```
      */
-    async listExecutions() {
+    async listExecutions(query) {
         logger_js_1.logger.debug(`Listing executions for job: ${this.jobName}`);
-        const { data } = await (0, index_js_1.listJobExecutions)({
-            path: {
-                jobId: this.jobName,
-            },
-            headers: settings_js_1.settings.headers,
-            throwOnError: true,
+        const fetchPage = async (pageQuery) => {
+            const { data } = await (0, index_js_1.listJobExecutions)({
+                path: {
+                    jobId: this.jobName,
+                },
+                query: pageQuery,
+                headers: settings_js_1.settings.headers,
+                throwOnError: true,
+            });
+            return data;
+        };
+        return (0, pagination_js_1.createPaginatedList)({
+            response: await fetchPage(query),
+            fetchPage,
+            mapItem: (execution) => execution,
+            query,
         });
-        const items = Array.isArray(data) ? data : (data?.data ?? []);
-        return items;
     }
     /**
      * Get the status of a specific execution

package/dist/cjs/sandbox/client/sdk.gen.js

@@ -92,7 +92,7 @@ const getDrivesMount = (options) => {
 exports.getDrivesMount = getDrivesMount;
 /**
  * Attach a drive to a local path
- * Mounts an agent drive using the blfs binary to a local path, optionally mounting a subpath within the drive
+ * Mounts an agent drive using the blfs binary to a local path, optionally mounting a subpath within the drive. Supports optional UID/GID mapping to remap file ownership between the local sandbox and the filer (always mapped to filer UID/GID 0). Mapping values can be set per-request via uidMap/gidMap fields, or globally via BLFS_UID_MAP/BLFS_GID_MAP environment variables (request values take precedence).
  */
 const postDrivesMount = (options) => {
     return (options.client ?? client_gen_1.client).post({
@@ -643,7 +643,7 @@ exports.getProcessByIdentifierLogsStream = getProcessByIdentifierLogsStream;
  * Triggers an upgrade of the sandbox-api process. Returns 200 immediately before upgrading.
  * The upgrade will: download the specified binary from GitHub releases, validate it, and restart.
  * All running processes will be preserved across the upgrade.
- * Available versions: "develop" (default), "main", "latest", or specific tag like "v1.0.0"
+ * Available versions: "latest" (default, most recent release), "develop", "main", or specific tag like "v1.0.0"
  * You can also specify a custom baseUrl for forks (defaults to https://github.com/blaxel-ai/sandbox/releases)
  */
 const postUpgrade = (options) => {

package/dist/cjs/sandbox/preview.js

@@ -105,24 +105,29 @@ class SandboxPreviews {
         });
         return data.map((preview) => new SandboxPreview(preview));
     }
-    async create(preview) {
+    async create(preview, force) {
+        const query = {};
+        if (force) {
+            query['force'] = 'true';
+        }
         const { data } = await (0, index_js_1.createSandboxPreview)({
             path: {
                 sandboxName: this.sandboxName,
             },
+            query,
             body: preview,
             throwOnError: true,
         });
         return new SandboxPreview(data);
     }
-    async createIfNotExists(preview) {
+    async createIfNotExists(preview, force) {
         try {
             const previewInstance = await this.get(preview.metadata.name);
             return previewInstance;
         }
         catch (e) {
             if (typeof e === "object" && e !== null && "code" in e && e.code === 404) {
-                return this.create(preview);
+                return this.create(preview, force);
             }
             throw e;
         }

package/dist/cjs/sandbox/sandbox.js

@@ -37,6 +37,7 @@ exports.SandboxInstance = void 0;
 const uuid_1 = require("uuid");
 const index_js_1 = require("../client/index.js");
 const logger_js_1 = require("../common/logger.js");
+const pagination_js_1 = require("../common/pagination.js");
 const settings_js_1 = require("../common/settings.js");
 const index_js_2 = require("./codegen/index.js");
 const index_js_3 = require("./drive/index.js");
@@ -283,40 +284,46 @@ class SandboxInstance {
         const instance = new SandboxInstance(data);
         return SandboxInstance.attachH2Session(instance);
     }
-    static async list({ externalId } = {}) {
-        const { data: raw } = await (0, index_js_1.listSandboxes)({
-            query: externalId ? { externalId } : undefined,
-            throwOnError: true,
+    /**
+     * List one page of sandboxes.
+     *
+     * The returned page exposes `data` for the current page, `meta` for cursor
+     * metadata, and helpers to fetch more pages only when you need them.
+     *
+     * @example
+     * ```ts
+     * const page = await SandboxInstance.list({ limit: 50 });
+     *
+     * for (const sandbox of page.data) {
+     *   console.log(sandbox.metadata.name);
+     * }
+     *
+     * const nextPage = await page.nextPage();
+     * ```
+     *
+     * @example
+     * ```ts
+     * const page = await SandboxInstance.list({ limit: 100 });
+     *
+     * for await (const sandbox of page) {
+     *   console.log(sandbox.metadata.name);
+     * }
+     * ```
+     */
+    static async list(query) {
+        const fetchPage = async (pageQuery) => {
+            const { data } = await (0, index_js_1.listSandboxes)({
+                query: pageQuery,
+                throwOnError: true,
+            });
+            return data;
+        };
+        return (0, pagination_js_1.createPaginatedList)({
+            response: await fetchPage(query),
+            fetchPage,
+            mapItem: (sandbox) => SandboxInstance.attachH2Session(new SandboxInstance(sandbox)),
+            query,
         });
-        const items = (Array.isArray(raw) ? raw : (raw?.data ?? []));
-        const instances = items.map((sb) => new SandboxInstance(sb));
-        if (!settings_js_1.settings.disableH2) {
-            const { h2Pool } = await Promise.resolve().then(() => __importStar(require("../common/h2pool.js")));
-            const uniqueDomains = [
-                ...new Set(instances
-                    .map((i) => SandboxInstance.edgeDomainForRegion(i.spec?.region))
-                    .filter((d) => d !== null)),
-            ];
-            const sessionByDomain = new Map();
-            await Promise.all(uniqueDomains.map(async (domain) => {
-                try {
-                    sessionByDomain.set(domain, await h2Pool.get(domain));
-                }
-                catch {
-                    sessionByDomain.set(domain, null);
-                }
-            }));
-            for (const instance of instances) {
-                const domain = SandboxInstance.edgeDomainForRegion(instance.spec?.region);
-                if (domain) {
-                    const session = sessionByDomain.get(domain) ?? null;
-                    instance.h2Session = session;
-                    instance.sandbox.h2Session = session;
-                    instance.sandbox.h2Domain = domain;
-                }
-            }
-        }
-        return instances;
     }
     static async delete(sandboxName) {
         const { data } = await (0, index_js_1.deleteSandbox)({

package/dist/cjs/sandbox/schedule.js

@@ -2,15 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SandboxSchedules = void 0;
 const index_js_1 = require("../client/index.js");
-// Schedule list endpoints return a bare array on older API versions and a
-// cursor-paginated `{ data, meta }` envelope starting on Blaxel-Version
-// 2026-04-28. Handle both so the wrapper works regardless of the SDK's default
-// version.
-function unwrapPage(data) {
-    if (Array.isArray(data))
-        return data;
-    return data?.data ?? [];
-}
+const pagination_js_1 = require("../common/pagination.js");
 // SandboxSchedules manages a sandbox's schedules. A schedule entry is a flat
 // record (id/type/value/input) with no sub-resource of its own, so methods
 // return the raw SandboxScheduleEntry rather than a wrapper class (the generated
@@ -23,15 +15,38 @@ class SandboxSchedules {
     get sandboxName() {
         return this.sandbox.metadata.name;
     }
+    /**
+     * List one page of the sandbox's schedules.
+     *
+     * The returned page exposes `data` for the current page, `meta` for cursor
+     * metadata, and `nextPage()` / `autoPagingEach()` / `autoPagingToArray()`
+     * helpers. Iterate it directly with `for await` to walk every page.
+     *
+     * @example
+     * ```ts
+     * const page = await sandbox.schedules.list({ limit: 50 });
+     * for await (const schedule of page) {
+     *   console.log(schedule.id);
+     * }
+     * ```
+     */
     async list(options = {}) {
-        const { data } = await (0, index_js_1.listSandboxSchedules)({
-            path: {
-                sandboxName: this.sandboxName,
-            },
+        const fetchPage = async (query) => {
+            const { data } = await (0, index_js_1.listSandboxSchedules)({
+                path: {
+                    sandboxName: this.sandboxName,
+                },
+                query,
+                throwOnError: true,
+            });
+            return data;
+        };
+        return (0, pagination_js_1.createPaginatedList)({
+            response: await fetchPage(options),
+            fetchPage,
+            mapItem: (entry) => entry,
             query: options,
-            throwOnError: true,
         });
-        return unwrapPage(data);
     }
     async create(schedule) {
         const { data } = await (0, index_js_1.createSandboxSchedule)({
@@ -77,15 +92,30 @@ class SandboxSchedules {
     // List the execution history of every schedule on the sandbox, newest first.
     // Executions are sandbox-scoped, not per-schedule; filter by `scheduleId` on
     // the returned records to isolate a single schedule's runs.
+    /**
+     * List one page of schedule executions, newest first.
+     *
+     * The returned page exposes `data`, `meta`, and `nextPage()` /
+     * `autoPagingEach()` / `autoPagingToArray()` helpers. Iterate it directly
+     * with `for await` to walk every page.
+     */
     async executions(options = {}) {
-        const { data } = await (0, index_js_1.listSandboxScheduleExecutions)({
-            path: {
-                sandboxName: this.sandboxName,
-            },
+        const fetchPage = async (query) => {
+            const { data } = await (0, index_js_1.listSandboxScheduleExecutions)({
+                path: {
+                    sandboxName: this.sandboxName,
+                },
+                query,
+                throwOnError: true,
+            });
+            return data;
+        };
+        return (0, pagination_js_1.createPaginatedList)({
+            response: await fetchPage(options),
+            fetchPage,
+            mapItem: (execution) => execution,
             query: options,
-            throwOnError: true,
         });
-        return unwrapPage(data);
     }
 }
 exports.SandboxSchedules = SandboxSchedules;

package/dist/cjs/types/common/pagination.d.ts

@@ -0,0 +1,35 @@
+export type PaginatedListMeta = {
+    hasMore?: boolean;
+    nextCursor?: string;
+    total?: number;
+};
+export type CursorPaginationQuery = {
+    cursor?: string;
+};
+export type ListResponse<T> = T[] | {
+    data?: T[] | null;
+    meta?: PaginatedListMeta | null;
+} | null | undefined;
+export type AutoPagingEachCallback<T> = (item: T) => boolean | void | Promise<boolean | void>;
+export type AutoPagingToArrayOptions = {
+    limit: number;
+};
+export type PaginatedList<T, TQuery extends CursorPaginationQuery = CursorPaginationQuery> = AsyncIterable<T> & {
+    data: T[];
+    meta: PaginatedListMeta;
+    hasMore: boolean;
+    nextCursor?: string;
+    nextPage(): Promise<PaginatedList<T, TQuery> | null>;
+    autoPagingEach(onItem: AutoPagingEachCallback<T>): Promise<void>;
+    autoPagingToArray(options: AutoPagingToArrayOptions): Promise<T[]>;
+};
+type CreatePaginatedListOptions<TRaw, TItem, TQuery extends CursorPaginationQuery> = {
+    response: ListResponse<TRaw>;
+    fetchPage: (query?: TQuery) => Promise<ListResponse<TRaw>>;
+    mapItem: (item: TRaw) => TItem | Promise<TItem>;
+    query?: TQuery;
+    seenCursors?: Set<string>;
+};
+export declare function unwrapListData<T>(response: ListResponse<T>): T[];
+export declare function createPaginatedList<TRaw, TItem, TQuery extends CursorPaginationQuery = CursorPaginationQuery>({ response, fetchPage, mapItem, query, seenCursors, }: CreatePaginatedListOptions<TRaw, TItem, TQuery>): Promise<PaginatedList<TItem, TQuery>>;
+export {};

package/dist/cjs/types/common/pagination.test.d.ts

@@ -0,0 +1 @@
+export {};