@blaxel/core 0.2.43-dev.196 → 0.2.43-dev.199

package/dist/cjs-browser/mcp/server.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.BlaxelMcpServerTransport = 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 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_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.BlaxelMcpServerTransport = BlaxelMcpServerTransport;

package/dist/cjs-browser/models/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModelMetadata = exports.blModel = exports.BLModel = void 0;
+const index_js_1 = require("../cache/index.js");
+const sdk_gen_js_1 = require("../client/sdk.gen.js");
+class BLModel {
+    modelName;
+    options;
+    constructor(modelName, options) {
+        this.modelName = modelName;
+        this.options = options || {};
+    }
+}
+exports.BLModel = BLModel;
+const blModel = (modelName, options) => {
+    return new BLModel(modelName, options);
+};
+exports.blModel = blModel;
+const getModelMetadata = async (model) => {
+    const cacheData = await (0, index_js_1.findFromCache)("Model", model);
+    if (cacheData) {
+        return cacheData;
+    }
+    const { data } = await (0, sdk_gen_js_1.getModel)({
+        path: {
+            modelName: model,
+        },
+    });
+    return data || null;
+};
+exports.getModelMetadata = getModelMetadata;

package/dist/cjs-browser/sandbox/action.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxAction = exports.ResponseError = void 0;
+const client_fetch_1 = require("@hey-api/client-fetch");
+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;
+    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;
+    }
+}
+exports.ResponseError = ResponseError;
+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 this.sandbox.metadata?.url ?? `${settings_js_1.settings.runUrl}/${settings_js_1.settings.workspace}/sandboxes/${this.name}`;
+    }
+    get internalUrl() {
+        return (0, internal_js_1.generateInternalUrl)(settings_js_1.settings.workspace, "sandbox", this.name, settings_js_1.settings.env, settings_js_1.settings.runInternalProtocol, settings_js_1.settings.runInternalHostname, settings_js_1.settings.blCloud, settings_js_1.settings.workspaceId);
+    }
+    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;
+        return (0, internal_js_1.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);
+        }
+    }
+}
+exports.SandboxAction = SandboxAction;

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

@@ -0,0 +1,6 @@
+"use strict";
+// This file is auto-generated by @hey-api/openapi-ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.client = void 0;
+const client_fetch_1 = require("@hey-api/client-fetch");
+exports.client = (0, client_fetch_1.createClient)((0, client_fetch_1.createConfig)());

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

@@ -0,0 +1,19 @@
+"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 });
+// This file is auto-generated by @hey-api/openapi-ts
+__exportStar(require("./types.gen.js"), exports);
+__exportStar(require("./sdk.gen.js"), exports);

package/dist/cjs-browser/sandbox/client/sdk.gen.js

