@blaxel/core 0.2.57-preview.30 → 0.2.57-preview.33

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

@@ -9,8 +9,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.57-preview.30";
-const BUILD_COMMIT = "56d2203f7145b774778210b79f0641b8e3a5e175";
+const BUILD_VERSION = "0.2.57-preview.33";
+const BUILD_COMMIT = "c169eb11d41a069351c8203a2aad841f8cdef220";
 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/client/sdk.gen.js

@@ -525,7 +525,7 @@ const getProcess = (options) => {
 exports.getProcess = getProcess;
 /**
  * Execute a command
- * Execute a command and return process information
+ * Execute a command and return process information. If Accept header is text/event-stream, streams logs in SSE format and returns the process response as a final event.
  */
 const postProcess = (options) => {
     return (options.client ?? client_gen_1.client).post({

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

@@ -77,41 +77,36 @@ class SandboxProcess extends action_js_1.SandboxAction {
     }
     async exec(process) {
         let onLog;
+        let onStdout;
+        let onStderr;
         if ('onLog' in process && process.onLog) {
             onLog = process.onLog;
             delete process.onLog;
         }
+        if ('onStdout' in process && process.onStdout) {
+            onStdout = process.onStdout;
+            delete process.onStdout;
+        }
+        if ('onStderr' in process && process.onStderr) {
+            onStderr = process.onStderr;
+            delete process.onStderr;
+        }
         // Store original wait_for_completion setting
         const shouldWaitForCompletion = process.waitForCompletion;
-        // Always start process without wait_for_completion to avoid server-side blocking
-        if (shouldWaitForCompletion && onLog) {
-            process.waitForCompletion = false;
-        }
-        const { response, data, error } = await (0, index_js_1.postProcess)({
-            body: process,
-            baseUrl: this.url,
-            client: this.client,
-        });
-        this.handleResponseError(response, data, error);
-        let result = data;
-        // Handle wait_for_completion with parallel log streaming
-        if (shouldWaitForCompletion && onLog) {
-            const streamControl = this.streamLogs(result.pid, { onLog });
-            try {
-                // Wait for process completion
-                result = await this.wait(result.pid, { interval: 500, maxWait: 1000 * 60 * 60 });
-            }
-            finally {
-                // Clean up log streaming
-                if (streamControl) {
-                    streamControl.close();
-                }
-            }
+        // When waiting for completion with streaming callbacks, use streaming endpoint
+        if (shouldWaitForCompletion && (onLog || onStdout || onStderr)) {
+            return await this.execWithStreaming(process, { onLog, onStdout, onStderr });
         }
         else {
-            // For non-blocking execution, set up log streaming immediately if requested
-            if (onLog) {
-                const streamControl = this.streamLogs(result.pid, { onLog });
+            const { response, data, error } = await (0, index_js_1.postProcess)({
+                body: process,
+                baseUrl: this.url,
+                client: this.client,
+            });
+            this.handleResponseError(response, data, error);
+            const result = data;
+            if (onLog || onStdout || onStderr) {
+                const streamControl = this.streamLogs(result.pid, { onLog, onStdout, onStderr });
                 return {
                     ...result,
                     close() {
@@ -121,8 +116,123 @@ class SandboxProcess extends action_js_1.SandboxAction {
                     },
                 };
             }
+            return result;
+        }
+    }
+    async execWithStreaming(processRequest, options) {
+        const headers = this.sandbox.forceUrl ? this.sandbox.headers : settings_js_1.settings.headers;
+        const controller = new AbortController();
+        const response = await fetch(`${this.url}/process`, {
+            method: 'POST',
+            signal: controller.signal,
+            headers: {
+                ...headers,
+                'Content-Type': 'application/json',
+                'Accept': 'text/event-stream',
+            },
+            body: JSON.stringify(processRequest),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to execute process: ${errorText}`);
         }
-        return { ...result, close: () => { } };
+        const contentType = response.headers.get('Content-Type') || '';
+        const isStreaming = contentType.includes('application/x-ndjson');
+        // Fallback: server doesn't support streaming, use legacy approach
+        if (!isStreaming) {
+            const data = await response.json();
+            // If process already completed (server waited), just return with logs
+            if (data.status === 'completed' || data.status === 'failed') {
+                // Emit any captured logs through callbacks
+                if (data.stdout) {
+                    for (const line of data.stdout.split('\n').filter(l => l)) {
+                        options.onStdout?.(line);
+                    }
+                }
+                if (data.stderr) {
+                    for (const line of data.stderr.split('\n').filter(l => l)) {
+                        options.onStderr?.(line);
+                    }
+                }
+                if (data.logs) {
+                    for (const line of data.logs.split('\n').filter(l => l)) {
+                        options.onLog?.(line);
+                    }
+                }
+                return {
+                    ...data,
+                    close: () => { },
+                };
+            }
+            return {
+                ...data,
+                close: () => { },
+            };
+        }
+        // Streaming response handling
+        if (!response.body) {
+            throw new Error('No response body for streaming');
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let result = null;
+        while (true) {
+            const readResult = await reader.read();
+            if (readResult.done)
+                break;
+            if (readResult.value && readResult.value instanceof Uint8Array) {
+                buffer += decoder.decode(readResult.value, { stream: true });
+            }
+            const lines = buffer.split(/\r?\n/);
+            buffer = lines.pop();
+            for (const line of lines) {
+                const parsed = JSON.parse(line);
+                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;
+                    default:
+                        break;
+                }
+            }
+        }
+        // Process any remaining buffer
+        if (buffer.trim()) {
+            if (buffer.startsWith('result:')) {
+                const jsonStr = buffer.slice(7);
+                try {
+                    result = JSON.parse(jsonStr);
+                }
+                catch {
+                    throw new Error(`Failed to parse result JSON: ${jsonStr}`);
+                }
+            }
+        }
+        if (!result) {
+            throw new Error('No result received from streaming response');
+        }
+        return {
+            ...result,
+            close: () => controller.abort(),
+        };
     }
     async wait(identifier, { maxWait = 60000, interval = 1000 } = {}) {
         const startTime = Date.now();

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

@@ -187,7 +187,7 @@ export declare const getNetworkProcessByPidPorts: <ThrowOnError extends boolean
 export declare const getProcess: <ThrowOnError extends boolean = false>(options?: Options<GetProcessData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").ProcessResponse[], unknown, ThrowOnError>;
 /**
  * Execute a command
- * Execute a command and return process information
+ * Execute a command and return process information. If Accept header is text/event-stream, streams logs in SSE format and returns the process response as a final event.
  */
 export declare const postProcess: <ThrowOnError extends boolean = false>(options: Options<PostProcessData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").ProcessResponse, import("./types.gen").ErrorResponse, ThrowOnError>;
 /**

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

@@ -143,6 +143,8 @@ export type ProcessResponse = {
     restartOnFailure?: boolean;
     startedAt: string;
     status: 'failed' | 'killed' | 'stopped' | 'running' | 'completed';
+    stderr: string;
+    stdout: string;
     workingDir: string;
 };
 export type RankedFile = {

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

@@ -13,6 +13,7 @@ export declare class SandboxProcess extends SandboxAction {
         close: () => void;
     };
     exec(process: ProcessRequest | ProcessRequestWithLog): Promise<PostProcessResponse | ProcessResponseWithLog>;
+    private execWithStreaming;
     wait(identifier: string, { maxWait, interval }?: {
         maxWait?: number;
         interval?: number;

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

@@ -47,6 +47,8 @@ export declare function normalizeEnvs(envs?: EnvVar[]): EnvVar[] | undefined;
 export declare function normalizeVolumes(volumes?: (VolumeBinding | VolumeAttachment)[]): VolumeAttachment[] | undefined;
 export type ProcessRequestWithLog = ProcessRequest & {
     onLog?: (log: string) => void;
+    onStdout?: (stdout: string) => void;
+    onStderr?: (stderr: string) => void;
 };
 export type ProcessResponseWithLog = PostProcessResponse & {
     close: () => void;