@blaxel/core 0.2.79-preview.130 → 0.2.79-preview.132

package/dist/esm-browser/common/settings.js

@@ -5,8 +5,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.79-preview.130";
-const BUILD_COMMIT = "7f4924b21bd257cad5bdf35bd3a2db8d99876495";
+const BUILD_VERSION = "0.2.79-preview.132";
+const BUILD_COMMIT = "5fb1f8667d2d0bc7b45ca640257677c647eb5e59";
 const BUILD_SENTRY_DSN = "https://fd5e60e1c9820e1eef5ccebb84a07127@o4508714045276160.ingest.us.sentry.io/4510465864564736";
 // Cache for config.yaml tracking value
 let configTrackingValue = null;

package/dist/esm-browser/sandbox/network/network.js

@@ -1,6 +1,38 @@
+import { settings } from "../../common/settings.js";
 import { SandboxAction } from "../action.js";
 export class SandboxNetwork extends SandboxAction {
     constructor(sandbox) {
         super(sandbox);
     }
+    /**
+     * Fetch a resource served on a sandbox port.
+     * The request is proxied through the sandbox's `/port/{port}` endpoint.
+     *
+     * @param port - The port number inside the sandbox
+     * @param path - Optional path appended after the port (default: "/")
+     * @param init - Standard RequestInit options forwarded to fetch
+     */
+    async fetch(port, path = "/", init) {
+        const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+        const url = `${this.url}/port/${port}${normalizedPath}`;
+        const headers = (this.sandbox.forceUrl ? this.sandbox.headers : undefined) ?? settings.headers;
+        const initHeaders = {};
+        if (init?.headers) {
+            const entries = init.headers instanceof Headers
+                ? init.headers.entries()
+                : Array.isArray(init.headers)
+                    ? init.headers.values()
+                    : Object.entries(init.headers).values();
+            for (const [key, value] of entries) {
+                initHeaders[key] = value;
+            }
+        }
+        return this.h2Fetch(url, {
+            ...init,
+            headers: {
+                ...headers,
+                ...initHeaders,
+            },
+        });
+    }
 }

package/dist/esm-browser/sandbox/process/process.js

@@ -15,7 +15,24 @@ export class SandboxProcess extends SandboxAction {
                 console.error("Stream error:", err);
             }
         };
+        const processLine = (line) => {
+            if (line.startsWith("[keepalive]")) {
+                return;
+            }
+            if (line.startsWith('stdout:')) {
+                options.onStdout?.(line.slice(7));
+                options.onLog?.(line.slice(7));
+            }
+            else if (line.startsWith('stderr:')) {
+                options.onStderr?.(line.slice(7));
+                options.onLog?.(line.slice(7));
+            }
+            else {
+                options.onLog?.(line);
+            }
+        };
         const done = (async () => {
+            let buffer = '';
             try {
                 const headers = this.sandbox.forceUrl ? this.sandbox.headers : settings.headers;
                 const stream = await this.h2Fetch(`${this.url}/process/${identifier}/logs/stream`, {
@@ -33,7 +50,6 @@ export class SandboxProcess extends SandboxAction {
                 }
                 const reader = stream.body.getReader();
                 const decoder = new TextDecoder();
-                let buffer = '';
                 while (true) {
                     const result = await reader.read();
                     if (result.done)
@@ -44,25 +60,21 @@ export class SandboxProcess extends SandboxAction {
                     const lines = buffer.split(/\r?\n/);
                     buffer = lines.pop();
                     for (const line of lines) {
-                        if (line.startsWith("[keepalive]")) {
-                            continue;
-                        }
-                        if (line.startsWith('stdout:')) {
-                            options.onStdout?.(line.slice(7));
-                            options.onLog?.(line.slice(7));
-                        }
-                        else if (line.startsWith('stderr:')) {
-                            options.onStderr?.(line.slice(7));
-                            options.onLog?.(line.slice(7));
-                        }
-                        else {
-                            options.onLog?.(line);
-                        }
+                        processLine(line);
                     }
                 }
+                // Flush the TextDecoder and process any remaining buffered data
+                buffer += decoder.decode();
+                if (buffer.trim()) {
+                    processLine(buffer);
+                }
             }
             catch (err) {
                 if (err && typeof err === 'object' && 'name' in err && err.name === 'AbortError') {
+                    // Process remaining buffer before returning on abort
+                    if (buffer.trim()) {
+                        processLine(buffer);
+                    }
                     return;
                 }
                 handleError(err instanceof Error ? err : new Error('Unknown stream error'));
@@ -212,15 +224,51 @@ export class SandboxProcess extends SandboxAction {
                 }
             }
         }
-        // Process any remaining buffer
+        // Flush the TextDecoder and process any remaining buffered data
+        buffer += decoder.decode();
         if (buffer.trim()) {
-            if (buffer.startsWith('result:')) {
-                const jsonStr = buffer.slice(7);
-                try {
-                    result = JSON.parse(jsonStr);
+            let parsed = null;
+            try {
+                parsed = JSON.parse(buffer.trim());
+            }
+            catch (e) {
+                // Not valid JSON — try legacy result: prefix format
+                if (buffer.startsWith('result:')) {
+                    const jsonStr = buffer.slice(7);
+                    try {
+                        result = JSON.parse(jsonStr);
+                    }
+                    catch {
+                        throw new Error(`Failed to parse result JSON: ${jsonStr}`);
+                    }
+                }
+                else {
+                    // Not a legacy result line — surface the original parse error
+                    throw e;
                 }
-                catch {
-                    throw new Error(`Failed to parse result JSON: ${jsonStr}`);
+            }
+            if (parsed) {
+                switch (parsed.type) {
+                    case 'stdout':
+                        if (parsed.data) {
+                            options.onStdout?.(parsed.data);
+                            options.onLog?.(parsed.data);
+                        }
+                        break;
+                    case 'stderr':
+                        if (parsed.data) {
+                            options.onStderr?.(parsed.data);
+                            options.onLog?.(parsed.data);
+                        }
+                        break;
+                    case 'result':
+                        try {
+                            result = JSON.parse(parsed.data);
+                        }
+                        catch {
+                            throw new Error(`Failed to parse result JSON: ${parsed.data}`);
+                        }
+                        break;
                 }
             }
         }

package/dist/esm-browser/sandbox/sandbox.js

@@ -74,6 +74,16 @@ export class SandboxInstance {
     get expiresIn() {
         return this.sandbox.expiresIn;
     }
+    /**
+     * Fetch a resource served on a sandbox port.
+     *
+     * @param port - The port number inside the sandbox
+     * @param path - Optional path appended after the port (default: "/")
+     * @param init - Standard RequestInit options forwarded to fetch
+     */
+    async fetch(port, path = "/", init) {
+        return this.network.fetch(port, path, init);
+    }
     /* eslint-disable */
     async wait({ maxWait = 60000, interval = 1000 } = {}) {
         logger.warn("⚠️  Warning: sandbox.wait() is deprecated. You don't need to wait for the sandbox to be deployed anymore.");

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@blaxel/core",
-	"version": "0.2.79-preview.130",
+	"version": "0.2.79-preview.132",
 	"description": "Blaxel Core SDK for TypeScript",
 	"license": "MIT",
 	"author": "Blaxel, INC (https://blaxel.ai)",