@blaxel/core 0.2.0-dev1

package/dist/client/types.gen.js

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

package/dist/common/autoload.d.ts

@@ -0,0 +1,3 @@
+import { Config } from "./settings.js";
+export declare function initialize(config: Config): void;
+export declare function authenticate(): Promise<void>;

package/dist/common/autoload.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initialize = initialize;
+exports.authenticate = authenticate;
+const client_gen_js_1 = require("../client/client.gen.js");
+const interceptors_js_1 = require("../client/interceptors.js");
+const client_gen_js_2 = require("../sandbox/client/client.gen.js");
+const settings_js_1 = require("./settings.js");
+client_gen_js_1.client.setConfig({
+    baseUrl: settings_js_1.settings.baseUrl,
+});
+for (const interceptor of interceptors_js_1.interceptors) {
+    // @ts-expect-error - Interceptor is not typed
+    client_gen_js_1.client.interceptors.request.use(interceptor);
+    // @ts-expect-error - Interceptor is not typed
+    client_gen_js_2.client.interceptors.request.use(interceptor);
+}
+// Allow to set custom configuration for browser environment
+function initialize(config) {
+    settings_js_1.settings.setConfig(config);
+    client_gen_js_1.client.setConfig({
+        baseUrl: settings_js_1.settings.baseUrl,
+    });
+}
+function authenticate() {
+    return settings_js_1.settings.authenticate();
+}

package/dist/common/env.d.ts

@@ -0,0 +1,5 @@
+type EnvVariables = {
+    [key: string]: string | undefined;
+};
+declare const env: EnvVariables;
+export { env };

package/dist/common/env.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.env = void 0;
+const toml_1 = __importDefault(require("toml"));
+const node_js_1 = require("./node.js");
+const secretEnv = {};
+const configEnv = {};
+if (node_js_1.fs !== null) {
+    try {
+        const configFile = node_js_1.fs.readFileSync("blaxel.toml", "utf8");
+        const configInfos = toml_1.default.parse(configFile);
+        for (const key in configInfos.env) {
+            configEnv[key] = configInfos.env[key];
+        }
+    }
+    catch (error) { }
+    try {
+        const secretFile = node_js_1.fs.readFileSync(".env", "utf8");
+        secretFile.split("\n").forEach((line) => {
+            if (line.startsWith("#")) {
+                return;
+            }
+            const [key, value] = line.split("=");
+            secretEnv[key] = value;
+        });
+    }
+    catch (error) { }
+}
+const env = new Proxy({}, {
+    get: (target, prop) => {
+        if (secretEnv[prop]) {
+            return secretEnv[prop];
+        }
+        if (configEnv[prop]) {
+            return configEnv[prop];
+        }
+        return process.env[prop];
+    },
+});
+exports.env = env;

package/dist/common/errors.d.ts

@@ -0,0 +1 @@
+export declare function handleDynamicImportError(err: any): void;

package/dist/common/errors.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleDynamicImportError = handleDynamicImportError;
+function handleDynamicImportError(err) {
+    if (err instanceof Error) {
+        // We check if it's module import error and retrieve package name from the error message with a regex
+        if (err.message.includes("Cannot find module")) {
+            const packageName = err.message.match(/Cannot find module '([^']+)'/)?.[1];
+            if (packageName) {
+                err.message = `Dependency not found. Please run one of the following commands to install it:
+- npm: 'npm install ${packageName}'
+- yarn: 'yarn add ${packageName}'
+- pnpm: 'pnpm add ${packageName}'`;
+            }
+        }
+    }
+}

package/dist/common/internal.d.ts

@@ -0,0 +1,2 @@
+export declare function getAlphanumericLimitedHash(input: string, maxSize: number): string;
+export declare function getGlobalUniqueHash(workspace: string, type: string, name: string): string;

package/dist/common/internal.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAlphanumericLimitedHash = getAlphanumericLimitedHash;
+exports.getGlobalUniqueHash = getGlobalUniqueHash;
+const crypto_1 = __importDefault(require("crypto"));
+function getAlphanumericLimitedHash(input, maxSize) {
+    const hash = crypto_1.default.createHash("sha256").update(input).digest("base64");
+    const alphanumeric = hash.replace(/[^a-z0-9]+/g, "");
+    return alphanumeric.length > maxSize
+        ? alphanumeric.substring(0, maxSize)
+        : alphanumeric;
+}
+function getGlobalUniqueHash(workspace, type, name) {
+    const globalUniqueName = `${workspace}-${type}-${name}`;
+    return getAlphanumericLimitedHash(globalUniqueName, 48);
+}

package/dist/common/logger.d.ts

@@ -0,0 +1 @@
+export declare const logger: Console;

package/dist/common/logger.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+exports.logger = console;

package/dist/common/node.d.ts

@@ -0,0 +1,3 @@
+declare let fs: any;
+declare let os: any;
+export { fs, os };

