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

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

@@ -0,0 +1,102 @@
+import { SandboxAction } from "../action.js";
+import { SandboxFileSystem } from "./filesystem.js";
+export class SandboxFileSystemWebSocket extends SandboxAction {
+    process;
+    wsClient;
+    httpClient;
+    constructor(sandbox, process, wsClient) {
+        super(sandbox);
+        this.process = process;
+        this.wsClient = wsClient;
+        // Create HTTP client for fallback operations
+        this.httpClient = new SandboxFileSystem(sandbox, process);
+    }
+    async mkdir(path, permissions = "0755") {
+        path = this.formatPath(path);
+        const data = await this.wsClient.send("filesystem:create", {
+            path,
+            isDirectory: true,
+            permissions,
+        });
+        return data;
+    }
+    async write(path, content) {
+        path = this.formatPath(path);
+        const data = await this.wsClient.send("filesystem:create", {
+            path,
+            content,
+            isDirectory: false,
+        });
+        return data;
+    }
+    async writeBinary(path, content) {
+        return this.httpClient.writeBinary(path, content);
+    }
+    async writeTree(files, destinationPath = null) {
+        const path = this.formatPath(destinationPath ?? "");
+        const filesMap = files.reduce((acc, file) => {
+            acc[file.path] = file.content;
+            return acc;
+        }, {});
+        const data = await this.wsClient.send("filesystem:tree:create", {
+            path,
+            files: filesMap,
+        });
+        return data;
+    }
+    async read(path) {
+        path = this.formatPath(path);
+        const data = await this.wsClient.send("filesystem:get", { path });
+        return data.content;
+    }
+    async readBinary(path) {
+        // Binary downloads are better suited for HTTP
+        // Fall back to HTTP client for binary operations
+        return this.httpClient.readBinary(path);
+    }
+    async download(src, destinationPath, options = {}) {
+        // File downloads are better suited for HTTP
+        // Fall back to HTTP client
+        return this.httpClient.download(src, destinationPath, options);
+    }
+    async rm(path, recursive = false) {
+        path = this.formatPath(path);
+        const data = await this.wsClient.send("filesystem:delete", {
+            path,
+            recursive,
+        });
+        return data;
+    }
+    async ls(path) {
+        path = this.formatPath(path);
+        const data = await this.wsClient.send("filesystem:get", { path });
+        return data;
+    }
+    async cp(source, destination, { maxWait = 180000 } = {}) {
+        // Copy operation is typically done via process execution
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        let process = await this.process.exec({
+            command: `cp -r ${source} ${destination}`,
+        });
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument
+        process = await this.process.wait(process.pid, { maxWait, interval: 100 });
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        if (process.status === "failed") {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            throw new Error(`Could not copy ${source} to ${destination} cause: ${process.logs}`);
+        }
+        return {
+            message: "Files copied",
+            source,
+            destination,
+        };
+    }
+    watch(path, callback, options) {
+        // File watching uses HTTP streaming which is already optimized
+        // Fall back to HTTP client
+        return this.httpClient.watch(path, callback, options);
+    }
+    formatPath(path) {
+        return path;
+    }
+}

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

@@ -0,0 +1,8 @@
+import { SandboxAction } from "../action.js";
+export class SandboxNetworkWebSocket extends SandboxAction {
+    wsClient;
+    constructor(sandbox, wsClient) {
+        super(sandbox);
+        this.wsClient = wsClient;
+    }
+}

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

