@blaxel/core 0.2.49-dev.211 → 0.2.49-dev.212

package/dist/cjs-browser/sandbox/websocket/client.js

@@ -0,0 +1,275 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketClient = void 0;
+const uuid_1 = require("uuid");
+const node_js_1 = require("../../common/node.js");
+class WebSocketClient {
+    ws = null;
+    WebSocketClass = null;
+    url;
+    headers;
+    reconnect;
+    reconnectInterval;
+    maxReconnectAttempts;
+    reconnectAttempts = 0;
+    pendingRequests = new Map();
+    streamHandlers = new Map();
+    isClosing = false;
+    connectionPromise = null;
+    heartbeatInterval = null;
+    reconnectTimeout = null;
+    lastPongReceived = Date.now();
+    constructor(options) {
+        this.url = options.url;
+        this.headers = options.headers || {};
+        this.reconnect = options.reconnect ?? true;
+        this.reconnectInterval = options.reconnectInterval ?? 5000;
+        this.maxReconnectAttempts = options.maxReconnectAttempts ?? 5;
+    }
+    async connect() {
+        if (this.connectionPromise) {
+            return this.connectionPromise;
+        }
+        this.connectionPromise = this.initializeConnection();
+        return this.connectionPromise;
+    }
+    async initializeConnection() {
+        return new Promise((resolve, reject) => {
+            // Get WebSocket class and connect
+            void (async () => {
+                try {
+                    // Get WebSocket class if not already loaded
+                    if (!this.WebSocketClass) {
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                        this.WebSocketClass = await (0, node_js_1.getWebSocket)();
+                    }
+                    // Convert http/https URL to ws/wss
+                    let wsUrl = this.url;
+                    if (wsUrl.startsWith("http://")) {
+                        wsUrl = wsUrl.replace("http://", "ws://");
+                    }
+                    else if (wsUrl.startsWith("https://")) {
+                        wsUrl = wsUrl.replace("https://", "wss://");
+                    }
+                    // Add /ws endpoint if not present
+                    if (!wsUrl.endsWith("/ws")) {
+                        wsUrl = `${wsUrl}/ws`;
+                    }
+                    // Create WebSocket with headers (if supported by the environment)
+                    const wsOptions = {};
+                    if (Object.keys(this.headers).length > 0) {
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                        wsOptions.headers = this.headers;
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call
+                    this.ws = new this.WebSocketClass(wsUrl, wsOptions);
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                    this.ws.onopen = () => {
+                        this.reconnectAttempts = 0;
+                        this.startHeartbeat();
+                        resolve();
+                    };
+                    this.ws.onmessage = (event) => {
+                        this.handleMessage(event);
+                    };
+                    this.ws.onerror = (error) => {
+                        console.error("WebSocket error:", error);
+                        reject(new Error("WebSocket connection error"));
+                    };
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                    this.ws.onclose = () => {
+                        this.stopHeartbeat();
+                        this.connectionPromise = null;
+                        if (!this.isClosing && this.reconnect && this.reconnectAttempts < this.maxReconnectAttempts) {
+                            this.reconnectAttempts++;
+                            this.reconnectTimeout = setTimeout(() => {
+                                this.connect().catch(console.error);
+                            }, this.reconnectInterval);
+                            // Allow process to exit even if reconnect timeout is pending
+                            if (this.reconnectTimeout.unref) {
+                                this.reconnectTimeout.unref();
+                            }
+                        }
+                        else {
+                            // Reject all pending requests
+                            this.pendingRequests.forEach(({ reject }) => {
+                                reject(new Error("WebSocket connection closed"));
+                            });
+                            this.pendingRequests.clear();
+                        }
+                    };
+                    // Handle pong messages for heartbeat
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                    if (typeof this.ws.on === 'function') {
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+                        this.ws.on('pong', () => {
+                            this.lastPongReceived = Date.now();
+                        });
+                    }
+                }
+                catch (error) {
+                    reject(error instanceof Error ? error : new Error(String(error)));
+                }
+            })();
+        });
+    }
+    startHeartbeat() {
+        // Send ping every 30 seconds
+        this.heartbeatInterval = setInterval(() => {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            if (this.ws && this.WebSocketClass && this.ws.readyState === this.WebSocketClass.OPEN) {
+                // Check if we received a pong recently (within 60 seconds)
+                if (Date.now() - this.lastPongReceived > 60000) {
+                    console.warn("WebSocket heartbeat timeout, closing connection");
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+                    this.ws.close();
+                    return;
+                }
+                // Send ping
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                if (typeof this.ws.ping === 'function') {
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+                    this.ws.ping();
+                }
+            }
+        }, 30000);
+        // Allow process to exit even if heartbeat interval is active
+        if (this.heartbeatInterval.unref) {
+            this.heartbeatInterval.unref();
+        }
+    }
+    stopHeartbeat() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+    }
+    handleMessage(event) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+            const response = JSON.parse(String(event.data));
+            // Check if this is a streaming response
+            if (response.stream) {
+                const streamHandler = this.streamHandlers.get(response.id);
+                if (streamHandler) {
+                    // Call the data handler with the response data
+                    streamHandler.onData(response.data);
+                    // If stream is done, call end handler and clean up
+                    if (response.done) {
+                        streamHandler.onEnd();
+                        this.streamHandlers.delete(response.id);
+                    }
+                }
+                return;
+            }
+            // Regular request-response handling
+            const pending = this.pendingRequests.get(response.id);
+            if (pending) {
+                this.pendingRequests.delete(response.id);
+                if (response.success) {
+                    pending.resolve(response.data);
+                }
+                else {
+                    pending.reject(new Error(response.error || "Unknown error"));
+                }
+            }
+        }
+        catch (error) {
+            console.error("Failed to parse WebSocket message:", error);
+        }
+    }
+    async send(operation, data = {}) {
+        // Ensure we're connected
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        if (!this.ws || !this.WebSocketClass || this.ws.readyState !== this.WebSocketClass.OPEN) {
+            await this.connect();
+        }
+        return new Promise((resolve, reject) => {
+            const id = (0, uuid_1.v4)();
+            const message = {
+                id,
+                operation,
+                data,
+            };
+            // Store the promise handlers
+            this.pendingRequests.set(id, { resolve, reject });
+            // Set a timeout for the request (60 seconds)
+            setTimeout(() => {
+                if (this.pendingRequests.has(id)) {
+                    this.pendingRequests.delete(id);
+                    reject(new Error("Request timeout"));
+                }
+            }, 60000);
+            // Send the message
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            if (this.ws && this.WebSocketClass && this.ws.readyState === this.WebSocketClass.OPEN) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+                this.ws.send(JSON.stringify(message));
+            }
+            else {
+                this.pendingRequests.delete(id);
+                reject(new Error("WebSocket not connected"));
+            }
+        });
+    }
+    sendStream(operation, data, onData, onEnd) {
+        // Ensure we're connected
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        if (!this.ws || !this.WebSocketClass || this.ws.readyState !== this.WebSocketClass.OPEN) {
+            throw new Error("WebSocket not connected");
+        }
+        const id = (0, uuid_1.v4)();
+        const message = {
+            id,
+            operation,
+            data,
+        };
+        // Store the stream handlers
+        this.streamHandlers.set(id, { onData, onEnd });
+        // Send the message
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        this.ws.send(JSON.stringify(message));
+        return id;
+    }
+    cancelStream(id) {
+        this.streamHandlers.delete(id);
+    }
+    close() {
+        this.isClosing = true;
+        this.reconnect = false;
+        this.stopHeartbeat();
+        // Clear reconnect timeout if any
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = null;
+        }
+        if (this.ws) {
+            // In Node.js (ws package), use terminate() to forcefully close the connection
+            // This immediately closes the socket without waiting for the close handshake
+            // In browser, terminate() doesn't exist, so we fall back to close()
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            if (typeof this.ws.terminate === 'function') {
+                // Node.js ws package - force immediate close
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+                this.ws.terminate();
+            }
+            else {
+                // Browser WebSocket - graceful close
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+                this.ws.close();
+            }
+            this.ws = null;
+        }
+        // Reject all pending requests
+        this.pendingRequests.forEach(({ reject }) => {
+            reject(new Error("WebSocket client closed"));
+        });
+        this.pendingRequests.clear();
+        this.connectionPromise = null;
+    }
+    get isConnected() {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        return this.ws !== null && this.WebSocketClass !== null && this.ws.readyState === this.WebSocketClass.OPEN;
+    }
+}
+exports.WebSocketClient = WebSocketClient;

