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

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

@@ -0,0 +1,45 @@
+"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 });
+const vitest_1 = require("vitest");
+// Import your SDK entry point or a function to test
+const sdk = __importStar(require("./index"));
+(0, vitest_1.describe)('SDK Browser Integration', () => {
+    (0, vitest_1.it)('should load the SDK without Node.js-only modules', () => {
+        // Example: check that SDK loads and a function exists
+        (0, vitest_1.expect)(typeof sdk).toBe('object');
+        // Add more specific tests for your SDK as needed
+    });
+});

package/dist/cjs-browser/index.js

@@ -0,0 +1,34 @@
+"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 });
+require("./common/autoload");
+__exportStar(require("./agents/index.js"), exports);
+__exportStar(require("./client/client.js"), exports);
+__exportStar(require("./common/autoload.js"), exports);
+__exportStar(require("./common/env.js"), exports);
+__exportStar(require("./common/node.js"), exports);
+__exportStar(require("./common/errors.js"), exports);
+__exportStar(require("./common/internal.js"), exports);
+__exportStar(require("./common/logger.js"), exports);
+__exportStar(require("./common/settings.js"), exports);
+__exportStar(require("./jobs/index.js"), exports);
+__exportStar(require("./mcp/index.js"), exports);
+__exportStar(require("./models/index.js"), exports);
+__exportStar(require("./sandbox/index.js"), exports);
+__exportStar(require("./telemetry/telemetry.js"), exports);
+__exportStar(require("./tools/index.js"), exports);
+__exportStar(require("./tools/types.js"), exports);
+__exportStar(require("./volume/index.js"), exports);

package/dist/cjs-browser/jobs/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 });
+__exportStar(require("./jobs.js"), exports);
+__exportStar(require("./start.js"), exports);
+__exportStar(require("./types.js"), exports);

package/dist/cjs-browser/jobs/jobs.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blJob = void 0;
+const internal_js_1 = require("../common/internal.js");
+const logger_js_1 = require("../common/logger.js");
+const settings_js_1 = require("../common/settings.js");
+const telemetry_js_1 = require("../telemetry/telemetry.js");
+class BlJob {
+    jobName;
+    constructor(jobName) {
+        this.jobName = jobName;
+    }
+    get fallbackUrl() {
+        if (this.externalUrl != this.url) {
+            return this.externalUrl;
+        }
+        return null;
+    }
+    get externalUrl() {
+        return new URL(`${settings_js_1.settings.runUrl}/${settings_js_1.settings.workspace}/jobs/${this.jobName}`);
+    }
+    get internalUrl() {
+        const url = (0, internal_js_1.generateInternalUrl)(settings_js_1.settings.workspace, "job", this.jobName, 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);
+        return new URL(url);
+    }
+    get forcedUrl() {
+        return (0, internal_js_1.getForcedUrl)('job', this.jobName);
+    }
+    get url() {
+        if (this.forcedUrl)
+            return this.forcedUrl;
+        if (settings_js_1.settings.runInternalHostname)
+            return this.internalUrl;
+        return this.externalUrl;
+    }
+    async call(url, tasks) {
+        const body = {
+            tasks: tasks
+        };
+        const response = await fetch(url.toString() + "/executions", {
+            method: "POST",
+            headers: {
+                ...settings_js_1.settings.headers,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(body),
+        });
+        return response;
+    }
+    async run(tasks) {
+        logger_js_1.logger.debug(`Job Calling: ${this.jobName}`);
+        const span = (0, telemetry_js_1.startSpan)(this.jobName, {
+            attributes: {
+                "job.name": this.jobName,
+                "span.type": "job.run",
+            },
+            isRoot: false,
+        });
+        try {
+            const response = await this.call(this.url, tasks);
+            return await response.text();
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                if (!this.fallbackUrl) {
+                    span.setAttribute("job.run.error", err.stack);
+                    throw err;
+                }
+                try {
+                    const response = await this.call(this.fallbackUrl, tasks);
+                    return await response.text();
+                }
+                catch (err) {
+                    if (err instanceof Error) {
+                        span.setAttribute("job.run.error", err.stack);
+                    }
+                    throw err;
+                }
+            }
+            throw err;
+        }
+        finally {
+            span.end();
+        }
+    }
+}
+const blJob = (jobName) => {
+    return new BlJob(jobName);
+};
+exports.blJob = blJob;