@@ -0,0 +1,135 @@
+import { SandboxAction } from "../action.js";
+import { SandboxProcess } from "./process.js";
+export class SandboxProcessWebSocket extends SandboxAction {
+    wsClient;
+    httpClient;
+    constructor(sandbox, wsClient) {
+        super(sandbox);
+        this.wsClient = wsClient;
+        // Create HTTP client for fallback operations
+        this.httpClient = new SandboxProcess(sandbox);
+    }
+    streamLogs(identifier, options) {
+        const streamId = this.wsClient.sendStream("process:logs:stream:start", { identifier }, (data) => {
+            // Handle streaming log data
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            if (data && data.log) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                const log = String(data.log);
+                // Parse log format: "stdout:" or "stderr:" prefix
+                if (log.startsWith('stdout:')) {
+                    const stdout = log.slice(7);
+                    options.onStdout?.(stdout);
+                    options.onLog?.(stdout);
+                }
+                else if (log.startsWith('stderr:')) {
+                    const stderr = log.slice(7);
+                    options.onStderr?.(stderr);
+                    options.onLog?.(stderr);
+                }
+                else {
+                    options.onLog?.(log);
+                }
+            }
+        }, () => {
+            // Stream ended
+        });
+        return {
+            close: () => this.wsClient.cancelStream(streamId),
+        };
+    }
+    async exec(process) {
+        let onLog;
+        if ('onLog' in process && process.onLog) {
+            onLog = process.onLog;
+            delete process.onLog;
+        }
+        // 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 data = await this.wsClient.send("process:execute", process);
+        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();
+                }
+            }
+        }
+        else {
+            // For non-blocking execution, set up log streaming immediately if requested
+            if (onLog) {
+                const streamControl = this.streamLogs(result.pid, { onLog });
+                return {
+                    ...result,
+                    close() {
+                        if (streamControl) {
+                            streamControl.close();
+                        }
+                    },
+                };
+            }
+        }
+        return { ...result, close: () => { } };
+    }
+    async wait(identifier, { maxWait = 60000, interval = 1000 } = {}) {
+        const startTime = Date.now();
+        let status = "running";
+        let data = await this.get(identifier);
+        while (status === "running") {
+            await new Promise((resolve) => setTimeout(resolve, interval));
+            try {
+                data = await this.get(identifier);
+                status = data.status ?? "running";
+            }
+            catch {
+                break;
+            }
+            if (Date.now() - startTime > maxWait) {
+                throw new Error("Process did not finish in time");
+            }
+        }
+        return data;
+    }
+    async get(identifier) {
+        const data = await this.wsClient.send("process:get", { identifier });
+        return data;
+    }
+    async list() {
+        const data = await this.wsClient.send("process:list", {});
+        return data;
+    }
+    async stop(identifier) {
+        const data = await this.wsClient.send("process:stop", { identifier });
+        return data;
+    }
+    async kill(identifier) {
+        const data = await this.wsClient.send("process:kill", { identifier });
+        return data;
+    }
+    async logs(identifier, type = "all") {
+        const data = await this.wsClient.send("process:logs", {
+            identifier,
+        });
+        if (type === "all") {
+            return data.logs || "";
+        }
+        else if (type === "stdout") {
+            return data.stdout || "";
+        }
+        else if (type === "stderr") {
+            return data.stderr || "";
+        }
+        throw new Error("Unsupported log type");
+    }
+}

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

