@blaxel/core 0.2.0-preview5 → 0.2.1-dev.46

package/dist/sandbox/filesystem.js

@@ -13,7 +13,6 @@ class SandboxFileSystem extends action_js_1.SandboxAction {
             path: { path },
             body: { isDirectory: true, permissions },
             baseUrl: this.url,
-            client: this.client,
         });
         this.handleResponseError(response, data, error);
         return data;
@@ -24,7 +23,6 @@ class SandboxFileSystem extends action_js_1.SandboxAction {
             path: { path },
             body: { content },
             baseUrl: this.url,
-            client: this.client,
         });
         this.handleResponseError(response, data, error);
         return data;
@@ -34,7 +32,6 @@ class SandboxFileSystem extends action_js_1.SandboxAction {
         const { response, data, error } = await (0, index_js_1.getFilesystemByPath)({
             path: { path },
             baseUrl: this.url,
-            client: this.client,
         });
         this.handleResponseError(response, data, error);
         if (data && 'content' in data) {
@@ -48,7 +45,6 @@ class SandboxFileSystem extends action_js_1.SandboxAction {
             path: { path },
             query: { recursive },
             baseUrl: this.url,
-            client: this.client,
         });
         this.handleResponseError(response, data, error);
         return data;
@@ -58,7 +54,6 @@ class SandboxFileSystem extends action_js_1.SandboxAction {
         const { response, data, error } = await (0, index_js_1.getFilesystemByPath)({
             path: { path },
             baseUrl: this.url,
-            client: this.client,
         });
         this.handleResponseError(response, data, error);
         if (!data || !('files' in data || 'subdirectories' in data)) {
@@ -72,7 +67,6 @@ class SandboxFileSystem extends action_js_1.SandboxAction {
         const { response, data, error } = await (0, index_js_1.getFilesystemByPath)({
             path: { path: source },
             baseUrl: this.url,
-            client: this.client,
         });
         this.handleResponseError(response, data, error);
         if (data && ('files' in data || 'subdirectories' in data)) {
@@ -117,13 +111,136 @@ class SandboxFileSystem extends action_js_1.SandboxAction {
         }
         throw new Error("Unsupported file type");
     }
+    /**
+     * Watch for changes in a directory. Calls the callback with the changed file path (and optionally its content).
+     * Returns a handle with a close() method to stop watching.
+     * @param path Directory to watch
+     * @param callback Function called on each change: (filePath, content?)
+     * @param withContent If true, also fetches and passes the file content (default: false)
+     */
     watch(path, callback, options) {
+        if (options?.ws) {
+            return this.wsWatch(path, callback, options);
+        }
+        return this.sseWatch(path, callback, options);
+    }
+    wsWatch(path, callback, options) {
+        path = this.formatPath(path);
+        let closed = false;
+        let ws = this.websocket(`watch/filesystem${path.startsWith('/') ? path : '/' + path}`);
+        let pingInterval = null;
+        let pongTimeout = null;
+        const PING_INTERVAL_MS = 30000;
+        const PONG_TIMEOUT_MS = 10000;
+        function sendPing() {
+            if (ws && ws.readyState === ws.OPEN) {
+                try {
+                    ws.send(JSON.stringify({ type: 'ping' }));
+                }
+                catch { }
+                // Set pong timeout
+                if (pongTimeout)
+                    clearTimeout(pongTimeout);
+                pongTimeout = setTimeout(() => {
+                    // No pong received in time, close connection
+                    if (ws && typeof ws.close === 'function')
+                        ws.close();
+                }, PONG_TIMEOUT_MS);
+            }
+        }
+        if (ws) {
+            ws.onmessage = async (event) => {
+                if (closed)
+                    return;
+                let data;
+                try {
+                    data = typeof event.data === 'string' ? event.data : event.data;
+                    if (!data)
+                        return;
+                    // Accept both JSON and plain string (file path)
+                    let payload;
+                    try {
+                        payload = JSON.parse(data);
+                    }
+                    catch {
+                        payload = { name: data, event: undefined };
+                    }
+                    // Handle ping/pong
+                    if (payload.type === 'ping') {
+                        // Respond to ping with pong
+                        if (ws && ws.readyState === ws.OPEN) {
+                            try {
+                                ws.send(JSON.stringify({ type: 'pong' }));
+                            }
+                            catch { }
+                        }
+                        return;
+                    }
+                    if (payload.type === 'pong') {
+                        // Pong received, clear pong timeout
+                        if (pongTimeout)
+                            clearTimeout(pongTimeout);
+                        pongTimeout = null;
+                        return;
+                    }
+                    const filePath = payload.name || payload.path || data;
+                    if (!filePath)
+                        return;
+                    if (options?.withContent) {
+                        try {
+                            const content = await this.read(filePath);
+                            await callback(filePath, content);
+                        }
+                        catch (e) {
+                            await callback(filePath, undefined);
+                        }
+                    }
+                    else {
+                        await callback(filePath);
+                    }
+                }
+                catch (err) {
+                    if (options?.onError)
+                        options.onError(err);
+                }
+            };
+            ws.onerror = (err) => {
+                if (options?.onError)
+                    options.onError(err instanceof Error ? err : new Error(String(err)));
+                closed = true;
+                if (ws && typeof ws.close === 'function')
+                    ws.close();
+            };
+            ws.onclose = () => {
+                closed = true;
+                ws = null;
+                if (pingInterval)
+                    clearInterval(pingInterval);
+                if (pongTimeout)
+                    clearTimeout(pongTimeout);
+            };
+            // Start ping interval
+            pingInterval = setInterval(sendPing, PING_INTERVAL_MS);
+        }
+        return {
+            close: () => {
+                closed = true;
+                if (ws && typeof ws.close === 'function')
+                    ws.close();
+                ws = null;
+                if (pingInterval)
+                    clearInterval(pingInterval);
+                if (pongTimeout)
+                    clearTimeout(pongTimeout);
+            },
+        };
+    }
+    sseWatch(path, callback, options) {
         path = this.formatPath(path);
         let closed = false;
         let controller = new AbortController();
         const start = async () => {
             const { response, data, error } = await (0, index_js_1.getWatchFilesystemByPath)({
-                client: this.client,
                 path: { path },
                 baseUrl: this.url,
                 parseAs: 'stream',

package/dist/sandbox/process.d.ts

@@ -4,6 +4,21 @@ import { DeleteProcessByIdentifierKillResponse, DeleteProcessByIdentifierRespons
 export declare class SandboxProcess extends SandboxAction {
     constructor(sandbox: Sandbox);
     streamLogs(identifier: string, options: {
+        ws?: boolean;
+        onLog?: (log: string) => void;
+        onStdout?: (stdout: string) => void;
+        onStderr?: (stderr: string) => void;
+    }): {
+        close: () => void;
+    };
+    wsStreamLogs(identifier: string, options: {
+        onLog?: (log: string) => void;
+        onStdout?: (stdout: string) => void;
+        onStderr?: (stderr: string) => void;
+    }): {
+        close: () => void;
+    };
+    sseStreamLogs(identifier: string, options: {
         onLog?: (log: string) => void;
         onStdout?: (stdout: string) => void;
         onStderr?: (stderr: string) => void;

package/dist/sandbox/process.js

@@ -9,14 +9,126 @@ class SandboxProcess extends action_js_1.SandboxAction {
         super(sandbox);
     }
     streamLogs(identifier, options) {
+        if (options.ws) {
+            return this.wsStreamLogs(identifier, options);
+        }
+        return this.sseStreamLogs(identifier, options);
+    }
+    wsStreamLogs(identifier, options) {
+        let closed = false;
+        let ws = this.websocket(`process/${identifier}/logs/stream`);
+        let pingInterval = null;
+        let pongTimeout = null;
+        const PING_INTERVAL_MS = 30000;
+        const PONG_TIMEOUT_MS = 10000;
+        function sendPing() {
+            if (ws && ws.readyState === ws.OPEN) {
+                try {
+                    ws.send(JSON.stringify({ type: 'ping' }));
+                }
+                catch { }
+                // Set pong timeout
+                if (pongTimeout)
+                    clearTimeout(pongTimeout);
+                pongTimeout = setTimeout(() => {
+                    // No pong received in time, close connection
+                    if (ws && typeof ws.close === 'function')
+                        ws.close();
+                }, PONG_TIMEOUT_MS);
+            }
+        }
+        if (ws) {
+            ws.onmessage = (event) => {
+                if (closed)
+                    return;
+                let data;
+                try {
+                    data = typeof event.data === 'string' ? event.data : event.data;
+                    if (!data)
+                        return;
+                    let payload;
+                    try {
+                        payload = JSON.parse(data);
+                    }
+                    catch {
+                        payload = { log: data };
+                    }
+                    // Handle ping/pong
+                    if (payload.type === 'ping') {
+                        // Respond to ping with pong
+                        if (ws && ws.readyState === ws.OPEN) {
+                            try {
+                                ws.send(JSON.stringify({ type: 'pong' }));
+                            }
+                            catch { }
+                        }
+                        return;
+                    }
+                    if (payload.type === 'pong') {
+                        // Pong received, clear pong timeout
+                        if (pongTimeout)
+                            clearTimeout(pongTimeout);
+                        pongTimeout = null;
+                        return;
+                    }
+                    if (payload.type === 'log') {
+                        const logLine = payload.log || "";
+                        if (typeof logLine === 'string') {
+                            if (logLine.startsWith('stdout:')) {
+                                options.onStdout?.(logLine.slice(7));
+                                options.onLog?.(logLine.slice(7));
+                            }
+                            else if (logLine.startsWith('stderr:')) {
+                                options.onStderr?.(logLine.slice(7));
+                                options.onLog?.(logLine.slice(7));
+                            }
+                            else {
+                                options.onLog?.(logLine);
+                            }
+                        }
+                    }
+                }
+                catch (err) {
+                    console.error('WebSocket log stream error:', err);
+                }
+            };
+            ws.onerror = (err) => {
+                closed = true;
+                if (ws && typeof ws.close === 'function')
+                    ws.close();
+            };
+            ws.onclose = () => {
+                closed = true;
+                ws = null;
+                if (pingInterval)
+                    clearInterval(pingInterval);
+                if (pongTimeout)
+                    clearTimeout(pongTimeout);
+            };
+            // Start ping interval
+            pingInterval = setInterval(sendPing, PING_INTERVAL_MS);
+        }
+        return {
+            close: () => {
+                closed = true;
+                if (ws && typeof ws.close === 'function')
+                    ws.close();
+                ws = null;
+                if (pingInterval)
+                    clearInterval(pingInterval);
+                if (pongTimeout)
+                    clearTimeout(pongTimeout);
+            },
+        };
+    }
+    sseStreamLogs(identifier, options) {
         const controller = new AbortController();
         (async () => {
             try {
-                const headers = this.sandbox.forceUrl ? this.sandbox.headers : settings_js_1.settings.headers;
                 const stream = await fetch(`${this.url}/process/${identifier}/logs/stream`, {
                     method: 'GET',
                     signal: controller.signal,
-                    headers,
+                    headers: settings_js_1.settings.headers,
                 });
                 if (stream.status !== 200) {
                     throw new Error(`Failed to stream logs: ${await stream.text()}`);
@@ -63,7 +175,6 @@ class SandboxProcess extends action_js_1.SandboxAction {
         const { response, data, error } = await (0, index_js_1.postProcess)({
             body: process,
             baseUrl: this.url,
-            client: this.client,
         });
         this.handleResponseError(response, data, error);
         return data;
@@ -91,7 +202,6 @@ class SandboxProcess extends action_js_1.SandboxAction {
         const { response, data, error } = await (0, index_js_1.getProcessByIdentifier)({
             path: { identifier },
             baseUrl: this.url,
-            client: this.client,
         });
         this.handleResponseError(response, data, error);
         return data;
@@ -99,7 +209,6 @@ class SandboxProcess extends action_js_1.SandboxAction {
     async list() {
         const { response, data, error } = await (0, index_js_1.getProcess)({
             baseUrl: this.url,
-            client: this.client,
         });
         this.handleResponseError(response, data, error);
         return data;
@@ -108,7 +217,6 @@ class SandboxProcess extends action_js_1.SandboxAction {
         const { response, data, error } = await (0, index_js_1.deleteProcessByIdentifier)({
             path: { identifier },
             baseUrl: this.url,
-            client: this.client,
         });
         this.handleResponseError(response, data, error);
         return data;
@@ -117,7 +225,6 @@ class SandboxProcess extends action_js_1.SandboxAction {
         const { response, data, error } = await (0, index_js_1.deleteProcessByIdentifierKill)({
             path: { identifier },
             baseUrl: this.url,
-            client: this.client,
         });
         this.handleResponseError(response, data, error);
         return data;
@@ -126,7 +233,6 @@ class SandboxProcess extends action_js_1.SandboxAction {
         const { response, data, error } = await (0, index_js_1.getProcessByIdentifierLogs)({
             path: { identifier },
             baseUrl: this.url,
-            client: this.client,
         });
         this.handleResponseError(response, data, error);
         if (data && type in data) {

package/dist/sandbox/sandbox.d.ts

@@ -3,16 +3,13 @@ import { SandboxFileSystem } from "./filesystem.js";
 import { SandboxNetwork } from "./network.js";
 import { SandboxPreviews } from "./preview.js";
 import { SandboxProcess } from "./process.js";
-import { SandboxSessions } from "./session.js";
-import { SandboxConfiguration, SessionWithToken } from "./types.js";
 export declare class SandboxInstance {
     private sandbox;
     fs: SandboxFileSystem;
     network: SandboxNetwork;
     process: SandboxProcess;
     previews: SandboxPreviews;
-    sessions: SandboxSessions;
-    constructor(sandbox: SandboxConfiguration);
+    constructor(sandbox: SandboxModel);
     get metadata(): import("../client/types.gen.js").Metadata | undefined;
     get status(): string | undefined;
     get events(): import("../client/types.gen.js").CoreEvents | undefined;
@@ -25,5 +22,4 @@ export declare class SandboxInstance {
     static get(sandboxName: string): Promise<SandboxInstance>;
     static list(): Promise<SandboxInstance[]>;
     static delete(sandboxName: string): Promise<SandboxModel>;
-    static fromSession(session: SessionWithToken): Promise<SandboxInstance>;
 }

package/dist/sandbox/sandbox.js

@@ -7,21 +7,18 @@ const filesystem_js_1 = require("./filesystem.js");
 const network_js_1 = require("./network.js");
 const preview_js_1 = require("./preview.js");
 const process_js_1 = require("./process.js");
-const session_js_1 = require("./session.js");
 class SandboxInstance {
     sandbox;
     fs;
     network;
     process;
     previews;
-    sessions;
     constructor(sandbox) {
         this.sandbox = sandbox;
         this.fs = new filesystem_js_1.SandboxFileSystem(sandbox);
         this.network = new network_js_1.SandboxNetwork(sandbox);
         this.process = new process_js_1.SandboxProcess(sandbox);
         this.previews = new preview_js_1.SandboxPreviews(sandbox);
-        this.sessions = new session_js_1.SandboxSessions(sandbox);
     }
     get metadata() {
         return this.sandbox.metadata;
@@ -94,8 +91,5 @@ class SandboxInstance {
         });
         return data;
     }
-    static async fromSession(session) {
-        return new SandboxInstance({ forceUrl: session.url, params: { bl_preview_token: session.token }, headers: { "X-Blaxel-Preview-Token": session.token } });
-    }
 }
 exports.SandboxInstance = SandboxInstance;

package/dist/telemetry/telemetry.d.ts

@@ -55,5 +55,4 @@ export declare const telemetryRegistry: TelemetryRegistry;
  * Create a span with the registered provider
  */
 export declare function startSpan(name: string, options?: BlaxelSpanOptions): BlaxelSpan;
-export declare function withSpan<T>(name: string, fn: () => T, options?: BlaxelSpanOptions): T;
 export {};

package/dist/telemetry/telemetry.js

@@ -3,7 +3,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.telemetryRegistry = void 0;
 exports.startSpan = startSpan;
-exports.withSpan = withSpan;
 /**
  * No-operation implementation of Span
  */
@@ -58,16 +57,3 @@ exports.telemetryRegistry = TelemetryRegistry.getInstance();
 function startSpan(name, options) {
     return exports.telemetryRegistry.getProvider().startSpan(name, options);
 }
-function withSpan(name, fn, options) {
-    const span = startSpan(name, options);
-    try {
-        const result = fn();
-        span.end();
-        return result;
-    }
-    catch (error) {
-        span.recordException(error);
-        span.end();
-        throw error;
-    }
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blaxel/core",
-  "version": "0.2.0-preview5",
+  "version": "0.2.1-dev.46",
   "description": "Blaxel Core SDK for TypeScript",
   "license": "MIT",
   "author": "Blaxel, INC (https://blaxel.ai)",
@@ -62,13 +62,11 @@
     "uuid": "^11.1.0",
     "ws": "^8.18.2",
     "yaml": "^2.7.1",
-    "yargs": "^17.7.2",
     "zod": "^3.24.3"
   },
   "devDependencies": {
     "@eslint/js": "^9.26.0",
     "@types/ws": "^8.18.1",
-    "@types/yargs": "^17.0.33",
     "typescript": "^5.0.0",
     "typescript-eslint": "^8.31.1"
   },

package/dist/jobs/index.d.ts

@@ -1 +0,0 @@
-export * from "./jobs.js";

package/dist/jobs/index.js

@@ -1,17 +0,0 @@
-"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);

package/dist/jobs/jobs.d.ts

@@ -1,10 +0,0 @@
-declare class BlJob {
-    getArguments(): Promise<{
-        [key: number]: any;
-    }>;
-    get indexKey(): string;
-    get index(): number;
-    start(func: (args: any) => Promise<void>): Promise<void>;
-}
-export declare const blJob: BlJob;
-export {};

package/dist/jobs/jobs.js

@@ -1,42 +0,0 @@
-"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/server/http.d.ts

@@ -1,8 +0,0 @@
-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

@@ -1,16 +0,0 @@
-"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

@@ -1,4 +0,0 @@
-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

@@ -1,21 +0,0 @@
-"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

@@ -1,24 +0,0 @@
-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 {};