@blaxel/core 0.2.36-dev.185 → 0.2.36-dev.190

package/dist/esm/jobs/start.js

@@ -0,0 +1,62 @@
+import { authenticate } from '../common/autoload.js';
+import { env } from '../common/env.js';
+import { flush } from '../telemetry/telemetry.js';
+class BlJobWrapper {
+    async getArguments() {
+        if (!env.BL_EXECUTION_DATA_URL) {
+            const args = this.parseCommandLineArgs();
+            return args;
+        }
+        const response = await fetch(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.BL_TASK_KEY ?? "TASK_INDEX";
+    }
+    get index() {
+        return env[this.indexKey] ? Number(env[this.indexKey]) : 0;
+    }
+    /*
+      Run a job defined in a function, it's run in the current process
+    */
+    async start(func) {
+        await authenticate();
+        const parsedArgs = await this.getArguments();
+        await func(parsedArgs);
+    }
+}
+export const blStartJob = (func) => {
+    const job = new BlJobWrapper();
+    job.start(func).then(async () => {
+        try {
+            await flush();
+        }
+        catch (error) {
+            console.error('Error flushing telemetry:', error);
+        }
+        process.exit(0);
+    }).catch((error) => {
+        console.error('Job execution failed:', error);
+        process.exit(1);
+    });
+};

package/dist/esm/jobs/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/mcp/client.js

@@ -0,0 +1,243 @@
+import { JSONRPCMessageSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { logger } from "../common/logger.js";
+import { settings } from "../common/settings.js";
+// Detect environment
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const isBrowser = typeof globalThis !== "undefined" && globalThis.window !== undefined;
+// Conditional import for Node.js WebSocket
+let NodeWebSocket;
+if (!isBrowser) {
+    try {
+        // Dynamic import for Node.js environment
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-require-imports
+        NodeWebSocket = require("ws");
+    }
+    catch {
+        console.warn("ws is not available in this environment");
+        // ws is not available
+    }
+}
+//const SUBPROTOCOL = "mcp";
+// Helper function to wait
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+ * Client transport for WebSocket: this will connect to a server over the WebSocket protocol.
+ * Works in both browser and Node.js environments.
+ */
+export class BlaxelMcpClientTransport {
+    _socket;
+    _url;
+    _headers;
+    _isBrowser;
+    _retry_max;
+    _retry_delay;
+    onclose;
+    onerror;
+    onmessage;
+    constructor(url, headers, options) {
+        this._url = new URL(url.replace("http", "ws"));
+        this._retry_max = options?.retry?.max ?? 3;
+        this._retry_delay = options?.retry?.delay ?? 1000;
+        this._headers = headers ?? {};
+        this._isBrowser = isBrowser;
+    }
+    async start() {
+        if (this._socket) {
+            throw new Error("Blaxel already started! If using Client class, note that connect() calls start() automatically.");
+        }
+        let attempts = 0;
+        const maxAttempts = Math.max(1, this._retry_max + 1); // Ensure at least 1 attempt
+        while (attempts < maxAttempts) {
+            try {
+                await this._connect();
+                return;
+            }
+            catch (error) {
+                attempts++;
+                if (error instanceof Error) {
+                    logger.warn(error.stack ?? error.message);
+                }
+                if (attempts >= maxAttempts) {
+                    throw error;
+                }
+                logger.debug(`WebSocket connection attempt ${attempts} failed, retrying in ${this._retry_delay}ms...`);
+                await delay(this._retry_delay);
+            }
+        }
+    }
+    _connect() {
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        return new Promise((resolve, reject) => {
+            try {
+                if (this._isBrowser) {
+                    // Use native browser WebSocket
+                    const url = `${this._url.toString()}?token=${settings.token}`;
+                    this._socket = new WebSocket(url);
+                }
+                else {
+                    // Use Node.js WebSocket
+                    if (!NodeWebSocket) {
+                        throw new Error("WebSocket library not available in Node.js environment");
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+                    this._socket = new NodeWebSocket(this._url, {
+                        //protocols: SUBPROTOCOL,
+                        headers: this._headers,
+                    });
+                }
+                this._socket.onerror = (event) => {
+                    // Log websocket error with meaningful information instead of raw event
+                    const errorInfo = {
+                        type: 'WebSocket Error',
+                        url: this._url.toString(),
+                        readyState: this._socket?.readyState,
+                        browser: this._isBrowser,
+                        // Extract any available error details from the event
+                        eventType: event && typeof event === 'object' && 'type' in event
+                            ? String(event.type)
+                            : 'unknown',
+                        // Browser events might have different properties than Node.js
+                        message: this._isBrowser && event && typeof event === 'object' && 'message' in event
+                            ? String(event.message)
+                            : undefined,
+                        error: !this._isBrowser && event && typeof event === 'object' && 'error' in event
+                            ? String(event.error)
+                            : undefined
+                    };
+                    logger.error('WebSocket connection error', errorInfo);
+                    const error = this._isBrowser
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                        ? new Error(`WebSocket error: ${event.message}`)
+                        : "error" in event
+                            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                            ? event.error
+                            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                            : new Error(`WebSocket error: ${event.message}`);
+                    reject(error);
+                    this.onerror?.(error);
+                };
+                this._socket.onopen = () => {
+                    resolve();
+                };
+                this._socket.onclose = () => {
+                    this.onclose?.();
+                    this._socket = undefined;
+                };
+                this._socket.onmessage = (event) => {
+                    let message;
+                    try {
+                        let dataString;
+                        if (this._isBrowser) {
+                            // Browser WebSocket MessageEvent
+                            const browserEvent = event;
+                            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                            dataString = typeof browserEvent.data === "string"
+                                ? browserEvent.data
+                                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+                                : browserEvent.data.toString();
+                        }
+                        else {
+                            // Node.js WebSocket MessageEvent
+                            const nodeEvent = event;
+                            if (typeof nodeEvent.data === "string") {
+                                dataString = nodeEvent.data;
+                            }
+                            else if (nodeEvent.data instanceof Buffer) {
+                                dataString = nodeEvent.data.toString("utf-8");
+                            }
+                            else {
+                                throw new Error("Unsupported data type for event.data");
+                            }
+                        }
+                        message = JSONRPCMessageSchema.parse(JSON.parse(dataString));
+                    }
+                    catch (error) {
+                        logger.error(`Error parsing message: ${
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                        typeof event.data === "object"
+                            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                            ? JSON.stringify(event.data)
+                            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                            : event.data}`);
+                        this.onerror?.(error);
+                        return;
+                    }
+                    this.onmessage?.(message);
+                };
+            }
+            catch (error) {
+                if (error instanceof Error && error.message.includes("ws does not work in the browser")) {
+                    this._isBrowser = true;
+                    return this._connect().then(resolve).catch(reject);
+                }
+                reject(error);
+            }
+        });
+    }
+    get isConnected() {
+        if (!this._socket)
+            return false;
+        if (this._isBrowser) {
+            return this._socket.readyState === 1; // WebSocket.OPEN = 1
+        }
+        else {
+            return this._socket.readyState === 1; // WebSocket.OPEN = 1
+        }
+    }
+    async close() {
+        this._socket?.close();
+        this._socket = undefined;
+        this.onclose?.();
+        return Promise.resolve();
+    }
+    async send(message) {
+        let attempts = 0;
+        const maxAttempts = Math.max(1, this._retry_max + 1); // Ensure at least 1 attempt
+        while (attempts < maxAttempts) {
+            try {
+                if (!this._socket || !this.isConnected) {
+                    if (!this._socket) {
+                        // Only try to start if socket doesn't exist
+                        await this.start();
+                    }
+                    else {
+                        throw new Error("WebSocket is not in OPEN state");
+                    }
+                }
+                await new Promise((resolve, reject) => {
+                    try {
+                        const messageStr = JSON.stringify(message);
+                        if (this._isBrowser) {
+                            // Browser WebSocket
+                            this._socket?.send(messageStr);
+                            resolve();
+                        }
+                        else {
+                            // Node.js WebSocket
+                            this._socket?.send(messageStr, (error) => {
+                                if (error) {
+                                    reject(error);
+                                }
+                                else {
+                                    resolve();
+                                }
+                            });
+                        }
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
+                return;
+            }
+            catch (error) {
+                attempts++;
+                if (attempts >= maxAttempts) {
+                    throw error;
+                }
+                logger.warn(`WebSocket send attempt ${attempts} failed, retrying in ${this._retry_delay}ms...`);
+                await delay(this._retry_delay);
+            }
+        }
+    }
+}

package/dist/esm/mcp/index.js

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

package/dist/esm/mcp/server.js

@@ -0,0 +1,176 @@
+import { v4 as uuidv4 } from "uuid";
+import WebSocket, { WebSocketServer } from "ws";
+import { env } from "../common/env.js";
+import { logger } from "../common/logger.js";
+import { startSpan } from "../telemetry/telemetry.js";
+const spans = new Map();
+export class BlaxelMcpServerTransport {
+    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.BL_SERVER_PORT ?? "8080", 10);
+        this.wss = new WebSocketServer({ port: this.port });
+    }
+    async start() {
+        logger.info("Starting WebSocket Server on port " + this.port);
+        this.wss.on("connection", (ws) => {
+            const clientId = uuidv4();
+            this.clients.set(clientId, {
+                ws,
+            });
+            this.onconnection?.(clientId);
+            ws.on("message", (data) => {
+                const span = 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 === WebSocket.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 === WebSocket.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 !== WebSocket.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();
+            });
+        });
+    }
+}

package/dist/esm/models/index.js

@@ -0,0 +1,25 @@
+import { findFromCache } from "../cache/index.js";
+import { getModel } from "../client/sdk.gen.js";
+export class BLModel {
+    modelName;
+    options;
+    constructor(modelName, options) {
+        this.modelName = modelName;
+        this.options = options || {};
+    }
+}
+export const blModel = (modelName, options) => {
+    return new BLModel(modelName, options);
+};
+export const getModelMetadata = async (model) => {
+    const cacheData = await findFromCache("Model", model);
+    if (cacheData) {
+        return cacheData;
+    }
+    const { data } = await getModel({
+        path: {
+            modelName: model,
+        },
+    });
+    return data || null;
+};

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/dist/esm/sandbox/action.js

@@ -0,0 +1,79 @@
+import { createClient } from "@hey-api/client-fetch";
+import { getForcedUrl, getGlobalUniqueHash } from "../common/internal.js";
+import { settings } from "../common/settings.js";
+import { client as defaultClient } from "./client/client.gen.js";
+export class ResponseError extends Error {
+    response;
+    data;
+    error;
+    constructor(response, data, error) {
+        let dataError = {};
+        if (data && typeof data === 'object' && 'error' in data) {
+            dataError = data;
+        }
+        if (error && typeof error === 'object' && 'error' in error) {
+            dataError['error'] = error.error;
+        }
+        if (response.status) {
+            dataError['status'] = response.status;
+        }
+        if (response.statusText) {
+            dataError['statusText'] = response.statusText;
+        }
+        super(JSON.stringify(dataError));
+        this.response = response;
+        this.data = data;
+        this.error = error;
+    }
+}
+export class SandboxAction {
+    sandbox;
+    constructor(sandbox) {
+        this.sandbox = sandbox;
+    }
+    get name() {
+        return this.sandbox.metadata?.name ?? "";
+    }
+    get fallbackUrl() {
+        if (this.externalUrl != this.url) {
+            return this.externalUrl;
+        }
+        return null;
+    }
+    get externalUrl() {
+        return `${settings.runUrl}/${settings.workspace}/sandboxes/${this.name}`;
+    }
+    get internalUrl() {
+        const hash = getGlobalUniqueHash(settings.workspace, "sandbox", this.name);
+        return `${settings.runInternalProtocol}://bl-${settings.env}-${hash}.${settings.runInternalHostname}`;
+    }
+    get client() {
+        if (this.sandbox.forceUrl) {
+            return createClient({
+                baseUrl: this.sandbox.forceUrl,
+                headers: this.sandbox.headers,
+            });
+        }
+        return defaultClient;
+    }
+    get forcedUrl() {
+        if (this.sandbox.forceUrl)
+            return this.sandbox.forceUrl;
+        return getForcedUrl('sandbox', this.name);
+    }
+    get url() {
+        if (this.forcedUrl) {
+            const url = this.forcedUrl.toString();
+            return url.endsWith('/') ? url.slice(0, -1) : url;
+        }
+        // Uncomment and use this when agent and mcp are available in mk3
+        // Update all requests made in this package to use fallbackUrl when internalUrl is not working
+        // if (settings.runInternalHostname) return this.internalUrl;
+        return this.externalUrl;
+    }
+    handleResponseError(response, data, error) {
+        if (!response.ok || !data) {
+            throw new ResponseError(response, data, error);
+        }
+    }
+}

package/dist/esm/sandbox/client/client.gen.js

@@ -0,0 +1,3 @@
+// This file is auto-generated by @hey-api/openapi-ts
+import { createClient, createConfig } from '@hey-api/client-fetch';
+export const client = createClient(createConfig());

package/dist/esm/sandbox/client/index.js

@@ -0,0 +1,3 @@
+// This file is auto-generated by @hey-api/openapi-ts
+export * from './types.gen.js';
+export * from './sdk.gen.js';