@blaxel/core 0.3.32 → 0.3.34-preview.340

package/dist/esm/common/posthog.js

@@ -2,14 +2,13 @@ import { fs, os, path } from "../common/node.js";
 import { settings } from "./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/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.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/esm/sandbox/client/sdk.gen.js

@@ -440,7 +440,11 @@ export const deleteFilesystemTreeByPath = (options) => {
 };
 /**
  * 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 const getFilesystemTreeByPath = (options) => {
     return (options.client ?? _heyApiClient).get({

package/dist/esm/sandbox/filesystem/filesystem.js

@@ -4,7 +4,7 @@ import { withUploadSlot } from "../../common/h2fetch.js";
 import { isTransientResetError, retryOnTransientReset } from "../../common/transient-retry.js";
 import { shellQuote } from "../../common/shell.js";
 import { SandboxAction } from "../action.js";
-import { deleteFilesystemByPath, deleteFilesystemMultipartByUploadIdAbort, getFilesystemByPath, getFilesystemContentSearchByPath, getFilesystemFindByPath, getFilesystemSearchByPath, getWatchFilesystemByPath, postFilesystemMultipartByUploadIdComplete, postFilesystemMultipartInitiateByPath, putFilesystemByPath, putFilesystemMultipartByUploadIdPart } from "../client/index.js";
+import { deleteFilesystemByPath, deleteFilesystemMultipartByUploadIdAbort, getFilesystemByPath, getFilesystemContentSearchByPath, getFilesystemFindByPath, getFilesystemSearchByPath, getFilesystemTreeByPath, getWatchFilesystemByPath, postFilesystemMultipartByUploadIdComplete, postFilesystemMultipartInitiateByPath, putFilesystemByPath, putFilesystemMultipartByUploadIdPart } from "../client/index.js";
 // Multipart upload constants
 const MULTIPART_THRESHOLD = 5 * 1024 * 1024; // 5MB
 const CHUNK_SIZE = 5 * 1024 * 1024; // 5MB per part
@@ -203,12 +203,45 @@ export class SandboxFileSystem extends 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 retryOnTransientReset(async () => {
+            const { response, data, error } = await 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/esm/sandbox/sandbox.dockerconfig.test.js

@@ -0,0 +1,21 @@
+import { describe, expect, it } from "vitest";
+import { SandboxInstance } from "./sandbox.js";
+// toSandboxModel is private: reach it the same way the create path does, without a network call.
+const { toSandboxModel } = SandboxInstance;
+const toRuntime = (config) => toSandboxModel(config).model.spec?.runtime;
+describe("SandboxInstance.create dockerConfig", () => {
+    const auths = { auths: { "ghcr.io": { auth: "dXNlcjp0b2tlbg==" } } };
+    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" });
+        expect(runtime.image).toBe("ghcr.io/org/private:v1");
+        expect(JSON.parse(runtime.dockerConfig)).toEqual(auths);
+    });
+    it("passes a string through unchanged", () => {
+        const raw = JSON.stringify(auths);
+        expect(toRuntime({ dockerConfig: raw, region: "us-pdx-1" }).dockerConfig).toBe(raw);
+    });
+    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" })));
+        expect(body).not.toHaveProperty("dockerConfig");
+    });
+});

package/dist/esm/sandbox/sandbox.js

@@ -342,7 +342,8 @@ export 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: normalizeEnvs(sandbox.envs) };
@@ -365,6 +366,8 @@ export 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: {
@@ -379,6 +382,7 @@ export class SandboxInstance {
                         extraArgs,
                         terminationGracePeriodSeconds,
                         standbyGracePeriodSeconds,
+                        dockerConfig,
                     },
                     volumes: volumes,
                     lifecycle: lifecycle,