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

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

@@ -11,8 +11,8 @@ const index_js_1 = require("../authentication/index.js");
 const env_js_1 = require("../common/env.js");
 const node_js_1 = require("../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/cjs-browser/sandbox/network/network.js

@@ -1,10 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SandboxNetwork = void 0;
+const settings_js_1 = require("../../common/settings.js");
 const action_js_1 = require("../action.js");
 class SandboxNetwork extends action_js_1.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_js_1.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,
+            },
+        });
+    }
 }
 exports.SandboxNetwork = SandboxNetwork;

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

@@ -18,7 +18,24 @@ class SandboxProcess extends action_js_1.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_js_1.settings.headers;
                 const stream = await this.h2Fetch(`${this.url}/process/${identifier}/logs/stream`, {
@@ -36,7 +53,6 @@ class SandboxProcess extends action_js_1.SandboxAction {
                 }
                 const reader = stream.body.getReader();
                 const decoder = new TextDecoder();
-                let buffer = '';
                 while (true) {
                     const result = await reader.read();
                     if (result.done)
@@ -47,25 +63,21 @@ class SandboxProcess extends action_js_1.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'));
@@ -215,15 +227,51 @@ class SandboxProcess extends action_js_1.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/cjs-browser/sandbox/sandbox.js

@@ -110,6 +110,16 @@ 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_js_1.logger.warn("⚠️  Warning: sandbox.wait() is deprecated. You don't need to wait for the sandbox to be deployed anymore.");

package/dist/cjs-browser/types/sandbox/network/network.d.ts

@@ -2,4 +2,13 @@ import { Sandbox } from "../../client/types.gen.js";
 import { SandboxAction } from "../action.js";
 export declare class SandboxNetwork extends SandboxAction {
     constructor(sandbox: 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
+     */
+    fetch(port: number, path?: string, init?: RequestInit): Promise<Response>;
 }

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

@@ -31,6 +31,14 @@ export declare class SandboxInstance {
      */
     private static attachH2Session;
     get expiresIn(): number | undefined;
+    /**
+     * 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
+     */
+    fetch(port: number, path?: string, init?: RequestInit): Promise<Response>;
     wait({ maxWait, interval }?: {
         maxWait?: number;
         interval?: number;