package/dist/common/node.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.os = exports.fs = void 0;
+const isNode = typeof process !== "undefined" &&
+    process.versions != null &&
+    process.versions.node != null;
+let fs = null;
+exports.fs = fs;
+let os = null;
+exports.os = os;
+if (isNode) {
+    exports.fs = fs = require("fs");
+    exports.os = os = require("os");
+}

package/dist/common/settings.d.ts

@@ -0,0 +1,26 @@
+import { Credentials } from "../authentication/credentials.js";
+export type Config = {
+    proxy?: string;
+    apikey?: string;
+    workspace?: string;
+};
+declare class Settings {
+    credentials: Credentials;
+    config: Config;
+    constructor();
+    setConfig(config: Config): void;
+    get env(): string;
+    get baseUrl(): string;
+    get runUrl(): string;
+    get workspace(): string;
+    get authorization(): string;
+    get token(): string;
+    get headers(): Record<string, string>;
+    get name(): string;
+    get type(): string;
+    get runInternalHostname(): string;
+    get runInternalProtocol(): string;
+    authenticate(): Promise<void>;
+}
+export declare const settings: Settings;
+export {};

package/dist/common/settings.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.settings = void 0;
+const index_js_1 = require("../authentication/index.js");
+const env_js_1 = require("../common/env.js");
+class Settings {
+    credentials;
+    config;
+    constructor() {
+        this.credentials = (0, index_js_1.authentication)();
+        this.config = {
+            proxy: "",
+            apikey: "",
+            workspace: "",
+        };
+    }
+    setConfig(config) {
+        this.config = config;
+    }
+    get env() {
+        return env_js_1.env.BL_ENV || "prod";
+    }
+    get baseUrl() {
+        if (this.config.proxy) {
+            return this.config.proxy + "/api";
+        }
+        if (env_js_1.env.BL_API_URL) {
+            return env_js_1.env.BL_API_URL;
+        }
+        if (this.env === "prod") {
+            return "https://api.blaxel.ai/v0";
+        }
+        return "https://api.blaxel.dev/v0";
+    }
+    get runUrl() {
+        if (this.config.proxy) {
+            return this.config.proxy + "/run";
+        }
+        if (env_js_1.env.BL_RUN_URL) {
+            return env_js_1.env.BL_RUN_URL;
+        }
+        if (this.env === "prod") {
+            return "https://run.blaxel.ai";
+        }
+        return "https://run.blaxel.dev";
+    }
+    get workspace() {
+        return this.config.workspace || this.credentials.workspace || "";
+    }
+    get authorization() {
+        if (this.config.apikey) {
+            return 'Bearer ' + this.token;
+        }
+        return this.credentials.authorization;
+    }
+    get token() {
+        if (this.config.apikey) {
+            return this.config.apikey;
+        }
+        return this.credentials.token;
+    }
+    get headers() {
+        return {
+            "x-blaxel-authorization": this.authorization,
+            "x-blaxel-workspace": this.workspace || "",
+        };
+    }
+    get name() {
+        return env_js_1.env.BL_NAME || "";
+    }
+    get type() {
+        return env_js_1.env.BL_TYPE || "agents";
+    }
+    get runInternalHostname() {
+        return env_js_1.env.BL_RUN_INTERNAL_HOSTNAME || "";
+    }
+    get runInternalProtocol() {
+        return env_js_1.env.BL_RUN_INTERNAL_PROTOCOL || "https";
+    }
+    async authenticate() {
+        await this.credentials.authenticate();
+    }
+}
+exports.settings = new Settings();

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import './common/autoload';
+export * from "./agents/index.js";
+export * from "./client/client.js";
+export * from "./common/autoload.js";
+export * from "./common/env.js";
+export * from "./common/errors.js";
+export * from "./common/internal.js";
+export * from "./common/logger.js";
+export * from "./common/settings.js";
+export * from "./mcp/index.js";
+export * from "./models/index.js";
+export * from "./sandbox/index.js";
+export * from "./tools/index.js";
+export * from "./tools/types.js";

package/dist/index.js

@@ -0,0 +1,30 @@
+"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/errors.js"), exports);
+__exportStar(require("./common/internal.js"), exports);
+__exportStar(require("./common/logger.js"), exports);
+__exportStar(require("./common/settings.js"), exports);
+__exportStar(require("./mcp/index.js"), exports);
+__exportStar(require("./models/index.js"), exports);
+__exportStar(require("./sandbox/index.js"), exports);
+__exportStar(require("./tools/index.js"), exports);
+__exportStar(require("./tools/types.js"), exports);

package/dist/mcp/client.d.ts

@@ -0,0 +1,19 @@
+import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
+/**
+ * Client transport for WebSocket: this will connect to a server over the WebSocket protocol.
+ */
+export declare class BlaxelMcpClientTransport implements Transport {
+    private _socket?;
+    private _url;
+    private _headers;
+    onclose?: () => void;
+    onerror?: (error: Error) => void;
+    onmessage?: (message: JSONRPCMessage) => void;
+    constructor(url: string, headers?: Record<string, string>);
+    start(): Promise<void>;
+    private _connect;
+    get isConnected(): boolean;
+    close(): Promise<void>;
+    send(message: JSONRPCMessage): Promise<void>;
+}

