@blaxel/core 0.2.79-preview.129 → 0.2.79-preview.131

package/dist/esm/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.129";
-const BUILD_COMMIT = "b5c0690845895384dfbbc09cb3dcce82465d49c2";
+const BUILD_VERSION = "0.2.79-preview.131";
+const BUILD_COMMIT = "25ceae0c8e47c11fd966d9c692661180900bfd99";
 const BUILD_SENTRY_DSN = "https://fd5e60e1c9820e1eef5ccebb84a07127@o4508714045276160.ingest.us.sentry.io/4510465864564736";
 // Cache for config.yaml tracking value
 let configTrackingValue = null;

package/dist/esm/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;
                 }
             }
         }