package/dist/cjs-browser/jobs/start.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blStartJob = void 0;
+const autoload_js_1 = require("../common/autoload.js");
+const env_js_1 = require("../common/env.js");
+const telemetry_js_1 = require("../telemetry/telemetry.js");
+class BlJobWrapper {
+    async getArguments() {
+        if (!env_js_1.env.BL_EXECUTION_DATA_URL) {
+            const args = this.parseCommandLineArgs();
+            return args;
+        }
+        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";
+    }
+    get index() {
+        return env_js_1.env[this.indexKey] ? Number(env_js_1.env[this.indexKey]) : 0;
+    }
+    /*
+      Run a job defined in a function, it's run in the current process
+    */
+    async start(func) {
+        await (0, autoload_js_1.authenticate)();
+        const parsedArgs = await this.getArguments();
+        await func(parsedArgs);
+    }
+}
+const blStartJob = (func) => {
+    const job = new BlJobWrapper();
+    job.start(func).then(async () => {
+        try {
+            await (0, telemetry_js_1.flush)();
+        }
+        catch (error) {
+            console.error('Error flushing telemetry:', error);
+        }
+        process.exit(0);
+    }).catch((error) => {
+        console.error('Job execution failed:', error);
+        process.exit(1);
+    });
+};
+exports.blStartJob = blStartJob;

package/dist/cjs-browser/jobs/types.js

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

package/dist/cjs-browser/mcp/client.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlaxelMcpClientTransport = void 0;
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const logger_js_1 = require("../common/logger.js");
+const node_js_1 = require("../common/node.js");
+const settings_js_1 = require("../common/settings.js");
+// WebSocket will be loaded dynamically via getWebSocket() function
+//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.
+ */
+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 ?? {};
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        this._isBrowser = typeof globalThis !== "undefined" && (globalThis)?.window !== undefined;
+    }
+    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_js_1.logger.warn(error.stack ?? error.message);
+                }
+                if (attempts >= maxAttempts) {
+                    throw error;
+                }
+                logger_js_1.logger.debug(`WebSocket connection attempt ${attempts} failed, retrying in ${this._retry_delay}ms...`);
+                await delay(this._retry_delay);
+            }
+        }
+    }
+    async _connect() {
+        return new Promise((resolve, reject) => {
+            const setupConnection = async () => {
+                try {
+                    if (this._isBrowser) {
+                        // Use native browser WebSocket
+                        const url = `${this._url.toString()}?token=${settings_js_1.settings.token}`;
+                        this._socket = new WebSocket(url);
+                    }
+                    else {
+                        // Use Node.js WebSocket - get it via the centralized async function
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                        const NodeWebSocket = await (0, node_js_1.getWebSocket)();
+                        // 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_js_1.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 = types_js_1.JSONRPCMessageSchema.parse(JSON.parse(dataString));
+                        }
+                        catch (error) {
+                            logger_js_1.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);
+                }
+            };
+            setupConnection().catch(reject);
+        });
+    }
+    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_js_1.logger.warn(`WebSocket send attempt ${attempts} failed, retrying in ${this._retry_delay}ms...`);
+                await delay(this._retry_delay);
+            }
+        }
+    }
+}
+exports.BlaxelMcpClientTransport = BlaxelMcpClientTransport;

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

@@ -0,0 +1,18 @@
+"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 });
+__exportStar(require("./client.js"), exports);
+__exportStar(require("./server.js"), exports);