package/dist/cjs-browser/sandbox/websocket/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client.js"), exports);

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

@@ -0,0 +1,10 @@
+import { Sandbox } from "../../client/types.gen.js";
+import { SandboxAction } from "../action.js";
+import { WebSocketClient } from "../websocket/index.js";
+import { ApplyEditResponse, RerankingResponse } from "../client/types.gen.js";
+export declare class SandboxCodegenWebSocket extends SandboxAction {
+    private wsClient;
+    constructor(sandbox: Sandbox, wsClient: WebSocketClient);
+    fastapply(path: string, codeEdit: string, model?: string): Promise<ApplyEditResponse>;
+    reranking(path: string, query: string, scoreThreshold?: number, tokenLimit?: number, filePattern?: string): Promise<RerankingResponse>;
+}

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

@@ -0,0 +1,35 @@
+import { SandboxAction } from "../action.js";
+import { WebSocketClient } from "../websocket/index.js";
+import { Directory, SuccessResponse } from "../client/index.js";
+import { SandboxProcess } from "../process/index.js";
+import { SandboxProcessWebSocket } from "../process/process-ws.js";
+import { CopyResponse, SandboxFilesystemFile, WatchEvent } from "./types.js";
+import { SandboxConfiguration } from "../types.js";
+export declare class SandboxFileSystemWebSocket extends SandboxAction {
+    private process;
+    private wsClient;
+    private httpClient;
+    constructor(sandbox: SandboxConfiguration, process: SandboxProcess | SandboxProcessWebSocket, wsClient: WebSocketClient);
+    mkdir(path: string, permissions?: string): Promise<SuccessResponse>;
+    write(path: string, content: string): Promise<SuccessResponse>;
+    writeBinary(path: string, content: Buffer | Blob | File | Uint8Array | string): Promise<SuccessResponse>;
+    writeTree(files: SandboxFilesystemFile[], destinationPath?: string | null): Promise<Directory>;
+    read(path: string): Promise<string>;
+    readBinary(path: string): Promise<Blob>;
+    download(src: string, destinationPath: string, options?: {
+        mode?: number;
+    }): Promise<void>;
+    rm(path: string, recursive?: boolean): Promise<SuccessResponse>;
+    ls(path: string): Promise<Directory>;
+    cp(source: string, destination: string, { maxWait }?: {
+        maxWait?: number;
+    }): Promise<CopyResponse>;
+    watch(path: string, callback: (fileEvent: WatchEvent) => void | Promise<void>, options?: {
+        onError?: (error: Error) => void;
+        withContent: boolean;
+        ignore?: string[];
+    }): {
+        close: () => void;
+    };
+    private formatPath;
+}

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

