@blaxel/core 0.3.32 → 0.3.34-preview.340

package/dist/cjs/common/posthog.js

@@ -8,14 +8,13 @@ const node_js_1 = require("../common/node.js");
 const settings_js_1 = require("./settings.js");
 // PostHog API key injected at build time via build:replace-imports
 const BUILD_POSTHOG_KEY = "";
-// PostHog API endpoint
-const POSTHOG_HOST = "https://us.i.posthog.com";
+const POSTHOG_HOST = "https://events.blaxel.ai";
 /**
  * How long a capture may stay outstanding.
  *
  * Node keeps the event loop alive while a fetch is pending, so this is what a
  * short-lived script waits for before it can exit. A capture against
- * us.i.posthog.com takes ~250-350ms end to end (DNS + TLS handshake + POST), so
+ * events.blaxel.ai takes ~250-350ms end to end (DNS + TLS handshake + POST), so
  * a second covers the happy path with headroom. The ceiling matters because a
  * version is only recorded after a successful delivery: when the endpoint is
  * unreachable every later run tries again, and networks that silently drop

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.32";
-const BUILD_COMMIT = "85c4e5d52f8c501ac8db9409390611090a3e4df2";
+const BUILD_VERSION = "0.3.34-preview.340";
+const BUILD_COMMIT = "e1289af07e1a5c5efeb0af7b397d2c2fd138d89f";
 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/sandbox/client/sdk.gen.js

@@ -466,7 +466,11 @@ const deleteFilesystemTreeByPath = (options) => {
 exports.deleteFilesystemTreeByPath = deleteFilesystemTreeByPath;
 /**
  * Get directory tree
- * Get a recursive directory tree structure starting from the specified path
+ * List a directory. Without query parameters, `files` and `subdirectories` hold its direct children.
+ *
+ * With `recursive=true`, they hold every file and directory below the path (flat, with full paths). With `content=true`, each regular file (or symlink to one) also carries its `content` as UTF-8 text, like a JSON file read; other entries have no `content`. `patterns`, `excludeDirs` and `excludeHidden` select entries the same way as find, but nothing is excluded by default.
+ *
+ * The response is all or nothing: when more than `maxFiles` files match, or `content=true` and they hold more than `maxBytes` bytes, the request fails with 422 before any content is read.
  */
 const getFilesystemTreeByPath = (options) => {
     return (options.client ?? client_gen_1.client).get({

package/dist/cjs/sandbox/filesystem/filesystem.js

@@ -207,12 +207,45 @@ class SandboxFileSystem extends action_js_1.SandboxAction {
                 baseUrl: this.url,
             }));
             this.handleResponseError(response, data, error);
-            if (data && 'content' in data) {
+            if (data && 'content' in data && typeof data.content === "string") {
                 return data.content;
             }
             throw new Error("Unsupported file type");
         });
     }
