@blaxel/core 0.2.2-preview3 → 0.2.2

package/dist/common/node.js

@@ -10,11 +10,6 @@ exports.fs = fs;
 let os = null;
 exports.os = os;
 if (isNode) {
-    try {
-        exports.fs = fs = eval("require")("fs");
-        exports.os = os = eval("require")("os");
-    }
-    catch (e) {
-        console.warn("fs and os are not available in this environment");
-    }
+    exports.fs = fs = eval("require")("fs");
+    exports.os = os = eval("require")("os");
 }

package/dist/common/settings.js

@@ -75,7 +75,7 @@ class Settings {
         if (!this.generation) {
             return "";
         }
-        return env_js_1.env.BL_RUN_INTERNAL_HOST || "";
+        return env_js_1.env.BL_RUN_INTERNAL_HOSTNAME || "";
     }
     get runInternalProtocol() {
         return env_js_1.env.BL_RUN_INTERNAL_PROTOCOL || "https";

package/dist/jobs/jobs.d.ts

@@ -2,7 +2,6 @@ declare class BlJob {
     getArguments(): Promise<{
         [key: number]: any;
     }>;
-    private parseCommandLineArgs;
     get indexKey(): string;
     get index(): number;
     start(func: (args: any) => Promise<void>): Promise<void>;

package/dist/jobs/jobs.js

@@ -1,38 +1,25 @@
 "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 args = this.parseCommandLineArgs();
-            return args;
+            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] ?? {};
     }
-    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";
+        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;

package/dist/sandbox/action.d.ts

@@ -16,4 +16,5 @@ export declare class SandboxAction {
     get forcedUrl(): string | null;
     get url(): string;
     handleResponseError(response: Response, data: unknown, error: unknown): void;
+    websocket(path: string): WebSocket | null;
 }

package/dist/sandbox/action.js

@@ -84,5 +84,45 @@ class SandboxAction {
             throw new ResponseError(response, data, error);
         }
     }
+    websocket(path) {
+        let ws = null;
+        // Build ws:// or wss:// URL from baseUrl
+        let baseUrl = this.url.replace(/^http/, 'ws');
+        if (baseUrl.endsWith('/'))
+            baseUrl = baseUrl.slice(0, -1);
+        let params = `token=${settings_js_1.settings.token}`;
+        if (this.sandbox.params) {
+            params = "";
+            for (const [key, value] of Object.entries(this.sandbox.params)) {
+                params += `${key}=${value}&`;
+            }
+            params = params.slice(0, -1);
+        }
+        const wsUrl = `${baseUrl}/ws/${path}?${params}`;
+        // Use isomorphic WebSocket: browser or Node.js
+        let WS = undefined;
+        if (typeof globalThis.WebSocket !== 'undefined') {
+            WS = globalThis.WebSocket;
+        }
+        else {
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                WS = require('ws');
+            }
+            catch {
+                WS = undefined;
+            }
+        }
+        if (!WS)
+            throw new Error('WebSocket is not available in this environment');
+        try {
+            ws = typeof WS === 'function' ? new WS(wsUrl) : new WS(wsUrl);
+        }
+        catch (err) {
+            console.error('WebSocket connection error:', err);
+            throw err;
+        }
+        return ws;
+    }
 }
 exports.SandboxAction = SandboxAction;

package/dist/sandbox/filesystem.d.ts

