@blaxel/core 0.2.0-preview3 → 0.2.0-preview4

package/dist/client/sdk.gen.d.ts

@@ -70,7 +70,7 @@ export declare const listFunctionRevisions: <ThrowOnError extends boolean = fals
  * List integrations connections
  * Returns integration information by name.
  */
-export declare const getIntegration: <ThrowOnError extends boolean = false>(options: Options<GetIntegrationData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<unknown, unknown, ThrowOnError>;
+export declare const getIntegration: <ThrowOnError extends boolean = false>(options: Options<GetIntegrationData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen.js").Integration, unknown, ThrowOnError>;
 /**
  * List integrations connections
  * Returns a list of all connections integrations in the workspace.

package/dist/client/types.gen.d.ts

@@ -419,6 +419,32 @@ export type HistogramStats = {
      */
     p99?: number;
 };
+/**
+ * Integration
+ */
+export type Integration = {
+    /**
+     * Integration additional infos
+     */
+    additionalInfos?: {
+        [key: string]: string;
+    };
+    endpoints?: IntegrationEndpoints;
+    headers?: IntegrationHeaders;
+    /**
+     * Integration name
+     */
+    name?: string;
+    /**
+     * Integration organizations
+     */
+    organizations?: Array<IntegrationOrganization>;
+    params?: IntegrationQueryParams;
+    /**
+     * Integration repositories
+     */
+    repositories?: Array<IntegrationRepository>;
+};
 /**
  * Integration Connection
  */
@@ -452,6 +478,62 @@ export type IntegrationConnectionSpec = {
     };
 };
 export type IntegrationConnectionsList = Array<string>;
+/**
+ * Integration endpoint
+ */
+export type IntegrationEndpoint = {
+    /**
+     * Integration endpoint body
+     */
+    body?: string;
+    /**
+     * Integration endpoint ignore models
+     */
+    ignoreModels?: Array<unknown>;
+    /**
+     * Integration endpoint method
+     */
+    method?: string;
+    /**
+     * Integration endpoint models
+     */
+    models?: Array<unknown>;
+    /**
+     * Integration endpoint stream key
+     */
+    streamKey?: string;
+    streamToken?: IntegrationEndpointToken;
+    token?: IntegrationEndpointToken;
+};
+/**
+ * Integration endpoint token
+ */
+export type IntegrationEndpointToken = {
+    /**
+     * Integration endpoint token received
+     */
+    received?: string;
+    /**
+     * Integration endpoint token sent
+     */
+    sent?: string;
+    /**
+     * Integration endpoint token total
+     */
+    total?: string;
+};
+/**
+ * Integration endpoints
+ */
+export type IntegrationEndpoints = {
+    [key: string]: IntegrationEndpoint;
+};
+/**
+ * Integration headers
+ */
+export type IntegrationHeaders = {
+    [key: string]: string;
+};
 /**
  * Model obtained from an external authentication provider, such as HuggingFace, OpenAI, etc...
  */
@@ -505,6 +587,33 @@ export type IntegrationModel = {
      */
     trending_score?: number;
 };
+/**
+ * Integration organization
+ */
+export type IntegrationOrganization = {
+    /**
+     * Provider organization avatar URL
+     */
+    avatar_url?: string;
+    /**
+     * Provider organization display name
+     */
+    displayName?: string;
+    /**
+     * Provider organization ID
+     */
+    id?: string;
+    /**
+     * Provider organization name
+     */
+    name?: string;
+};
+/**
+ * Integration query params
+ */
+export type IntegrationQueryParams = {
+    [key: string]: string;
+};
 /**
  * Integration repository
  */
@@ -1109,6 +1218,10 @@ export type PreviewSpec = {
      * Port of the preview
      */
     port?: number;
+    /**
+     * Prefix URL
+     */
+    prefixUrl?: string;
     /**
      * Whether the preview is public
      */
@@ -1162,10 +1275,6 @@ export type PreviewTokenSpec = {
      * Expiration time of the token
      */
     expiresAt?: string;
-    /**
-     * Whether the token is public
-     */
-    public?: boolean;
     /**
      * Token
      */
@@ -1625,18 +1734,6 @@ export type SandboxSpec = CoreSpec & unknown;
  * Name of a Sandbox definition
  */
 export type SandboxStoreDefinitionName = unknown;
-/**
- * Micro VM for running agentic tasks
- */
-export type Sandboxes = {
-    events?: CoreEvents;
-    metadata?: Metadata;
-    spec?: SandboxSpec;
-    /**
-     * Sandbox status
-     */
-    status?: string;
-};
 /**
  * Configuration for a serverless deployment
  */
@@ -2290,8 +2387,9 @@ export type GetIntegrationResponses = {
     /**
      * successful operation
      */
-    200: unknown;
+    200: Integration;
 };
+export type GetIntegrationResponse = GetIntegrationResponses[keyof GetIntegrationResponses];
 export type ListIntegrationConnectionsData = {
     body?: never;
     path?: never;

package/dist/common/env.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.env = void 0;
 /* eslint-disable */
+const dotenv_1 = __importDefault(require("dotenv"));
 const toml_1 = __importDefault(require("toml"));
 const node_js_1 = require("./node.js");
 const secretEnv = {};
@@ -20,13 +21,8 @@ if (node_js_1.fs !== null) {
     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;
-        });
+        const parsed = dotenv_1.default.parse(secretFile);
+        Object.assign(secretEnv, parsed);
     }
     catch (error) { }
 }