@@ -0,0 +1,289 @@
+"use strict";
+// This file is auto-generated by @hey-api/openapi-ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWsWatchFilesystemByPath = exports.getWsProcessByIdentifierLogsStream = exports.getWatchFilesystemByPath = exports.getProcessByIdentifierLogsStream = exports.getProcessByIdentifierLogs = exports.deleteProcessByIdentifierKill = exports.getProcessByIdentifier = exports.deleteProcessByIdentifier = exports.postProcess = exports.getProcess = exports.getNetworkProcessByPidPorts = exports.postNetworkProcessByPidMonitor = exports.deleteNetworkProcessByPidMonitor = exports.putFilesystemByPath = exports.getFilesystemByPath = exports.deleteFilesystemByPath = void 0;
+const client_gen_1 = require("./client.gen");
+/**
+ * Delete file or directory
+ * Delete a file or directory
+ */
+const deleteFilesystemByPath = (options) => {
+    return (options.client ?? client_gen_1.client).delete({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/filesystem/{path}',
+        ...options
+    });
+};
+exports.deleteFilesystemByPath = deleteFilesystemByPath;
+/**
+ * Get file or directory information
+ * Get content of a file or listing of a directory
+ */
+const getFilesystemByPath = (options) => {
+    return (options.client ?? client_gen_1.client).get({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/filesystem/{path}',
+        ...options
+    });
+};
+exports.getFilesystemByPath = getFilesystemByPath;
+/**
+ * Create or update a file or directory
+ * Create or update a file or directory
+ */
+const putFilesystemByPath = (options) => {
+    return (options.client ?? client_gen_1.client).put({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/filesystem/{path}',
+        ...options,
+        headers: {
+            'Content-Type': 'application/json',
+            ...options?.headers
+        }
+    });
+};
+exports.putFilesystemByPath = putFilesystemByPath;
+/**
+ * Stop monitoring ports for a process
+ * Stop monitoring for new ports opened by a process
+ */
+const deleteNetworkProcessByPidMonitor = (options) => {
+    return (options.client ?? client_gen_1.client).delete({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/network/process/{pid}/monitor',
+        ...options
+    });
+};
+exports.deleteNetworkProcessByPidMonitor = deleteNetworkProcessByPidMonitor;
+/**
+ * Start monitoring ports for a process
+ * Start monitoring for new ports opened by a process
+ */
+const postNetworkProcessByPidMonitor = (options) => {
+    return (options.client ?? client_gen_1.client).post({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/network/process/{pid}/monitor',
+        ...options,
+        headers: {
+            'Content-Type': 'application/json',
+            ...options?.headers
+        }
+    });
+};
+exports.postNetworkProcessByPidMonitor = postNetworkProcessByPidMonitor;
+/**
+ * Get open ports for a process
+ * Get a list of all open ports for a process
+ */
+const getNetworkProcessByPidPorts = (options) => {
+    return (options.client ?? client_gen_1.client).get({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/network/process/{pid}/ports',
+        ...options
+    });
+};
+exports.getNetworkProcessByPidPorts = getNetworkProcessByPidPorts;
+/**
+ * List all processes
+ * Get a list of all running and completed processes
+ */
+const getProcess = (options) => {
+    return (options?.client ?? client_gen_1.client).get({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/process',
+        ...options
+    });
+};
+exports.getProcess = getProcess;
+/**
+ * Execute a command
+ * Execute a command and return process information
+ */
+const postProcess = (options) => {
+    return (options.client ?? client_gen_1.client).post({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/process',
+        ...options,
+        headers: {
+            'Content-Type': 'application/json',
+            ...options?.headers
+        }
+    });
+};
+exports.postProcess = postProcess;
+/**
+ * Stop a process
+ * Gracefully stop a running process
+ */
+const deleteProcessByIdentifier = (options) => {
+    return (options.client ?? client_gen_1.client).delete({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/process/{identifier}',
+        ...options
+    });
+};
+exports.deleteProcessByIdentifier = deleteProcessByIdentifier;
+/**
+ * Get process by identifier
+ * Get information about a process by its PID or name
+ */
+const getProcessByIdentifier = (options) => {
+    return (options.client ?? client_gen_1.client).get({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/process/{identifier}',
+        ...options
+    });
+};
+exports.getProcessByIdentifier = getProcessByIdentifier;
+/**
+ * Kill a process
+ * Forcefully kill a running process
+ */
+const deleteProcessByIdentifierKill = (options) => {
+    return (options.client ?? client_gen_1.client).delete({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/process/{identifier}/kill',
+        ...options
+    });
+};
+exports.deleteProcessByIdentifierKill = deleteProcessByIdentifierKill;
+/**
+ * Get process logs
+ * Get the stdout and stderr output of a process
+ */
+const getProcessByIdentifierLogs = (options) => {
+    return (options.client ?? client_gen_1.client).get({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/process/{identifier}/logs',
+        ...options
+    });
+};
+exports.getProcessByIdentifierLogs = getProcessByIdentifierLogs;
+/**
+ * Stream process logs in real time
+ * Streams the stdout and stderr output of a process in real time, one line per log, prefixed with 'stdout:' or 'stderr:'. Closes when the process exits or the client disconnects.
+ */
+const getProcessByIdentifierLogsStream = (options) => {
+    return (options.client ?? client_gen_1.client).get({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/process/{identifier}/logs/stream',
+        ...options
+    });
+};
+exports.getProcessByIdentifierLogsStream = getProcessByIdentifierLogsStream;
+/**
+ * Stream file modification events in a directory
+ * Streams the path of modified files (one per line) in the given directory. Closes when the client disconnects.
+ */
+const getWatchFilesystemByPath = (options) => {
+    return (options.client ?? client_gen_1.client).get({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/watch/filesystem/{path}',
+        ...options
+    });
+};
+exports.getWatchFilesystemByPath = getWatchFilesystemByPath;
+/**
+ * Stream process logs in real time via WebSocket
+ * Streams the stdout and stderr output of a process in real time as JSON messages.
+ */
+const getWsProcessByIdentifierLogsStream = (options) => {
+    return (options.client ?? client_gen_1.client).get({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/ws/process/{identifier}/logs/stream',
+        ...options
+    });
+};
+exports.getWsProcessByIdentifierLogsStream = getWsProcessByIdentifierLogsStream;
+/**
+ * Stream file modification events in a directory via WebSocket
+ * Streams JSON events of modified files in the given directory. Closes when the client disconnects.
+ */
+const getWsWatchFilesystemByPath = (options) => {
+    return (options.client ?? client_gen_1.client).get({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/ws/watch/filesystem/{path}',
+        ...options
+    });
+};
+exports.getWsWatchFilesystemByPath = getWsWatchFilesystemByPath;

package/dist/cjs-browser/sandbox/client/types.gen.js

@@ -0,0 +1,3 @@
+"use strict";
+// This file is auto-generated by @hey-api/openapi-ts
+Object.defineProperty(exports, "__esModule", { value: true });