@blaxel/core 0.2.0-preview3 → 0.2.0-preview5

package/dist/jobs/jobs.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blJob = void 0;
+const yargs_1 = __importDefault(require("yargs"));
+const helpers_1 = require("yargs/helpers");
+const env_js_1 = require("../common/env.js");
+class BlJob {
+    async getArguments() {
+        if (!env_js_1.env.BL_EXECUTION_DATA_URL) {
+            const argv = await (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
+                .parseAsync();
+            return argv;
+        }
+        const response = await fetch(env_js_1.env.BL_EXECUTION_DATA_URL);
+        const data = await response.json();
+        return data.tasks[this.index] ?? {};
+    }
+    get indexKey() {
+        return env_js_1.env.BL_EXECUTION_INDEX_KEY ?? "TASK_INDEX";
+    }
+    get index() {
+        return env_js_1.env[this.indexKey] ? Number(env_js_1.env[this.indexKey]) ?? 0 : 0;
+    }
+    /*
+      Run a job defined in a function, it's run in the current process
+    */
+    async start(func) {
+        try {
+            const parsedArgs = await this.getArguments();
+            await func(parsedArgs);
+            process.exit(0);
+        }
+        catch (error) {
+            console.error('Job execution failed:', error);
+            process.exit(1);
+        }
+    }
+}
+exports.blJob = new BlJob();

package/dist/mcp/client.js

@@ -63,16 +63,13 @@ class BlaxelMcpClientTransport {
                 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;

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

@@ -1,4 +1,4 @@
-import { Sandbox } from "../client/index.js";
+import { SandboxConfiguration } from "./types.js";
 export declare class ResponseError extends Error {
     response: Response;
     data: unknown;
@@ -6,12 +6,13 @@ export declare class ResponseError extends Error {
     constructor(response: Response, data: unknown, error: unknown);
 }
 export declare class SandboxAction {
-    private sandbox;
-    constructor(sandbox: Sandbox);
+    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 | null;
     get url(): string;
     handleResponseError(response: Response, data: unknown, error: unknown): void;

package/dist/sandbox/action.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SandboxAction = exports.ResponseError = void 0;
+const client_fetch_1 = require("@hey-api/client-fetch");
 const process_1 = require("process");
 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;
@@ -50,7 +52,18 @@ class SandboxAction {
         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;
         const envVar = this.name.replace(/-/g, "_").toUpperCase();
         const envName = `BL_SANDBOX_${envVar}_URL`;
         if (process_1.env[envName]) {
@@ -61,8 +74,9 @@ class SandboxAction {
     get url() {
         if (this.forcedUrl)
             return this.forcedUrl;
-        if (settings_js_1.settings.runInternalHostname)
-            return this.internalUrl;
+        // 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) {

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

@@ -1,5 +1,5 @@
 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 } from './types.gen';
+import type { DeleteFilesystemByPathData, GetFilesystemByPathData, PutFilesystemByPathData, DeleteNetworkProcessByPidMonitorData, PostNetworkProcessByPidMonitorData, GetNetworkProcessByPidPortsData, GetProcessData, PostProcessData, DeleteProcessByIdentifierData, GetProcessByIdentifierData, DeleteProcessByIdentifierKillData, GetProcessByIdentifierLogsData, GetProcessByIdentifierLogsStreamData, GetWatchFilesystemByPathData } 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
@@ -82,9 +82,12 @@ export declare const getProcessByIdentifierLogs: <ThrowOnError extends boolean =
     [key: string]: string;
 }, import("./types.gen").ErrorResponse, ThrowOnError>;
 /**
- * Get process logs in realtime
- * Get the stdout and stderr output of a process in realtime
+ * 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<{
-    [key: string]: string;
-}, import("./types.gen").ErrorResponse, ThrowOnError>;
+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>;

package/dist/sandbox/client/sdk.gen.js

@@ -1,7 +1,7 @@
 "use strict";
 // This file is auto-generated by @hey-api/openapi-ts
 Object.defineProperty(exports, "__esModule", { value: true });
-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;
+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
@@ -152,8 +152,8 @@ const getProcessByIdentifierLogs = (options) => {
 };
 exports.getProcessByIdentifierLogs = getProcessByIdentifierLogs;
 /**
- * Get process logs in realtime
- * Get the stdout and stderr output of a process in realtime
+ * 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({
@@ -162,3 +162,14 @@ const getProcessByIdentifierLogsStream = (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({
+        url: '/watch/filesystem/{path}',
+        ...options
+    });
+};
+exports.getWatchFilesystemByPath = getWatchFilesystemByPath;

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

@@ -41,7 +41,6 @@ export type ProcessKillRequest = {
 export type ProcessRequest = {
     command: string;
     name?: string;
-    streamLogs?: boolean;
     timeout?: number;
     waitForCompletion?: boolean;
     waitForPorts?: Array<number>;
@@ -394,12 +393,7 @@ export type GetProcessByIdentifierLogsData = {
          */
         identifier: string;
     };
-    query?: {
-        /**
-         * Stream logs
-         */
-        stream?: boolean;
-    };
+    query?: never;
     url: '/process/{identifier}/logs';
 };
 export type GetProcessByIdentifierLogsErrors = {
@@ -430,12 +424,7 @@ export type GetProcessByIdentifierLogsStreamData = {
          */
         identifier: string;
     };
-    query?: {
-        /**
-         * Stream logs
-         */
-        stream?: boolean;
-    };
+    query?: never;
     url: '/process/{identifier}/logs/stream';
 };
 export type GetProcessByIdentifierLogsStreamErrors = {
@@ -451,13 +440,40 @@ export type GetProcessByIdentifierLogsStreamErrors = {
 export type GetProcessByIdentifierLogsStreamError = GetProcessByIdentifierLogsStreamErrors[keyof GetProcessByIdentifierLogsStreamErrors];
 export type GetProcessByIdentifierLogsStreamResponses = {
     /**
-     * Process logs
+     * Stream of process logs, one line per log (prefixed with stdout:/stderr:)
      */
-    200: {
-        [key: string]: string;
-    };
+    200: string;
 };
 export type GetProcessByIdentifierLogsStreamResponse = GetProcessByIdentifierLogsStreamResponses[keyof GetProcessByIdentifierLogsStreamResponses];
+export type GetWatchFilesystemByPathData = {
+    body?: never;
+    path: {
+        /**
+         * Directory path to watch
+         */
+        path: string;
+    };
+    query?: never;
+    url: '/watch/filesystem/{path}';
+};
+export type GetWatchFilesystemByPathErrors = {
+    /**
+     * Invalid path
+     */
+    400: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+};
+export type GetWatchFilesystemByPathError = GetWatchFilesystemByPathErrors[keyof GetWatchFilesystemByPathErrors];
+export type GetWatchFilesystemByPathResponses = {
+    /**
+     * Stream of modified file paths, one per line
+     */
+    200: string;
+};
+export type GetWatchFilesystemByPathResponse = GetWatchFilesystemByPathResponses[keyof GetWatchFilesystemByPathResponses];
 export type ClientOptions = {
     baseUrl: `${string}://localhost:8080` | (string & {});
 };

package/dist/sandbox/filesystem.d.ts

@@ -14,5 +14,11 @@ export declare class SandboxFileSystem extends SandboxAction {
     rm(path: string, recursive?: boolean): Promise<SuccessResponse>;
     ls(path: string): Promise<Directory>;
     cp(source: string, destination: string): Promise<CopyResponse>;
+    watch(path: string, callback: (filePath: string, content?: string) => void | Promise<void>, options?: {
+        onError?: (error: Error) => void;
+        withContent: boolean;
+    }): {
+        close: () => void;
+    };
     private formatPath;
 }