package/dist/mcp/client.js

@@ -0,0 +1,151 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlaxelMcpClientTransport = void 0;
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const ws_1 = __importDefault(require("ws"));
+const logger_js_1 = require("../common/logger.js");
+//const SUBPROTOCOL = "mcp";
+const MAX_RETRIES = 3;
+const RETRY_DELAY_MS = 1000;
+// 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.
+ */
+class BlaxelMcpClientTransport {
+    _socket;
+    _url;
+    _headers;
+    onclose;
+    onerror;
+    onmessage;
+    constructor(url, headers) {
+        this._url = new URL(url.replace("http", "ws"));
+        this._headers = headers ?? {};
+    }
+    async start() {
+        if (this._socket) {
+            throw new Error("Blaxel already started! If using Client class, note that connect() calls start() automatically.");
+        }
+        let attempts = 0;
+        while (attempts < MAX_RETRIES) {
+            try {
+                await this._connect();
+                return;
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    logger_js_1.logger.warn(error.stack);
+                }
+                attempts++;
+                if (attempts === MAX_RETRIES) {
+                    throw error;
+                }
+                logger_js_1.logger.debug(`WebSocket connection attempt ${attempts} failed, retrying in ${RETRY_DELAY_MS}ms...`);
+                await delay(RETRY_DELAY_MS);
+            }
+        }
+    }
+    _connect() {
+        return new Promise((resolve, reject) => {
+            this._socket = new ws_1.default(this._url, {
+                //protocols: SUBPROTOCOL,
+                headers: this._headers,
+            });
+            this._socket.onerror = (event) => {
+                const error = "error" in event
+                    ? event.error
+                    : new Error(`WebSocket error: ${JSON.stringify(event)}`);
+                reject(error);
+                this.onerror?.(error);
+            };
+            this._socket.onopen = () => {
+                logger_js_1.logger.debug("WebSocket opened");
+                resolve();
+            };
+            this._socket.onclose = () => {
+                logger_js_1.logger.debug("WebSocket closed");
+                this.onclose?.();
+                this._socket = undefined;
+            };
+            this._socket.onmessage = (event) => {
+                logger_js_1.logger.debug("WebSocket message received");
+                let message;
+                try {
+                    let dataString;
+                    if (typeof event.data === "string") {
+                        dataString = event.data;
+                    }
+                    else if (event.data instanceof Buffer) {
+                        dataString = event.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: ${typeof event.data === "object"
+                        ? JSON.stringify(event.data)
+                        : event.data}`);
+                    this.onerror?.(error);
+                    return;
+                }
+                this.onmessage?.(message);
+            };
+        });
+    }
+    get isConnected() {
+        return this._socket?.readyState === ws_1.default.OPEN;
+    }
+    async close() {
+        this._socket?.close();
+        this._socket = undefined;
+        this.onclose?.();
+        return Promise.resolve();
+    }
+    async send(message) {
+        let attempts = 0;
+        while (attempts < MAX_RETRIES) {
+            try {
+                if (!this._socket || this._socket.readyState !== ws_1.default.OPEN) {
+                    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 {
+                        this._socket?.send(JSON.stringify(message), (error) => {
+                            if (error) {
+                                reject(error);
+                            }
+                            else {
+                                resolve();
+                            }
+                        });
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
+                return;
+            }
+            catch (error) {
+                attempts++;
+                if (attempts === MAX_RETRIES) {
+                    throw error;
+                }
+                logger_js_1.logger.warn(`WebSocket send attempt ${attempts} failed, retrying in ${RETRY_DELAY_MS}ms...`);
+                await delay(RETRY_DELAY_MS);
+            }
+        }
+    }
+}
+exports.BlaxelMcpClientTransport = BlaxelMcpClientTransport;

package/dist/mcp/index.d.ts

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

package/dist/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);

package/dist/mcp/server.d.ts

@@ -0,0 +1,24 @@
+import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+interface JSONRPCMessage {
+    jsonrpc: "2.0";
+    id?: string | number;
+    method?: string;
+    params?: Record<string, unknown>;
+}
+export declare class BlaxelMcpServerTransport implements Transport {
+    private port;
+    private wss;
+    private clients;
+    onclose?: () => void;
+    onerror?: (err: Error) => void;
+    private messageHandler?;
+    onconnection?: (clientId: string) => void;
+    ondisconnection?: (clientId: string) => void;
+    set onmessage(handler: ((message: JSONRPCMessage) => void) | undefined);
+    constructor(port?: number);
+    start(): Promise<void>;
+    send(msg: JSONRPCMessage): Promise<void>;
+    broadcast(msg: JSONRPCMessage): Promise<void>;
+    close(): Promise<void>;
+}
+export {};