@@ -0,0 +1,7 @@
+import { Sandbox } from "../../client/types.gen.js";
+import { SandboxAction } from "../action.js";
+import { WebSocketClient } from "../websocket/index.js";
+export declare class SandboxNetworkWebSocket extends SandboxAction {
+    private wsClient;
+    constructor(sandbox: Sandbox, wsClient: WebSocketClient);
+}

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

@@ -0,0 +1,27 @@
+import { Sandbox } from "../../client/types.gen.js";
+import { SandboxAction } from "../action.js";
+import { WebSocketClient } from "../websocket/index.js";
+import { ProcessRequest, ProcessResponse, SuccessResponse } from "../client/index.js";
+import { ProcessRequestWithLog, ProcessResponseWithLog } from "../types.js";
+export declare class SandboxProcessWebSocket extends SandboxAction {
+    private wsClient;
+    private httpClient;
+    constructor(sandbox: Sandbox, wsClient: WebSocketClient);
+    streamLogs(identifier: string, options: {
+        onLog?: (log: string) => void;
+        onStdout?: (stdout: string) => void;
+        onStderr?: (stderr: string) => void;
+    }): {
+        close: () => void;
+    };
+    exec(process: ProcessRequest | ProcessRequestWithLog): Promise<ProcessResponse | ProcessResponseWithLog>;
+    wait(identifier: string, { maxWait, interval }?: {
+        maxWait?: number;
+        interval?: number;
+    }): Promise<ProcessResponse>;
+    get(identifier: string): Promise<ProcessResponse>;
+    list(): Promise<ProcessResponse[]>;
+    stop(identifier: string): Promise<SuccessResponse>;
+    kill(identifier: string): Promise<SuccessResponse>;
+    logs(identifier: string, type?: "stdout" | "stderr" | "all"): Promise<string>;
+}

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

@@ -1,19 +1,24 @@
 import { Sandbox as SandboxModel } from "../client/index.js";
 import { SandboxFileSystem } from "./filesystem/index.js";
+import { SandboxFileSystemWebSocket } from "./filesystem/filesystem-ws.js";
 import { SandboxNetwork } from "./network/index.js";
+import { SandboxNetworkWebSocket } from "./network/network-ws.js";
 import { SandboxPreviews } from "./preview.js";
 import { SandboxProcess } from "./process/index.js";
