@blaxel/core 0.2.2-preview2 → 0.2.2

package/dist/common/node.js

@@ -10,11 +10,6 @@ exports.fs = fs;
 let os = null;
 exports.os = os;
 if (isNode) {
-    try {
-        exports.fs = fs = eval("require")("fs");
-        exports.os = os = eval("require")("os");
-    }
-    catch (e) {
-        console.warn("fs and os are not available in this environment");
-    }
+    exports.fs = fs = eval("require")("fs");
+    exports.os = os = eval("require")("os");
 }

package/dist/sandbox/action.d.ts

@@ -16,4 +16,5 @@ export declare class SandboxAction {
     get forcedUrl(): string | null;
     get url(): string;
     handleResponseError(response: Response, data: unknown, error: unknown): void;
+    websocket(path: string): WebSocket | null;
 }

package/dist/sandbox/action.js

@@ -84,5 +84,45 @@ class SandboxAction {
             throw new ResponseError(response, data, error);
         }
     }
+    websocket(path) {
+        let ws = null;
+        // Build ws:// or wss:// URL from baseUrl
+        let baseUrl = this.url.replace(/^http/, 'ws');
+        if (baseUrl.endsWith('/'))
+            baseUrl = baseUrl.slice(0, -1);
+        let params = `token=${settings_js_1.settings.token}`;
+        if (this.sandbox.params) {
+            params = "";
+            for (const [key, value] of Object.entries(this.sandbox.params)) {
+                params += `${key}=${value}&`;
+            }
+            params = params.slice(0, -1);
+        }
+        const wsUrl = `${baseUrl}/ws/${path}?${params}`;
+        // Use isomorphic WebSocket: browser or Node.js
+        let WS = undefined;
+        if (typeof globalThis.WebSocket !== 'undefined') {
+            WS = globalThis.WebSocket;
+        }
+        else {
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                WS = require('ws');
+            }
+            catch {
+                WS = undefined;
+            }
+        }
+        if (!WS)
+            throw new Error('WebSocket is not available in this environment');
+        try {
+            ws = typeof WS === 'function' ? new WS(wsUrl) : new WS(wsUrl);
+        }
+        catch (err) {
+            console.error('WebSocket connection error:', err);
+            throw err;
+        }
+        return ws;
+    }
 }
 exports.SandboxAction = SandboxAction;

package/dist/sandbox/filesystem.d.ts

