@blaxel/core 0.2.49-dev.214 → 0.2.49-dev1

package/dist/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/models/index.d.ts

@@ -0,0 +1,8 @@
+import { Model } from "../client/types.gen.js";
+export declare class BLModel {
+    modelName: string;
+    options?: Record<string, unknown>;
+    constructor(modelName: string, options?: Record<string, unknown>);
+}
+export declare const blModel: (modelName: string, options?: Record<string, unknown>) => BLModel;
+export declare const getModelMetadata: (model: string) => Promise<Model | null>;

package/dist/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/sandbox/action.d.ts

@@ -0,0 +1,19 @@
+import { SandboxConfiguration } from "./types.js";
+export declare class ResponseError extends Error {
+    response: Response;
+    data: unknown;
+    error: unknown;
+    constructor(response: Response, data: unknown, error: unknown);
+}
+export declare class SandboxAction {
+    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 | import("url").URL | null;
+    get url(): string;
+    handleResponseError(response: Response, data: unknown, error: unknown): void;
+}

package/dist/sandbox/action.js

@@ -0,0 +1,84 @@
+"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 `${settings_js_1.settings.runUrl}/${settings_js_1.settings.workspace}/sandboxes/${this.name}`;
+    }
+    get internalUrl() {
+        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;
+        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/sandbox/client/client.gen.d.ts

@@ -0,0 +1,12 @@
+import type { ClientOptions } from './types.gen';
+import { type Config, type ClientOptions as DefaultClientOptions } from '@hey-api/client-fetch';
+/**
+ * The `createClientConfig()` function will be called on client initialization
+ * and the returned object will become the client's initial configuration.
+ *
+ * You may want to initialize your client this way instead of calling
+ * `setConfig()`. This is useful for example if you're using Next.js
+ * to ensure your client always has the correct values.
+ */
+export type CreateClientConfig<T extends DefaultClientOptions = ClientOptions> = (override?: Config<DefaultClientOptions & T>) => Config<Required<DefaultClientOptions> & T>;
+export declare const client: import("@hey-api/client-fetch").Client;

package/dist/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/sandbox/client/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types.gen.js';
+export * from './sdk.gen.js';

package/dist/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/sandbox/client/sdk.gen.d.ts

@@ -0,0 +1,101 @@
+import type { Options as ClientOptions, TDataShape, Client } from '@hey-api/client-fetch';
+import type { DeleteFilesystemByPathData, GetFilesystemByPathData, PutFilesystemByPathData, DeleteNetworkProcessByPidMonitorData, PostNetworkProcessByPidMonitorData, GetNetworkProcessByPidPortsData, GetProcessData, PostProcessData, DeleteProcessByIdentifierData, GetProcessByIdentifierData, DeleteProcessByIdentifierKillData, GetProcessByIdentifierLogsData, GetProcessByIdentifierLogsStreamData, GetWatchFilesystemByPathData, GetWsProcessByIdentifierLogsStreamData, GetWsWatchFilesystemByPathData } from './types.gen';
+export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean> = ClientOptions<TData, ThrowOnError> & {
+    /**
+     * You can provide a client instance returned by `createClient()` instead of
+     * individual options. This might be also useful if you want to implement a
+     * custom client.
+     */
+    client?: Client;
+    /**
+     * You can pass arbitrary values through the `meta` object. This can be
+     * used to access values that aren't defined as part of the SDK function.
+     */
+    meta?: Record<string, unknown>;
+};
+/**
+ * Delete file or directory
+ * Delete a file or directory
+ */
+export declare const deleteFilesystemByPath: <ThrowOnError extends boolean = false>(options: Options<DeleteFilesystemByPathData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").SuccessResponse, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * Get file or directory information
+ * Get content of a file or listing of a directory
+ */
+export declare const getFilesystemByPath: <ThrowOnError extends boolean = false>(options: Options<GetFilesystemByPathData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").Directory | import("./types.gen").FileWithContent, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * Create or update a file or directory
+ * Create or update a file or directory
+ */
+export declare const putFilesystemByPath: <ThrowOnError extends boolean = false>(options: Options<PutFilesystemByPathData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").SuccessResponse, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * Stop monitoring ports for a process
+ * Stop monitoring for new ports opened by a process
+ */
+export declare const deleteNetworkProcessByPidMonitor: <ThrowOnError extends boolean = false>(options: Options<DeleteNetworkProcessByPidMonitorData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<{
+    [key: string]: unknown;
+}, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * Start monitoring ports for a process
+ * Start monitoring for new ports opened by a process
+ */
+export declare const postNetworkProcessByPidMonitor: <ThrowOnError extends boolean = false>(options: Options<PostNetworkProcessByPidMonitorData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<{
+    [key: string]: unknown;
+}, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * Get open ports for a process
+ * Get a list of all open ports for a process
+ */
+export declare const getNetworkProcessByPidPorts: <ThrowOnError extends boolean = false>(options: Options<GetNetworkProcessByPidPortsData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<{
+    [key: string]: unknown;
+}, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * List all processes
+ * Get a list of all running and completed processes
+ */
+export declare const getProcess: <ThrowOnError extends boolean = false>(options?: Options<GetProcessData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").ProcessResponse[], unknown, ThrowOnError>;
+/**
+ * Execute a command
+ * Execute a command and return process information
+ */
+export declare const postProcess: <ThrowOnError extends boolean = false>(options: Options<PostProcessData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").ProcessResponse, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * Stop a process
+ * Gracefully stop a running process
+ */
+export declare const deleteProcessByIdentifier: <ThrowOnError extends boolean = false>(options: Options<DeleteProcessByIdentifierData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").SuccessResponse, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * Get process by identifier
+ * Get information about a process by its PID or name
+ */
+export declare const getProcessByIdentifier: <ThrowOnError extends boolean = false>(options: Options<GetProcessByIdentifierData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").ProcessResponse, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * Kill a process
+ * Forcefully kill a running process
+ */
+export declare const deleteProcessByIdentifierKill: <ThrowOnError extends boolean = false>(options: Options<DeleteProcessByIdentifierKillData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").SuccessResponse, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * Get process logs
+ * Get the stdout and stderr output of a process
+ */
+export declare const getProcessByIdentifierLogs: <ThrowOnError extends boolean = false>(options: Options<GetProcessByIdentifierLogsData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").ProcessLogs, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * 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.
+ */
+export declare const getProcessByIdentifierLogsStream: <ThrowOnError extends boolean = false>(options: Options<GetProcessByIdentifierLogsStreamData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<string, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * 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.
+ */
+export declare const getWatchFilesystemByPath: <ThrowOnError extends boolean = false>(options: Options<GetWatchFilesystemByPathData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<string, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * Stream process logs in real time via WebSocket
+ * Streams the stdout and stderr output of a process in real time as JSON messages.
+ */
+export declare const getWsProcessByIdentifierLogsStream: <ThrowOnError extends boolean = false>(options: Options<GetWsProcessByIdentifierLogsStreamData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<unknown, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * Stream file modification events in a directory via WebSocket
+ * Streams JSON events of modified files in the given directory. Closes when the client disconnects.
+ */
+export declare const getWsWatchFilesystemByPath: <ThrowOnError extends boolean = false>(options: Options<GetWsWatchFilesystemByPathData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<unknown, import("./types.gen").ErrorResponse, ThrowOnError>;