+import { SandboxProcessWebSocket } from "./process/process-ws.js";
 import { SandboxCodegen } from "./codegen/index.js";
+import { SandboxCodegenWebSocket } from "./codegen/codegen-ws.js";
 import { SandboxSessions } from "./session.js";
 import { SandboxConfiguration, SandboxCreateConfiguration, SandboxUpdateMetadata, SessionWithToken } from "./types.js";
 export declare class SandboxInstance {
     private sandbox;
-    fs: SandboxFileSystem;
-    network: SandboxNetwork;
-    process: SandboxProcess;
+    fs: SandboxFileSystem | SandboxFileSystemWebSocket;
+    network: SandboxNetwork | SandboxNetworkWebSocket;
+    process: SandboxProcess | SandboxProcessWebSocket;
     previews: SandboxPreviews;
     sessions: SandboxSessions;
-    codegen: SandboxCodegen;
+    codegen: SandboxCodegen | SandboxCodegenWebSocket;
+    private wsClient?;
     constructor(sandbox: SandboxConfiguration);
     get metadata(): import("../client/types.gen.js").Metadata | undefined;
     get status(): string | undefined;
@@ -23,12 +28,13 @@ export declare class SandboxInstance {
         maxWait?: number;
         interval?: number;
     }): Promise<this>;
+    closeConnection(): void;
     static create(sandbox?: SandboxModel | SandboxCreateConfiguration, { safe }?: {
         safe?: boolean;
     }): Promise<SandboxInstance>;
-    static get(sandboxName: string): Promise<SandboxInstance>;
+    static get(sandboxName: string, connectionType?: "http" | "websocket"): Promise<SandboxInstance>;
     static list(): Promise<SandboxInstance[]>;
-    static delete(sandboxName: string): Promise<SandboxModel>;
+    static delete(sandboxName: string, instance?: SandboxInstance): Promise<SandboxModel>;
     static updateMetadata(sandboxName: string, metadata: SandboxUpdateMetadata): Promise<SandboxInstance>;
     static createIfNotExists(sandbox: SandboxModel | SandboxCreateConfiguration): Promise<SandboxInstance>;
     static fromSession(session: SessionWithToken): Promise<SandboxInstance>;

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

@@ -20,10 +20,12 @@ export interface VolumeBinding {
     mountPath: string;
     readOnly?: boolean;
 }
+export type ConnectionType = "http" | "websocket";
 export type SandboxConfiguration = {
     forceUrl?: string;
     headers?: Record<string, string>;
     params?: Record<string, string>;
+    connectionType?: ConnectionType;
 } & Sandbox;
 export type SandboxUpdateMetadata = {
     labels?: Record<string, string>;
@@ -41,6 +43,7 @@ export type SandboxCreateConfiguration = {
     region?: string;
     lifecycle?: SandboxLifecycle;
     snapshotEnabled?: boolean;
+    connectionType?: ConnectionType;
 };
 export declare function normalizePorts(ports?: (Port | Record<string, any>)[]): Port[] | undefined;
 export declare function normalizeEnvs(envs?: EnvVar[]): EnvVar[] | undefined;

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

@@ -0,0 +1,49 @@
+export interface WebSocketMessage {
+    id: string;
+    operation: string;
+    data: Record<string, any>;
+}
+export interface WebSocketResponse {
+    id: string;
+    success: boolean;
+    data?: any;
+    error?: string;
+    status?: number;
+    stream?: boolean;
+    done?: boolean;
+}
+export interface WebSocketClientOptions {
+    url: string;
+    headers?: Record<string, string>;
+    reconnect?: boolean;
+    reconnectInterval?: number;
+    maxReconnectAttempts?: number;
+}
+export declare class WebSocketClient {
+    private ws;
+    private WebSocketClass;
+    private url;
+    private headers;
+    private reconnect;
+    private reconnectInterval;
+    private maxReconnectAttempts;
+    private reconnectAttempts;
+    private pendingRequests;
+    private streamHandlers;
+    private isClosing;
+    private connectionPromise;
+    private heartbeatInterval;
+    private reconnectTimeout;
+    private lastPongReceived;
+    constructor(options: WebSocketClientOptions);
+    connect(): Promise<void>;
+    private initializeConnection;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private handleMessage;
+    send<T = any>(operation: string, data?: Record<string, any>): Promise<T>;
+    sendStream(operation: string, data: Record<string, any>, onData: (data: any) => void, onEnd: () => void): string;
+    cancelStream(id: string): void;
+    close(): void;
+    get isConnected(): boolean;
+}

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

@@ -0,0 +1 @@
+export * from "./client.js";