@@ -14,7 +14,27 @@ 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 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: string, callback: (filePath: string, content?: string) => void | Promise<void>, options?: {
+        ws?: boolean;
+        onError?: (error: Error) => void;
+        withContent: boolean;
+    }): {
+        close: () => void;
+    };
+    wsWatch(path: string, callback: (filePath: string, content?: string) => void | Promise<void>, options?: {
+        onError?: (error: Error) => void;
+        withContent: boolean;
+    }): {
+        close: () => void;
+    };
+    sseWatch(path: string, callback: (filePath: string, content?: string) => void | Promise<void>, options?: {
         onError?: (error: Error) => void;
         withContent: boolean;
     }): {

package/dist/sandbox/filesystem.js

@@ -117,7 +117,131 @@ 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();

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,6 +9,119 @@ 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 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blaxel/core",
-  "version": "0.2.2-preview3",
+  "version": "0.2.2",
   "description": "Blaxel Core SDK for TypeScript",
   "license": "MIT",
   "author": "Blaxel, INC (https://blaxel.ai)",
@@ -62,11 +62,13 @@
     "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/batches.d.ts

@@ -1,32 +0,0 @@
-declare class BlBatch {
-    /**
-     * Lists all remote batch jobs for a given name
-     * @param name - The name of the job to list
-     */
-    list(name: string): void;
-    /**
-     * Creates a new remote batch job configuration.
-     * This is used for remote execution management, not for local execution.
-     * @param name - The name of the job
-     * @param args - Array of argument arrays for each job in the batch
-     * @returns The batch configuration object
-     */
-    create(name: string, args: any[][]): {
-        name: string;
-        args: any[][];
-    };
-    /**
-     * Kills a remote batch job
-     * @param name - The name of the job
-     * @param batchId - The ID of the batch to kill
-     */
-    kill(name: string, batchId: string): void;
-    /**
-     * Retrieves information about a remote batch job
-     * @param name - The name of the job
-     * @param batchId - The ID of the batch to get information for
-     */
-    get(name: string, batchId: string): void;
-}
-export declare const blBatch: BlBatch;
-export {};

package/dist/jobs/batches.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.blBatch = void 0;
-class BlBatch {
-    /**
-     * Lists all remote batch jobs for a given name
-     * @param name - The name of the job to list
-     */
-    list(name) {
-    }
-    /**
-     * Creates a new remote batch job configuration.
-     * This is used for remote execution management, not for local execution.
-     * @param name - The name of the job
-     * @param args - Array of argument arrays for each job in the batch
-     * @returns The batch configuration object
-     */
-    create(name, args) {
-        const batch = {
-            name,
-            args,
-        };
-        return batch;
-    }
-    /**
-     * Kills a remote batch job
-     * @param name - The name of the job
-     * @param batchId - The ID of the batch to kill
-     */
-    kill(name, batchId) {
-    }
-    /**
-     * Retrieves information about a remote batch job
-     * @param name - The name of the job
-     * @param batchId - The ID of the batch to get information for
-     */
-    get(name, batchId) {
-    }
-}
-exports.blBatch = new BlBatch();

package/dist/jobs/job.d.ts

@@ -1,33 +0,0 @@
-declare class BlJob {
-    start(func: (...args: any[]) => Promise<void>): void;
-    /**
-     * Lists all remote batch jobs for a given name
-     * @param name - The name of the job to list
-     */
-    list(name: string): void;
-    /**
-     * Creates a new remote batch job configuration.
-     * This is used for remote execution management, not for local execution.
-     * @param name - The name of the job
-     * @param args - Array of argument arrays for each job in the batch
-     * @returns The batch configuration object
-     */
-    create(name: string, args: any[][]): {
-        name: string;
-        args: any[][];
-    };
-    /**
-     * Kills a remote batch job
-     * @param name - The name of the job
-     * @param batchId - The ID of the batch to kill
-     */
-    kill(name: string, batchId: string): void;
-    /**
-     * Retrieves information about a remote batch job
-     * @param name - The name of the job
-     * @param batchId - The ID of the batch to get information for
-     */
-    get(name: string, batchId: string): void;
-}
-export declare const blJob: BlJob;
-export {};

package/dist/jobs/job.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.blJob = void 0;
-function retrieveArguments() {
-    const args = process.argv.slice(2);
-    return args;
-}
-class BlJob {
-    /*
-      Run a job defined in a function, it's run in the current process
-    */
-    start(func) {
-        const args = retrieveArguments();
-        func(...args);
-    }
-    /**
-     * Lists all remote batch jobs for a given name
-     * @param name - The name of the job to list
-     */
-    list(name) {
-    }
-    /**
-     * Creates a new remote batch job configuration.
-     * This is used for remote execution management, not for local execution.
-     * @param name - The name of the job
-     * @param args - Array of argument arrays for each job in the batch
-     * @returns The batch configuration object
-     */
-    create(name, args) {
-        const batch = {
-            name,
-            args,
-        };
-        return batch;
-    }
-    /**
-     * Kills a remote batch job
-     * @param name - The name of the job
-     * @param batchId - The ID of the batch to kill
-     */
-    kill(name, batchId) {
-    }
-    /**
-     * Retrieves information about a remote batch job
-     * @param name - The name of the job
-     * @param batchId - The ID of the batch to get information for
-     */
-    get(name, batchId) {
-    }
-}
-exports.blJob = new BlJob();