package/dist/mcp/server/http.d.ts

@@ -0,0 +1,8 @@
+import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
+export declare class BlaxelHttpMcpServerTransport implements Transport {
+    private server;
+    constructor(port: number);
+    start(): Promise<void>;
+    send(msg: JSONRPCMessage): Promise<void>;
+}

package/dist/mcp/server/http.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlaxelHttpMcpServerTransport = void 0;
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+class BlaxelHttpMcpServerTransport {
+    server;
+    constructor(port) {
+        this.server = new streamableHttp_js_1.StreamableHTTPServerTransport({ port });
+    }
+    async start() {
+        await this.server.start();
+    }
+    async send(msg) {
+    }
+}
+exports.BlaxelHttpMcpServerTransport = BlaxelHttpMcpServerTransport;

package/dist/mcp/server/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./http.js";
+export * from "./websocket.js";
+import { BlaxelWebsocketMcpServerTransport } from "./websocket.js";
+export declare const BlaxelMcpServerTransport: typeof BlaxelWebsocketMcpServerTransport;

package/dist/mcp/server/index.js

@@ -0,0 +1,21 @@
+"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 });
+exports.BlaxelMcpServerTransport = void 0;
+__exportStar(require("./http.js"), exports);
+__exportStar(require("./websocket.js"), exports);
+const websocket_js_1 = require("./websocket.js");
+exports.BlaxelMcpServerTransport = websocket_js_1.BlaxelWebsocketMcpServerTransport;

package/dist/mcp/server/websocket.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 BlaxelWebsocketMcpServerTransport 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 {};

package/dist/mcp/server/websocket.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.BlaxelWebsocketMcpServerTransport = 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 BlaxelWebsocketMcpServerTransport {
+    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.BlaxelWebsocketMcpServerTransport = BlaxelWebsocketMcpServerTransport;

package/dist/sandbox/client/sdk.gen.d.ts

@@ -22,7 +22,7 @@ export declare const deleteFilesystemByPath: <ThrowOnError extends boolean = fal
  * 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").FileWithContent | import("./types.gen").Directory, import("./types.gen").ErrorResponse, ThrowOnError>;
+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 file or directory
  * Create or update a file or directory

package/dist/sandbox/client/types.gen.d.ts

@@ -1,3 +1,11 @@
+export type Directory = {
+    files?: Array<File>;
+    path?: string;
+    /**
+     * @name Subdirectories
+     */
+    subdirectories?: Array<Subdirectory>;
+};
 export type ErrorResponse = {
     error?: string;
 };
@@ -6,9 +14,6 @@ export type File = {
     lastModified?: string;
     owner?: string;
     path?: string;
-    /**
-     * swagger:strfmt string
-     */
     permissions?: string;
     size?: number;
 };
@@ -23,9 +28,6 @@ export type FileWithContent = {
     lastModified?: string;
     owner?: string;
     path?: string;
-    /**
-     * swagger:strfmt string
-     */
     permissions?: string;
     size?: number;
 };
@@ -57,17 +59,12 @@ export type ProcessResponse = {
     status?: string;
     workingDir?: string;
 };
-export type SuccessResponse = {
-    message?: string;
+export type Subdirectory = {
     path?: string;
 };
-export type Directory = {
-    files?: Array<File>;
+export type SuccessResponse = {
+    message?: string;
     path?: string;
-    /**
-     * @name Subdirectories
-     */
-    subdirectories?: Array<Directory>;
 };
 export type DeleteFilesystemByPathData = {
     body?: never;

package/dist/sandbox/filesystem.js

@@ -112,6 +112,9 @@ class SandboxFileSystem extends action_js_1.SandboxAction {
         throw new Error("Unsupported file type");
     }
     formatPath(path) {
+        if (path === "/") {
+            return path;
+        }
         if (path.startsWith("/")) {
             path = path.slice(1);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blaxel/core",
-  "version": "0.2.0-preview3",
+  "version": "0.2.0-preview4",
   "description": "Blaxel Core SDK for TypeScript",
   "license": "MIT",
   "author": "Blaxel, INC (https://blaxel.ai)",
@@ -56,6 +56,7 @@
     "@hey-api/client-fetch": "^0.10.0",
     "@modelcontextprotocol/sdk": "^1.11.0",
     "crypto": "^1.0.1",
+    "dotenv": "^16.5.0",
     "jwt-decode": "^4.0.0",
     "toml": "^3.0.0",
     "uuid": "^11.1.0",
@@ -71,6 +72,7 @@
   },
   "scripts": {
     "lint": "eslint src/",
+    "dev": "tsc --watch",
     "build": "tsc"
   }
 }