@blaxel/core 0.2.2-dev.60 → 0.2.2-preview1

package/dist/common/settings.js

@@ -75,7 +75,7 @@ class Settings {
         if (!this.generation) {
             return "";
         }
-        return env_js_1.env.BL_RUN_INTERNAL_HOST || "";
+        return env_js_1.env.BL_RUN_INTERNAL_HOSTNAME || "";
     }
     get runInternalProtocol() {
         return env_js_1.env.BL_RUN_INTERNAL_PROTOCOL || "https";

package/dist/jobs/jobs.d.ts

@@ -2,7 +2,6 @@ declare class BlJob {
     getArguments(): Promise<{
         [key: number]: any;
     }>;
-    private parseCommandLineArgs;
     get indexKey(): string;
     get index(): number;
     start(func: (args: any) => Promise<void>): Promise<void>;

package/dist/jobs/jobs.js

@@ -1,38 +1,25 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.blJob = void 0;
+const yargs_1 = __importDefault(require("yargs"));
+const helpers_1 = require("yargs/helpers");
 const env_js_1 = require("../common/env.js");
 class BlJob {
     async getArguments() {
         if (!env_js_1.env.BL_EXECUTION_DATA_URL) {
-            const args = this.parseCommandLineArgs();
-            return args;
+            const argv = await (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
+                .parseAsync();
+            return argv;
         }
         const response = await fetch(env_js_1.env.BL_EXECUTION_DATA_URL);
         const data = await response.json();
         return data.tasks[this.index] ?? {};
     }
-    parseCommandLineArgs() {
-        const args = process.argv.slice(2);
-        const result = {};
-        for (let i = 0; i < args.length; i++) {
-            const arg = args[i];
-            if (arg.startsWith('--')) {
-                const key = arg.slice(2);
-                const value = args[i + 1];
-                if (value && !value.startsWith('--')) {
-                    result[key] = value;
-                    i++;
-                }
-                else {
-                    result[key] = 'true';
-                }
-            }
-        }
-        return result;
-    }
     get indexKey() {
-        return env_js_1.env.BL_TASK_KEY ?? "TASK_INDEX";
+        return env_js_1.env.BL_EXECUTION_INDEX_KEY ?? "TASK_INDEX";
     }
     get index() {
         return env_js_1.env[this.indexKey] ? Number(env_js_1.env[this.indexKey]) ?? 0 : 0;

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

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

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

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

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

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

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

package/dist/sandbox/action.d.ts

@@ -1,4 +1,4 @@
-import { Sandbox } from "../client/index.js";
+import { SandboxConfiguration } from "./types.js";
 export declare class ResponseError extends Error {
     response: Response;
     data: unknown;
@@ -6,14 +6,14 @@ export declare class ResponseError extends Error {
     constructor(response: Response, data: unknown, error: unknown);
 }
 export declare class SandboxAction {
-    private sandbox;
-    constructor(sandbox: Sandbox);
+    protected sandbox: SandboxConfiguration;
+    constructor(sandbox: SandboxConfiguration);
     get name(): string;
     get fallbackUrl(): string | null;
     get externalUrl(): string;
     get internalUrl(): string;
+    get client(): import("@hey-api/client-fetch").Client;
     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

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SandboxAction = exports.ResponseError = void 0;
+const client_fetch_1 = require("@hey-api/client-fetch");
 const process_1 = require("process");
 const internal_js_1 = require("../common/internal.js");
 const settings_js_1 = require("../common/settings.js");
+const client_gen_js_1 = require("./client/client.gen.js");
 class ResponseError extends Error {
     response;
     data;
@@ -50,7 +52,18 @@ class SandboxAction {
         const hash = (0, internal_js_1.getGlobalUniqueHash)(settings_js_1.settings.workspace, "sandbox", this.name);
         return `${settings_js_1.settings.runInternalProtocol}://bl-${settings_js_1.settings.env}-${hash}.${settings_js_1.settings.runInternalHostname}`;
     }
+    get client() {
+        if (this.sandbox.forceUrl) {
+            return (0, client_fetch_1.createClient)({
+                baseUrl: this.sandbox.forceUrl,
+                headers: this.sandbox.headers,
+            });
+        }
+        return client_gen_js_1.client;
+    }
     get forcedUrl() {
+        if (this.sandbox.forceUrl)
+            return this.sandbox.forceUrl;
         const envVar = this.name.replace(/-/g, "_").toUpperCase();
         const envName = `BL_SANDBOX_${envVar}_URL`;
         if (process_1.env[envName]) {
@@ -71,37 +84,5 @@ 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);
-        const wsUrl = `${baseUrl}/ws/${path}?token=${settings_js_1.settings.token}`;
-        // 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,27 +14,7 @@ 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

@@ -13,6 +13,7 @@ class SandboxFileSystem extends action_js_1.SandboxAction {
             path: { path },
             body: { isDirectory: true, permissions },
             baseUrl: this.url,
+            client: this.client,
         });
         this.handleResponseError(response, data, error);
         return data;
@@ -23,6 +24,7 @@ class SandboxFileSystem extends action_js_1.SandboxAction {
             path: { path },
             body: { content },
             baseUrl: this.url,
+            client: this.client,
         });
         this.handleResponseError(response, data, error);
         return data;
@@ -32,6 +34,7 @@ class SandboxFileSystem extends action_js_1.SandboxAction {
         const { response, data, error } = await (0, index_js_1.getFilesystemByPath)({
             path: { path },
             baseUrl: this.url,
+            client: this.client,
         });
         this.handleResponseError(response, data, error);
         if (data && 'content' in data) {
@@ -45,6 +48,7 @@ class SandboxFileSystem extends action_js_1.SandboxAction {
             path: { path },
             query: { recursive },
             baseUrl: this.url,
+            client: this.client,
         });
         this.handleResponseError(response, data, error);
         return data;
@@ -54,6 +58,7 @@ class SandboxFileSystem extends action_js_1.SandboxAction {
         const { response, data, error } = await (0, index_js_1.getFilesystemByPath)({
             path: { path },
             baseUrl: this.url,
+            client: this.client,
         });
         this.handleResponseError(response, data, error);
         if (!data || !('files' in data || 'subdirectories' in data)) {
@@ -67,6 +72,7 @@ class SandboxFileSystem extends action_js_1.SandboxAction {
         const { response, data, error } = await (0, index_js_1.getFilesystemByPath)({
             path: { path: source },
             baseUrl: this.url,
+            client: this.client,
         });
         this.handleResponseError(response, data, error);
         if (data && ('files' in data || 'subdirectories' in data)) {
@@ -111,136 +117,13 @@ 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();
         const start = async () => {
             const { response, data, error } = await (0, index_js_1.getWatchFilesystemByPath)({
+                client: this.client,
                 path: { path },
                 baseUrl: this.url,
                 parseAs: 'stream',

package/dist/sandbox/process.d.ts

@@ -4,21 +4,6 @@ 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,126 +9,14 @@ 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 {
+                const headers = this.sandbox.forceUrl ? this.sandbox.headers : settings_js_1.settings.headers;
                 const stream = await fetch(`${this.url}/process/${identifier}/logs/stream`, {
                     method: 'GET',
                     signal: controller.signal,
-                    headers: settings_js_1.settings.headers,
+                    headers,
                 });
                 if (stream.status !== 200) {
                     throw new Error(`Failed to stream logs: ${await stream.text()}`);
@@ -175,6 +63,7 @@ class SandboxProcess extends action_js_1.SandboxAction {
         const { response, data, error } = await (0, index_js_1.postProcess)({
             body: process,
             baseUrl: this.url,
+            client: this.client,
         });
         this.handleResponseError(response, data, error);
         return data;
@@ -202,6 +91,7 @@ class SandboxProcess extends action_js_1.SandboxAction {
         const { response, data, error } = await (0, index_js_1.getProcessByIdentifier)({
             path: { identifier },
             baseUrl: this.url,
+            client: this.client,
         });
         this.handleResponseError(response, data, error);
         return data;
@@ -209,6 +99,7 @@ class SandboxProcess extends action_js_1.SandboxAction {
     async list() {
         const { response, data, error } = await (0, index_js_1.getProcess)({
             baseUrl: this.url,
+            client: this.client,
         });
         this.handleResponseError(response, data, error);
         return data;
@@ -217,6 +108,7 @@ class SandboxProcess extends action_js_1.SandboxAction {
         const { response, data, error } = await (0, index_js_1.deleteProcessByIdentifier)({
             path: { identifier },
             baseUrl: this.url,
+            client: this.client,
         });
         this.handleResponseError(response, data, error);
         return data;
@@ -225,6 +117,7 @@ class SandboxProcess extends action_js_1.SandboxAction {
         const { response, data, error } = await (0, index_js_1.deleteProcessByIdentifierKill)({
             path: { identifier },
             baseUrl: this.url,
+            client: this.client,
         });
         this.handleResponseError(response, data, error);
         return data;
@@ -233,6 +126,7 @@ class SandboxProcess extends action_js_1.SandboxAction {
         const { response, data, error } = await (0, index_js_1.getProcessByIdentifierLogs)({
             path: { identifier },
             baseUrl: this.url,
+            client: this.client,
         });
         this.handleResponseError(response, data, error);
         if (data && type in data) {

package/dist/sandbox/sandbox.d.ts

@@ -3,13 +3,16 @@ import { SandboxFileSystem } from "./filesystem.js";
 import { SandboxNetwork } from "./network.js";
 import { SandboxPreviews } from "./preview.js";
 import { SandboxProcess } from "./process.js";
+import { SandboxSessions } from "./session.js";
+import { SandboxConfiguration, SessionWithToken } from "./types.js";
 export declare class SandboxInstance {
     private sandbox;
     fs: SandboxFileSystem;
     network: SandboxNetwork;
     process: SandboxProcess;
     previews: SandboxPreviews;
-    constructor(sandbox: SandboxModel);
+    sessions: SandboxSessions;
+    constructor(sandbox: SandboxConfiguration);
     get metadata(): import("../client/types.gen.js").Metadata | undefined;
     get status(): string | undefined;
     get events(): import("../client/types.gen.js").CoreEvents | undefined;
@@ -22,4 +25,5 @@ export declare class SandboxInstance {
     static get(sandboxName: string): Promise<SandboxInstance>;
     static list(): Promise<SandboxInstance[]>;
     static delete(sandboxName: string): Promise<SandboxModel>;
+    static fromSession(session: SessionWithToken): Promise<SandboxInstance>;
 }

package/dist/sandbox/sandbox.js

@@ -7,18 +7,21 @@ const filesystem_js_1 = require("./filesystem.js");
 const network_js_1 = require("./network.js");
 const preview_js_1 = require("./preview.js");
 const process_js_1 = require("./process.js");
+const session_js_1 = require("./session.js");
 class SandboxInstance {
     sandbox;
     fs;
     network;
     process;
     previews;
+    sessions;
     constructor(sandbox) {
         this.sandbox = sandbox;
         this.fs = new filesystem_js_1.SandboxFileSystem(sandbox);
         this.network = new network_js_1.SandboxNetwork(sandbox);
         this.process = new process_js_1.SandboxProcess(sandbox);
         this.previews = new preview_js_1.SandboxPreviews(sandbox);
+        this.sessions = new session_js_1.SandboxSessions(sandbox);
     }
     get metadata() {
         return this.sandbox.metadata;
@@ -91,5 +94,8 @@ class SandboxInstance {
         });
         return data;
     }
+    static async fromSession(session) {
+        return new SandboxInstance({ forceUrl: session.url, params: { bl_preview_token: session.token }, headers: { "X-Blaxel-Preview-Token": session.token } });
+    }
 }
 exports.SandboxInstance = SandboxInstance;

package/dist/sandbox/session.d.ts

@@ -0,0 +1,21 @@
+import { Sandbox } from "../client/index.js";
+import { SessionCreateOptions, SessionWithToken } from "./types.js";
+export declare class SandboxSessions {
+    private sandbox;
+    constructor(sandbox: Sandbox);
+    get sandboxName(): string;
+    create(options?: SessionCreateOptions): Promise<SessionWithToken>;
+    list(): Promise<{
+        name: string;
+        url: string;
+        token: string;
+        expiresAt: string | Date;
+    }[]>;
+    get(name: string): Promise<{
+        url: string;
+        token: string;
+        expiresAt: string | Date;
+    }>;
+    delete(name: string): Promise<import("../client/types.gen.js").Preview>;
+    getToken(previewName: string): Promise<import("../client/types.gen.js").PreviewToken | null>;
+}

package/dist/sandbox/session.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxSessions = void 0;
+const index_js_1 = require("../client/index.js");
+const preview_js_1 = require("./preview.js");
+class SandboxSessions {
+    sandbox;
+    constructor(sandbox) {
+        this.sandbox = sandbox;
+    }
+    get sandboxName() {
+        return this.sandbox.metadata?.name ?? "";
+    }
+    async create(options = {}) {
+        const expiresAt = options.expiresAt ?? new Date(Date.now() + 24 * 60 * 60 * 1000); // 1 day from now
+        const body = {
+            metadata: {
+                name: "session-" + Date.now(),
+            },
+            spec: {
+                port: 443,
+                public: false,
+            },
+        };
+        const { data } = await (0, index_js_1.createSandboxPreview)({
+            path: {
+                sandboxName: this.sandboxName,
+            },
+            body,
+            throwOnError: true,
+        });
+        const preview = new preview_js_1.SandboxPreview(data);
+        // Create a token for the preview with the given expiresAt
+        const tokenObj = await preview.tokens.create(expiresAt);
+        return {
+            name: body.metadata.name,
+            url: preview.spec?.url ?? "",
+            token: tokenObj.value,
+            expiresAt: typeof tokenObj.expiresAt === 'string' ? new Date(tokenObj.expiresAt) : tokenObj.expiresAt,
+        };
+    }
+    async list() {
+        const { data } = await (0, index_js_1.listSandboxPreviews)({
+            path: {
+                sandboxName: this.sandboxName,
+            },
+            throwOnError: true,
+        });
+        return await Promise.all(data.filter((preview) => preview.metadata?.name?.includes("session-")).map(async (preview) => {
+            const token = await this.getToken(preview.metadata?.name ?? "");
+            return {
+                name: preview.metadata?.name ?? "",
+                url: preview.spec?.url ?? "",
+                token: token?.spec?.token ?? "",
+                expiresAt: token?.spec?.expiresAt ?? new Date(),
+            };
+        }));
+    }
+    async get(name) {
+        const { data } = await (0, index_js_1.getSandboxPreview)({
+            path: {
+                sandboxName: this.sandboxName,
+                previewName: name,
+            },
+            throwOnError: true,
+        });
+        const token = await this.getToken(name);
+        return {
+            url: data.spec?.url ?? "",
+            token: token?.spec?.token ?? "",
+            expiresAt: token?.spec?.expiresAt ?? new Date(),
+        };
+    }
+    async delete(name) {
+        const { data } = await (0, index_js_1.deleteSandboxPreview)({
+            path: {
+                sandboxName: this.sandboxName,
+                previewName: name,
+            },
+            throwOnError: true,
+        });
+        return data;
+    }
+    async getToken(previewName) {
+        const { data } = await (0, index_js_1.listSandboxPreviewTokens)({
+            path: {
+                sandboxName: this.sandboxName,
+                previewName,
+            },
+            throwOnError: true,
+        });
+        if (data.length === 0)
+            return null;
+        return data[0];
+    }
+}
+exports.SandboxSessions = SandboxSessions;

package/dist/sandbox/types.d.ts

@@ -0,0 +1,15 @@
+import { Sandbox } from "../client/types.gen";
+export interface SessionCreateOptions {
+    expiresAt?: Date;
+}
+export interface SessionWithToken {
+    name: string;
+    url: string;
+    token: string;
+    expiresAt: Date;
+}
+export type SandboxConfiguration = {
+    forceUrl?: string;
+    headers?: Record<string, string>;
+    params?: Record<string, string>;
+} & Sandbox;

package/dist/sandbox/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blaxel/core",
-  "version": "0.2.2-dev.60",
+  "version": "0.2.2-preview1",
   "description": "Blaxel Core SDK for TypeScript",
   "license": "MIT",
   "author": "Blaxel, INC (https://blaxel.ai)",
@@ -62,11 +62,13 @@
     "uuid": "^11.1.0",
     "ws": "^8.18.2",
     "yaml": "^2.7.1",
+    "yargs": "^17.7.2",
     "zod": "^3.24.3"
   },
   "devDependencies": {
     "@eslint/js": "^9.26.0",
     "@types/ws": "^8.18.1",
+    "@types/yargs": "^17.0.33",
     "typescript": "^5.0.0",
     "typescript-eslint": "^8.31.1"
   },