@@ -14,7 +14,27 @@ export declare class SandboxFileSystem extends SandboxAction {
     rm(path: string, recursive?: boolean): Promise<SuccessResponse>;
     ls(path: string): Promise<Directory>;
     cp(source: string, destination: string): Promise<CopyResponse>;
+    /**
+     * Watch for changes in a directory. Calls the callback with the changed file path (and optionally its content).
+     * Returns a handle with a close() method to stop watching.
+     * @param path Directory to watch
+     * @param callback Function called on each change: (filePath, content?)
+     * @param withContent If true, also fetches and passes the file content (default: false)
+     */
     watch(path: string, callback: (filePath: string, content?: string) => void | Promise<void>, options?: {
+        ws?: boolean;
+        onError?: (error: Error) => void;
+        withContent: boolean;
+    }): {
+        close: () => void;
+    };
+    wsWatch(path: string, callback: (filePath: string, content?: string) => void | Promise<void>, options?: {
+        onError?: (error: Error) => void;
+        withContent: boolean;
+    }): {
+        close: () => void;
+    };
+    sseWatch(path: string, callback: (filePath: string, content?: string) => void | Promise<void>, options?: {
         onError?: (error: Error) => void;
         withContent: boolean;
     }): {

package/dist/sandbox/filesystem.js

@@ -117,7 +117,131 @@ class SandboxFileSystem extends action_js_1.SandboxAction {
         }
         throw new Error("Unsupported file type");
     }
+    /**
+     * Watch for changes in a directory. Calls the callback with the changed file path (and optionally its content).
+     * Returns a handle with a close() method to stop watching.
+     * @param path Directory to watch
+     * @param callback Function called on each change: (filePath, content?)
+     * @param withContent If true, also fetches and passes the file content (default: false)
+     */
     watch(path, callback, options) {
+        if (options?.ws) {
+            return this.wsWatch(path, callback, options);
+        }
+        return this.sseWatch(path, callback, options);
+    }
+    wsWatch(path, callback, options) {
+        path = this.formatPath(path);
+        let closed = false;
+        let ws = this.websocket(`watch/filesystem${path.startsWith('/') ? path : '/' + path}`);
+        let pingInterval = null;
+        let pongTimeout = null;
+        const PING_INTERVAL_MS = 30000;
+        const PONG_TIMEOUT_MS = 10000;
+        function sendPing() {
+            if (ws && ws.readyState === ws.OPEN) {
+                try {
+                    ws.send(JSON.stringify({ type: 'ping' }));
+                }
+                catch { }
+                // Set pong timeout
+                if (pongTimeout)
+                    clearTimeout(pongTimeout);
+                pongTimeout = setTimeout(() => {
+                    // No pong received in time, close connection
+                    if (ws && typeof ws.close === 'function')
+                        ws.close();
+                }, PONG_TIMEOUT_MS);
+            }
+        }
+        if (ws) {
+            ws.onmessage = async (event) => {
+                if (closed)
+                    return;
+                let data;
+                try {
+                    data = typeof event.data === 'string' ? event.data : event.data;
+                    if (!data)
+                        return;
+                    // Accept both JSON and plain string (file path)
+                    let payload;
+                    try {
+                        payload = JSON.parse(data);
+                    }
+                    catch {
+                        payload = { name: data, event: undefined };
+                    }
+                    // Handle ping/pong
+                    if (payload.type === 'ping') {
+                        // Respond to ping with pong
+                        if (ws && ws.readyState === ws.OPEN) {
+                            try {
+                                ws.send(JSON.stringify({ type: 'pong' }));
+                            }
+                            catch { }
+                        }
+                        return;
+                    }
+                    if (payload.type === 'pong') {
+                        // Pong received, clear pong timeout
+                        if (pongTimeout)
+                            clearTimeout(pongTimeout);
+                        pongTimeout = null;
+                        return;
+                    }
+                    const filePath = payload.name || payload.path || data;
+                    if (!filePath)
+                        return;
+                    if (options?.withContent) {
+                        try {
+                            const content = await this.read(filePath);
+                            await callback(filePath, content);
+                        }
+                        catch (e) {
+                            await callback(filePath, undefined);
+                        }
+                    }
+                    else {
+                        await callback(filePath);
+                    }
+                }
+                catch (err) {
+                    if (options?.onError)
+                        options.onError(err);
+                }
+            };
+            ws.onerror = (err) => {
+                if (options?.onError)
+                    options.onError(err instanceof Error ? err : new Error(String(err)));
+                closed = true;
+                if (ws && typeof ws.close === 'function')
+                    ws.close();
+            };
+            ws.onclose = () => {
+                closed = true;
+                ws = null;
+                if (pingInterval)
+                    clearInterval(pingInterval);
+                if (pongTimeout)
+                    clearTimeout(pongTimeout);
+            };
+            // Start ping interval
+            pingInterval = setInterval(sendPing, PING_INTERVAL_MS);
+        }
+        return {
+            close: () => {
+                closed = true;
+                if (ws && typeof ws.close === 'function')
+                    ws.close();
+                ws = null;
+                if (pingInterval)
+                    clearInterval(pingInterval);
+                if (pongTimeout)
+                    clearTimeout(pongTimeout);
+            },
+        };
+    }
+    sseWatch(path, callback, options) {
         path = this.formatPath(path);
         let closed = false;
         let controller = new AbortController();

package/dist/sandbox/process.d.ts

@@ -4,6 +4,21 @@ import { DeleteProcessByIdentifierKillResponse, DeleteProcessByIdentifierRespons
 export declare class SandboxProcess extends SandboxAction {
     constructor(sandbox: Sandbox);
     streamLogs(identifier: string, options: {
+        ws?: boolean;
+        onLog?: (log: string) => void;
+        onStdout?: (stdout: string) => void;
+        onStderr?: (stderr: string) => void;
+    }): {
+        close: () => void;
+    };
+    wsStreamLogs(identifier: string, options: {
+        onLog?: (log: string) => void;
+        onStdout?: (stdout: string) => void;
+        onStderr?: (stderr: string) => void;
+    }): {
+        close: () => void;
+    };
+    sseStreamLogs(identifier: string, options: {
         onLog?: (log: string) => void;
         onStdout?: (stdout: string) => void;
         onStderr?: (stderr: string) => void;

package/dist/sandbox/process.js

@@ -9,6 +9,119 @@ class SandboxProcess extends action_js_1.SandboxAction {
         super(sandbox);
     }
     streamLogs(identifier, options) {
+        if (options.ws) {
+            return this.wsStreamLogs(identifier, options);
+        }
+        return this.sseStreamLogs(identifier, options);
+    }
+    wsStreamLogs(identifier, options) {
+        let closed = false;
+        let ws = this.websocket(`process/${identifier}/logs/stream`);
+        let pingInterval = null;
+        let pongTimeout = null;
+        const PING_INTERVAL_MS = 30000;
+        const PONG_TIMEOUT_MS = 10000;
+        function sendPing() {
+            if (ws && ws.readyState === ws.OPEN) {
+                try {
+                    ws.send(JSON.stringify({ type: 'ping' }));
+                }
+                catch { }
+                // Set pong timeout
+                if (pongTimeout)
+                    clearTimeout(pongTimeout);
+                pongTimeout = setTimeout(() => {
+                    // No pong received in time, close connection
+                    if (ws && typeof ws.close === 'function')
+                        ws.close();
+                }, PONG_TIMEOUT_MS);
+            }
+        }
+        if (ws) {
+            ws.onmessage = (event) => {
+                if (closed)
+                    return;
+                let data;
+                try {
+                    data = typeof event.data === 'string' ? event.data : event.data;
+                    if (!data)
+                        return;
+                    let payload;
+                    try {
+                        payload = JSON.parse(data);
+                    }
+                    catch {
+                        payload = { log: data };
+                    }
+                    // Handle ping/pong
+                    if (payload.type === 'ping') {
+                        // Respond to ping with pong
+                        if (ws && ws.readyState === ws.OPEN) {
+                            try {
+                                ws.send(JSON.stringify({ type: 'pong' }));
+                            }
+                            catch { }
+                        }
+                        return;
+                    }
+                    if (payload.type === 'pong') {
+                        // Pong received, clear pong timeout
+                        if (pongTimeout)
+                            clearTimeout(pongTimeout);
+                        pongTimeout = null;
+                        return;
+                    }
+                    if (payload.type === 'log') {
+                        const logLine = payload.log || "";
+                        if (typeof logLine === 'string') {
+                            if (logLine.startsWith('stdout:')) {
+                                options.onStdout?.(logLine.slice(7));
+                                options.onLog?.(logLine.slice(7));
+                            }
+                            else if (logLine.startsWith('stderr:')) {
+                                options.onStderr?.(logLine.slice(7));
+                                options.onLog?.(logLine.slice(7));
+                            }
+                            else {
+                                options.onLog?.(logLine);
+                            }
+                        }
+                    }
+                }
+                catch (err) {
+                    console.error('WebSocket log stream error:', err);
+                }
+            };
+            ws.onerror = (err) => {
+                closed = true;
+                if (ws && typeof ws.close === 'function')
+                    ws.close();
+            };
+            ws.onclose = () => {
+                closed = true;
+                ws = null;
+                if (pingInterval)
+                    clearInterval(pingInterval);
+                if (pongTimeout)
+                    clearTimeout(pongTimeout);
+            };
+            // Start ping interval
+            pingInterval = setInterval(sendPing, PING_INTERVAL_MS);
+        }
+        return {
+            close: () => {
+                closed = true;
+                if (ws && typeof ws.close === 'function')
+                    ws.close();
+                ws = null;
+                if (pingInterval)
+                    clearInterval(pingInterval);
+                if (pongTimeout)
+                    clearTimeout(pongTimeout);
+            },
+        };
+    }
+    sseStreamLogs(identifier, options) {
         const controller = new AbortController();
         (async () => {
             try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blaxel/core",
-  "version": "0.2.2-preview2",
+  "version": "0.2.2",
   "description": "Blaxel Core SDK for TypeScript",
   "license": "MIT",
   "author": "Blaxel, INC (https://blaxel.ai)",

package/dist/mcp/server/http.d.ts

@@ -1,8 +0,0 @@
-import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
-import { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
-export declare class BlaxelHttpMcpServerTransport implements Transport {
-    private server;
-    constructor(port: number);
-    start(): Promise<void>;
-    send(msg: JSONRPCMessage): Promise<void>;
-}

package/dist/mcp/server/http.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BlaxelHttpMcpServerTransport = void 0;
-const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
-class BlaxelHttpMcpServerTransport {
-    server;
-    constructor(port) {
-        this.server = new streamableHttp_js_1.StreamableHTTPServerTransport({ port });
-    }
-    async start() {
-        await this.server.start();
-    }
-    async send(msg) {
-    }
-}
-exports.BlaxelHttpMcpServerTransport = BlaxelHttpMcpServerTransport;

package/dist/mcp/server/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./http.js";
-export * from "./websocket.js";
-import { BlaxelWebsocketMcpServerTransport } from "./websocket.js";
-export declare const BlaxelMcpServerTransport: typeof BlaxelWebsocketMcpServerTransport;

package/dist/mcp/server/index.js

@@ -1,21 +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 });
-exports.BlaxelMcpServerTransport = void 0;
-__exportStar(require("./http.js"), exports);
-__exportStar(require("./websocket.js"), exports);
-const websocket_js_1 = require("./websocket.js");
-exports.BlaxelMcpServerTransport = websocket_js_1.BlaxelWebsocketMcpServerTransport;

package/dist/mcp/server/websocket.d.ts

@@ -1,24 +0,0 @@
-import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
-interface JSONRPCMessage {
-    jsonrpc: "2.0";
-    id?: string | number;
-    method?: string;
-    params?: Record<string, unknown>;
-}
-export declare class BlaxelWebsocketMcpServerTransport implements Transport {
-    private port;
-    private wss;
-    private clients;
-    onclose?: () => void;
-    onerror?: (err: Error) => void;
-    private messageHandler?;
-    onconnection?: (clientId: string) => void;
-    ondisconnection?: (clientId: string) => void;
-    set onmessage(handler: ((message: JSONRPCMessage) => void) | undefined);
-    constructor(port?: number);
-    start(): Promise<void>;
-    send(msg: JSONRPCMessage): Promise<void>;
-    broadcast(msg: JSONRPCMessage): Promise<void>;
-    close(): Promise<void>;
-}
-export {};

package/dist/mcp/server/websocket.js

@@ -1,213 +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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BlaxelWebsocketMcpServerTransport = void 0;
-const uuid_1 = require("uuid");
-const ws_1 = __importStar(require("ws"));
-const env_js_1 = require("../../common/env.js");
-const logger_js_1 = require("../../common/logger.js");
-const telemetry_js_1 = require("../../telemetry/telemetry.js");
-const spans = new Map();
-class BlaxelWebsocketMcpServerTransport {
-    port;
-    wss;
-    clients = new Map();
-    onclose;
-    onerror;
-    messageHandler;
-    onconnection;
-    ondisconnection;
-    set onmessage(handler) {
-        this.messageHandler = handler
-            ? (msg, clientId) => {
-                if (!("id" in msg)) {
-                    return handler(msg);
-                }
-                return handler({
-                    ...msg,
-                    id: clientId + ":" + msg.id,
-                });
-            }
-            : undefined;
-    }
-    constructor(port) {
-        this.port = port ?? parseInt(env_js_1.env.BL_SERVER_PORT ?? "8080", 10);
-        this.wss = new ws_1.WebSocketServer({ port: this.port });
-    }
-    async start() {
-        logger_js_1.logger.info("Starting WebSocket Server on port " + this.port);
-        this.wss.on("connection", (ws) => {
-            const clientId = (0, uuid_1.v4)();
-            this.clients.set(clientId, {
-                ws,
-            });
-            this.onconnection?.(clientId);
-            ws.on("message", (data) => {
-                const span = (0, telemetry_js_1.startSpan)("message", {
-                    attributes: {
-                        "mcp.client.id": clientId,
-                        "span.type": "mcp.message",
-                    },
-                    isRoot: false,
-                });
-                try {
-                    const msg = JSON.parse(data.toString());
-                    this.messageHandler?.(msg, clientId);
-                    if ("method" in msg && "id" in msg && "params" in msg) {
-                        span.setAttributes({
-                            "mcp.message.parsed": true,
-                            "mcp.method": msg.method,
-                            "mcp.messageId": msg.id,
-                            "mcp.toolName": msg.params?.name,
-                        });
-                        spans.set(clientId + ":" + msg.id, span);
-                    }
-                    // Handle msg.id safely
-                    const msgId = msg.id ? String(msg.id) : "";
-                    const [cId, parsedMsgId] = msgId.split(":");
-                    msg.id = parsedMsgId ? parseInt(parsedMsgId) : undefined;
-                    // Use optional chaining for safe access
-                    const client = this.clients.get(cId ?? "");
-                    if (client?.ws?.readyState === ws_1.default.OPEN) {
-                        const msgSpan = spans.get(cId + ":" + (msg.id ?? ""));
-                        try {
-                            client.ws.send(JSON.stringify(msg));
-                            if (msgSpan) {
-                                msgSpan.setAttributes({
-                                    "mcp.message.response_sent": true,
-                                });
-                            }
-                        }
-                        catch (err) {
-                            if (msgSpan) {
-                                msgSpan.setStatus("error"); // Error status
-                                msgSpan.recordException(err);
-                            }
-                            throw err;
-                        }
-                        finally {
-                            if (msgSpan) {
-                                msgSpan.end();
-                            }
-                        }
-                    }
-                    else {
-                        this.clients.delete(cId);
-                        this.ondisconnection?.(cId);
-                    }
-                }
-                catch (err) {
-                    if (err instanceof Error) {
-                        span.setStatus("error"); // Error status
-                        span.recordException(err);
-                        this.onerror?.(err);
-                    }
-                    else {
-                        this.onerror?.(new Error(`Failed to parse message: ${String(err)}`));
-                    }
-                    span.end();
-                }
-            });
-            ws.on("close", () => {
-                this.clients.delete(clientId);
-                this.ondisconnection?.(clientId);
-            });
-            ws.on("error", (err) => {
-                this.onerror?.(err);
-            });
-        });
-        return Promise.resolve();
-    }
-    async send(msg) {
-        const [cId, msgId] = msg.id ? String(msg.id).split(":") : [];
-        msg.id = parseInt(msgId);
-        const data = JSON.stringify(msg);
-        const deadClients = [];
-        if (cId) {
-            // Send to specific client
-            const client = this.clients.get(cId);
-            if (client?.ws?.readyState === ws_1.default.OPEN) {
-                const msgSpan = spans.get(cId + ":" + msg.id);
-                try {
-                    client.ws.send(data);
-                    if (msgSpan) {
-                        msgSpan.setAttributes({
-                            "mcp.message.response_sent": true,
-                        });
-                    }
-                }
-                catch (err) {
-                    if (msgSpan) {
-                        msgSpan.setStatus("error"); // Error status
-                        msgSpan.recordException(err);
-                    }
-                    throw err;
-                }
-                finally {
-                    if (msgSpan) {
-                        msgSpan.end();
-                    }
-                }
-            }
-            else {
-                this.clients.delete(cId);
-                this.ondisconnection?.(cId);
-            }
-        }
-        for (const [id, client] of this.clients.entries()) {
-            if (client.ws.readyState !== ws_1.default.OPEN) {
-                deadClients.push(id);
-            }
-        }
-        // Cleanup dead clients
-        deadClients.forEach((id) => {
-            this.clients.delete(id);
-            this.ondisconnection?.(id);
-        });
-        return Promise.resolve();
-    }
-    async broadcast(msg) {
-        return this.send(msg);
-    }
-    async close() {
-        return new Promise((resolve) => {
-            this.wss.close(() => {
-                this.clients.clear();
-                resolve();
-            });
-        });
-    }
-}
-exports.BlaxelWebsocketMcpServerTransport = BlaxelWebsocketMcpServerTransport;