@blaxel/core 0.2.50-dev.215 → 0.2.50-preview.115

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

@@ -1,139 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SandboxProcessWebSocket = void 0;
-const action_js_1 = require("../action.js");
-const process_js_1 = require("./process.js");
-class SandboxProcessWebSocket extends action_js_1.SandboxAction {
-    wsClient;
-    httpClient;
-    constructor(sandbox, wsClient) {
-        super(sandbox);
-        this.wsClient = wsClient;
-        // Create HTTP client for fallback operations
-        this.httpClient = new process_js_1.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.processes || [];
-    }
-    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");
-    }
-}
-exports.SandboxProcessWebSocket = SandboxProcessWebSocket;

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

@@ -1,269 +0,0 @@
-"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");
-const settings_js_1 = require("../../common/settings.js");
-class WebSocketClient {
-    ws = null;
-    WebSocketClass = null;
-    url;
-    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.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`;
-                    }
-                    wsUrl = `${wsUrl}?token=${settings_js_1.settings.token}`;
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call
-                    this.ws = new this.WebSocketClass(wsUrl);
-                    // 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

@@ -1,17 +0,0 @@
-"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

@@ -1,10 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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/websocket/client.d.ts

@@ -1,48 +0,0 @@
-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 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

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

package/dist/esm/sandbox/codegen/codegen-ws.js

@@ -1,26 +0,0 @@
-import { SandboxAction } from "../action.js";
-export class SandboxCodegenWebSocket extends SandboxAction {
-    wsClient;
-    constructor(sandbox, wsClient) {
-        super(sandbox);
-        this.wsClient = wsClient;
-    }
-    async fastapply(path, codeEdit, model) {
-        const data = await this.wsClient.send("codegen:fastapply", {
-            path,
-            codeEdit,
-            model,
-        });
-        return data;
-    }
-    async reranking(path, query, scoreThreshold, tokenLimit, filePattern) {
-        const data = await this.wsClient.send("codegen:reranking", {
-            path,
-            query,
-            scoreThreshold,
-            tokenLimit,
-            filePattern,
-        });
-        return data;
-    }
-}