@@ -2,11 +2,16 @@ import { v4 as uuidv4 } from "uuid";
 import { createSandbox, deleteSandbox, getSandbox, listSandboxes, updateSandbox } from "../client/index.js";
 import { logger } from "../common/logger.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 { WebSocketClient } from "./websocket/index.js";
 import { normalizeEnvs, normalizePorts, normalizeVolumes } from "./types.js";
 export class SandboxInstance {
     sandbox;
@@ -16,14 +21,32 @@ export class SandboxInstance {
     previews;
     sessions;
     codegen;
+    wsClient;
     constructor(sandbox) {
         this.sandbox = sandbox;
-        this.process = new SandboxProcess(sandbox);
-        this.fs = new SandboxFileSystem(sandbox, this.process);
-        this.network = new SandboxNetwork(sandbox);
+        // If connection type is websocket, initialize WebSocket client and use WebSocket transport layers
+        if (sandbox.connectionType === "websocket") {
+            const url = sandbox.forceUrl || sandbox.metadata?.url || "";
+            this.wsClient = new WebSocketClient({
+                url,
+                headers: sandbox.headers,
+            });
+            // Initialize WebSocket-based action handlers
+            this.process = new SandboxProcessWebSocket(sandbox, this.wsClient);
+            this.fs = new SandboxFileSystemWebSocket(sandbox, this.process, this.wsClient);
+            this.network = new SandboxNetworkWebSocket(sandbox, this.wsClient);
+            this.codegen = new SandboxCodegenWebSocket(sandbox, this.wsClient);
+        }
+        else {
+            // Default to HTTP-based action handlers
+            this.process = new SandboxProcess(sandbox);
+            this.fs = new SandboxFileSystem(sandbox, this.process);
+            this.network = new SandboxNetwork(sandbox);
+            this.codegen = new SandboxCodegen(sandbox);
+        }
+        // These are always HTTP-based
         this.previews = new SandboxPreviews(sandbox);
         this.sessions = new SandboxSessions(sandbox);
-        this.codegen = new SandboxCodegen(sandbox);
     }
     get metadata() {
         return this.sandbox.metadata;
@@ -42,10 +65,17 @@ export class SandboxInstance {
         logger.warn("⚠️  Warning: sandbox.wait() is deprecated. You don't need to wait for the sandbox to be deployed anymore.");
         return this;
     }
+    closeConnection() {
+        if (this.wsClient) {
+            this.wsClient.close();
+        }
+    }
     static async create(sandbox, { safe = true } = {}) {
         const defaultName = `sandbox-${uuidv4().replace(/-/g, '').substring(0, 8)}`;
         const defaultImage = `blaxel/base-image:latest`;
         const defaultMemory = 4096;
+        // Store connection type if provided
+        let connectionType;
         // Handle SandboxCreateConfiguration or simple dict with name/image/memory/ports/envs/volumes keys
         if (!sandbox ||
             'name' in sandbox ||
@@ -55,7 +85,8 @@ export class SandboxInstance {
             'envs' in sandbox ||
             'volumes' in sandbox ||
             'lifecycle' in sandbox ||
-            'snapshotEnabled' in sandbox) {
+            'snapshotEnabled' in sandbox ||
+            'connectionType' in sandbox) {
             if (!sandbox)
                 sandbox = {};
             if (!sandbox.name)
@@ -64,6 +95,7 @@ export class SandboxInstance {
                 sandbox.image = defaultImage;
             if (!sandbox.memory)
                 sandbox.memory = defaultMemory;
+            connectionType = sandbox.connectionType;
             const ports = normalizePorts(sandbox.ports);
             const envs = normalizeEnvs(sandbox.envs);
             const volumes = normalizeVolumes(sandbox.volumes);
@@ -112,7 +144,16 @@ export class SandboxInstance {
             body: sandbox,
             throwOnError: true,
         });
-        const instance = new SandboxInstance(data);
+        // Add connection type to configuration
+        const config = {
+            ...data,
+            connectionType: connectionType || "http",
+        };
+        const instance = new SandboxInstance(config);
+        // Connect WebSocket if needed
+        if (connectionType === "websocket" && instance.wsClient) {
+            await instance.wsClient.connect();
+        }
         // TODO remove this part once we have a better way to handle this
         if (safe) {
             try {
@@ -122,20 +163,34 @@ export class SandboxInstance {
         }
         return instance;
     }
-    static async get(sandboxName) {
+    static async get(sandboxName, connectionType) {
         const { data } = await getSandbox({
             path: {
                 sandboxName,
             },
             throwOnError: true,
         });
-        return new SandboxInstance(data);
+        // Add connection type to configuration
+        const config = {
+            ...data,
+            connectionType: connectionType || "http",
+        };
+        const instance = new SandboxInstance(config);
+        // Connect WebSocket if needed
+        if (connectionType === "websocket" && instance.wsClient) {
+            await instance.wsClient.connect();
+        }
+        return instance;
     }
     static async list() {
         const { data } = await listSandboxes({ throwOnError: true });
         return data.map((sandbox) => new SandboxInstance(sandbox));
     }
-    static async delete(sandboxName) {
+    static async delete(sandboxName, instance) {
+        // Close WebSocket connection if instance is provided
+        if (instance && instance.wsClient) {
+            instance.closeConnection();
+        }
         const { data } = await deleteSandbox({
             path: {
                 sandboxName,
@@ -165,8 +220,10 @@ export class SandboxInstance {
                 if (!name) {
                     throw new Error("Sandbox name is required");
                 }
+                // Get connection type if specified
+                const connectionType = 'connectionType' in sandbox ? sandbox.connectionType : undefined;
                 // Get the existing sandbox to check its status
-                const sandboxInstance = await SandboxInstance.get(name);
+                const sandboxInstance = await SandboxInstance.get(name, connectionType);
                 // If the sandbox is TERMINATED, treat it as not existing
                 if (sandboxInstance.status === "TERMINATED") {
                     // Create a new sandbox - backend will handle cleanup of the terminated one

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

@@ -0,0 +1,271 @@
+import { v4 as uuidv4 } from "uuid";
+import { getWebSocket } from "../../common/node.js";
+export 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 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 = uuidv4();
+            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 = uuidv4();
+        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;
+    }
+}

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

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