+    /**
+     * Reads the whole tree under `path` in one request and returns the API's `Directory`: every
+     * file below `path` in `files`, each regular file (or symlink to one) with its `content` as
+     * UTF-8 text. The sandbox API applies `patterns`, `excludeDirs` and `excludeHidden`, and rejects,
+     * returning nothing partial, when more than `maxFiles` files match or they hold more than
+     * `maxBytes` bytes.
+     */
+    async readTree(path, options = {}) {
+        const { patterns, excludeDirs, excludeHidden, maxFiles, maxBytes } = options;
+        // Idempotent GET: self-heal a transient connection reset.
+        return (0, transient_retry_js_1.retryOnTransientReset)(async () => {
+            const { response, data, error } = await (0, index_js_1.getFilesystemTreeByPath)(this.withClient({
+                path: { path: this.formatPath(path) },
+                query: {
+                    recursive: true,
+                    content: true,
+                    patterns: patterns?.join(","),
+                    excludeDirs: excludeDirs?.join(","),
+                    excludeHidden,
+                    maxFiles,
+                    maxBytes,
+                },
+                baseUrl: this.url,
+            }));
+            this.handleResponseError(response, data, error);
+            // An older sandbox API ignores the query and lists only direct children,
+            // without `recursive`. Fail instead of returning that as the whole tree.
+            if (data?.recursive !== true) {
+                throw new Error("readTree needs a newer sandbox API: this sandbox does not support recursive tree reads; update its image");
+            }
+            return data;
+        });
+    }
     async readBinary(path) {
         path = this.formatPath(path);
         // Idempotent GET: self-heal a transient connection reset.

package/dist/cjs/sandbox/sandbox.dockerconfig.test.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const sandbox_js_1 = require("./sandbox.js");
+// toSandboxModel is private: reach it the same way the create path does, without a network call.
+const { toSandboxModel } = sandbox_js_1.SandboxInstance;
+const toRuntime = (config) => toSandboxModel(config).model.spec?.runtime;
+(0, vitest_1.describe)("SandboxInstance.create dockerConfig", () => {
+    const auths = { auths: { "ghcr.io": { auth: "dXNlcjp0b2tlbg==" } } };
+    (0, vitest_1.it)("sends an object as a JSON string in spec.runtime.dockerConfig", () => {
+        const runtime = toRuntime({ image: "ghcr.io/org/private:v1", dockerConfig: auths, region: "us-pdx-1" });
+        (0, vitest_1.expect)(runtime.image).toBe("ghcr.io/org/private:v1");
+        (0, vitest_1.expect)(JSON.parse(runtime.dockerConfig)).toEqual(auths);
+    });
+    (0, vitest_1.it)("passes a string through unchanged", () => {
+        const raw = JSON.stringify(auths);
+        (0, vitest_1.expect)(toRuntime({ dockerConfig: raw, region: "us-pdx-1" }).dockerConfig).toBe(raw);
+    });
+    (0, vitest_1.it)("omits it from the request when not set", () => {
+        const body = JSON.parse(JSON.stringify(toRuntime({ image: "ghcr.io/org/private:v1", region: "us-pdx-1" })));
+        (0, vitest_1.expect)(body).not.toHaveProperty("dockerConfig");
+    });
+});

package/dist/cjs/sandbox/sandbox.js

@@ -381,7 +381,8 @@ class SandboxInstance {
             'labels' in sandbox ||
             'extraArgs' in sandbox ||
             'terminationGracePeriodSeconds' in sandbox ||
-            'standbyGracePeriodSeconds' in sandbox) {
+            'standbyGracePeriodSeconds' in sandbox ||
+            'dockerConfig' in sandbox) {
             if (!sandbox)
                 sandbox = {};
             requested = { image: sandbox.image, memory: sandbox.memory, region: sandbox.region, envs: (0, types_js_1.normalizeEnvs)(sandbox.envs) };
@@ -404,6 +405,8 @@ class SandboxInstance {
             const snapshotEnabled = sandbox.snapshotEnabled;
             const extraArgs = sandbox.extraArgs;
             const { terminationGracePeriodSeconds, standbyGracePeriodSeconds } = sandbox;
+            // Not in the generated SandboxRuntime: the API reads it from the raw body, like the CLI sends it.
+            const dockerConfig = typeof sandbox.dockerConfig === "object" ? JSON.stringify(sandbox.dockerConfig) : sandbox.dockerConfig;
             sandbox = {
                 metadata: { name: sandbox.name, labels: sandbox.labels, externalId: sandbox.externalId },
                 spec: {
@@ -418,6 +421,7 @@ class SandboxInstance {
                         extraArgs,
                         terminationGracePeriodSeconds,
                         standbyGracePeriodSeconds,
+                        dockerConfig,
                     },
                     volumes: volumes,
                     lifecycle: lifecycle,

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

@@ -3,7 +3,7 @@
  *
  * Node keeps the event loop alive while a fetch is pending, so this is what a
  * short-lived script waits for before it can exit. A capture against
- * us.i.posthog.com takes ~250-350ms end to end (DNS + TLS handshake + POST), so
+ * events.blaxel.ai takes ~250-350ms end to end (DNS + TLS handshake + POST), so
  * a second covers the happy path with headroom. The ceiling matters because a
  * version is only recorded after a successful delivery: when the endpoint is
  * unreachable every later run tries again, and networks that silently drop

package/dist/cjs/types/sandbox/client/sdk.gen.d.ts

@@ -170,7 +170,11 @@ export declare const putFilesystemByPath: <ThrowOnError extends boolean = false>
 export declare const deleteFilesystemTreeByPath: <ThrowOnError extends boolean = false>(options: Options<DeleteFilesystemTreeByPathData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").SuccessResponse, import("./types.gen").ErrorResponse, ThrowOnError>;
 /**
  * Get directory tree
- * Get a recursive directory tree structure starting from the specified path
+ * List a directory. Without query parameters, `files` and `subdirectories` hold its direct children.
+ *
+ * With `recursive=true`, they hold every file and directory below the path (flat, with full paths). With `content=true`, each regular file (or symlink to one) also carries its `content` as UTF-8 text, like a JSON file read; other entries have no `content`. `patterns`, `excludeDirs` and `excludeHidden` select entries the same way as find, but nothing is excluded by default.
+ *
+ * The response is all or nothing: when more than `maxFiles` files match, or `content=true` and they hold more than `maxBytes` bytes, the request fails with 422 before any content is read.
  */
 export declare const getFilesystemTreeByPath: <ThrowOnError extends boolean = false>(options: Options<GetFilesystemTreeByPathData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").Directory, import("./types.gen").ErrorResponse, ThrowOnError>;
 /**

package/dist/cjs/types/sandbox/client/types.gen.d.ts

@@ -68,6 +68,12 @@ export type Directory = {
     files: Array<File>;
     name: string;
     path: string;
+    /**
+     * Recursive is true when files and subdirectories hold every level below
+     * path (tree read with recursive=true). Older APIs ignore that parameter
+     * and omit this field, so clients can tell a one-level listing apart.
+     */
+    recursive?: boolean;
     /**
      * @name Subdirectories
      */
@@ -233,6 +239,10 @@ export type ExportResult = {
     uploaded?: boolean;
 };
 export type File = {
+    /**
+     * Content is set only by a tree read with content=true, for regular files.
+     */
+    content?: string;
     group: string;
     lastModified: string;
     name: string;
@@ -785,6 +795,10 @@ export type PostDrivesMountErrors = {
      * Internal Server Error
      */
     500: ErrorResponse;
+    /**
+     * Insufficient Storage
+     */
+    507: ErrorResponse;
 };
 export type PostDrivesMountError = PostDrivesMountErrors[keyof PostDrivesMountErrors];
 export type PostDrivesMountResponses = {
@@ -810,6 +824,10 @@ export type DeleteDrivesMountByMountPathErrors = {
      * Bad Request
      */
     400: ErrorResponse;
+    /**
+     * Not Found
+     */
+    404: ErrorResponse;
     /**
      * Internal Server Error
      */
@@ -1385,7 +1403,36 @@ export type GetFilesystemTreeByPathData = {
          */
         path: string;
     };
-    query?: never;
+    query?: {
+        /**
+         * List every file and directory below the path, not only its direct children (default: false)
+         */
+        recursive?: boolean;
+        /**
+         * Include the content of each regular file, as UTF-8 text (default: false)
+         */
+        content?: boolean;
+        /**
+         * Comma-separated glob patterns matched against file names (e.g., *.json,*.md). Directories are not filtered.
+         */
+        patterns?: string;
+        /**
+         * Comma-separated directory names to skip with everything below them (default: none)
+         */
+        excludeDirs?: string;
+        /**
+         * Skip files and directories whose name starts with a dot (default: false)
+         */
+        excludeHidden?: boolean;
+        /**
+         * Fail with 422 when more files match (default: 10000 with recursive or content, otherwise unlimited; at most 100000)
+         */
+        maxFiles?: number;
+        /**
+         * With content=true, fail with 422 when the matching files hold more bytes (default: 33554432, 32 MiB; at most 268435456, 256 MiB)
+         */
+        maxBytes?: number;
+    };
     url: '/filesystem/tree/{path}';
 };
 export type GetFilesystemTreeByPathErrors = {
@@ -1394,7 +1441,7 @@ export type GetFilesystemTreeByPathErrors = {
      */
     400: ErrorResponse;
     /**
-     * Unprocessable entity
+     * Unprocessable entity, including a maxFiles or maxBytes limit
      */
     422: ErrorResponse;
     /**

package/dist/cjs/types/sandbox/filesystem/filesystem.d.ts

@@ -4,6 +4,7 @@ import { SandboxAction } from "../action.js";
 import { ContentSearchResponse, Directory, FindResponse, FuzzySearchResponse, SuccessResponse } from "../client/index.js";
 import { SandboxProcess } from "../process/index.js";
 import { CopyResponse, FilesystemFindOptions, FilesystemGrepOptions, FilesystemSearchOptions, SandboxFilesystemFile, WatchEvent } from "./types.js";
+import type { FilesystemReadTreeOptions } from "./types.js";
 export declare const isTransientUploadError: typeof isTransientResetError;
 export declare function retryOnTransient<T>(fn: () => Promise<T>): Promise<T>;
 export declare class SandboxFileSystem extends SandboxAction {
@@ -14,6 +15,14 @@ export declare class SandboxFileSystem extends SandboxAction {
     writeBinary(path: string, content: Buffer | Blob | File | Uint8Array | string): Promise<SuccessResponse>;
     writeTree(files: SandboxFilesystemFile[], destinationPath?: string | null): Promise<Directory | undefined>;
     read(path: string): Promise<string>;
+    /**
+     * Reads the whole tree under `path` in one request and returns the API's `Directory`: every
+     * file below `path` in `files`, each regular file (or symlink to one) with its `content` as
+     * UTF-8 text. The sandbox API applies `patterns`, `excludeDirs` and `excludeHidden`, and rejects,
+     * returning nothing partial, when more than `maxFiles` files match or they hold more than
+     * `maxBytes` bytes.
+     */
+    readTree(path: string, options?: FilesystemReadTreeOptions): Promise<Directory>;
     readBinary(path: string): Promise<Blob>;
     download(src: string, destinationPath: string, { mode }?: {
         mode?: number;

package/dist/cjs/types/sandbox/filesystem/types.d.ts

@@ -26,6 +26,16 @@ export interface FilesystemFindOptions {
     excludeDirs?: string[];
     excludeHidden?: boolean;
 }
+export type FilesystemReadTreeOptions = Pick<FilesystemFindOptions, "patterns"> & {
+    /** Directory names to skip, with everything below them. Default: none. */
+    excludeDirs?: string[];
+    /** Skip files and directories whose name starts with a dot. Default: false. */
+    excludeHidden?: boolean;
+    /** Reject instead of truncating when more files match. Default 10000, at most 100000. */
+    maxFiles?: number;
+    /** Reject when the matching files hold more bytes. Default 32 MiB, at most 256 MiB. */
+    maxBytes?: number;
+};
 export interface FilesystemGrepOptions {
     caseSensitive?: boolean;
     contextLines?: number;

package/dist/cjs/types/sandbox/sandbox.dockerconfig.test.d.ts

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

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

@@ -81,6 +81,12 @@ export type SandboxCreateConfiguration = {
     terminationGracePeriodSeconds?: number;
     /** Seconds the sandbox gets after SIGUSR2 to prepare before standby. Defaults to 0. */
     standbyGracePeriodSeconds?: number;
+    /**
+     * Registry credentials to pull a private registry image (e.g. ghcr.io/org/image:tag),
+     * in Docker config.json format: { auths: { "ghcr.io": { auth: base64("user:token") } } }.
+     * Only used when image is a registry reference.
+     */
+    dockerConfig?: string | Record<string, unknown>;
 };
 export declare function normalizePorts(ports?: (Port | Record<string, any>)[]): Port[] | undefined;
 export declare function normalizeEnvs(envs?: EnvVar[]): EnvVar[] | undefined;