@blaxel/core 0.2.1-dev.47 → 0.2.1-dev1

package/dist/common/settings.d.ts

@@ -20,6 +20,7 @@ declare class Settings {
     get type(): string;
     get runInternalHostname(): string;
     get runInternalProtocol(): string;
+    get blCloud(): boolean;
     get loggerType(): string;
     authenticate(): Promise<void>;
 }

package/dist/common/settings.js

@@ -77,6 +77,9 @@ class Settings {
     get runInternalProtocol() {
         return env_js_1.env.BL_RUN_INTERNAL_PROTOCOL || "https";
     }
+    get blCloud() {
+        return env_js_1.env.BL_CLOUD === "true";
+    }
     get loggerType() {
         return env_js_1.env.BL_LOGGER || "http";
     }

package/dist/index.d.ts

@@ -7,6 +7,7 @@ export * from "./common/errors.js";
 export * from "./common/internal.js";
 export * from "./common/logger.js";
 export * from "./common/settings.js";
+export * from "./jobs/index.js";
 export * from "./mcp/index.js";
 export * from "./models/index.js";
 export * from "./sandbox/index.js";

package/dist/index.js

@@ -23,6 +23,7 @@ __exportStar(require("./common/errors.js"), exports);
 __exportStar(require("./common/internal.js"), exports);
 __exportStar(require("./common/logger.js"), exports);
 __exportStar(require("./common/settings.js"), exports);
+__exportStar(require("./jobs/index.js"), exports);
 __exportStar(require("./mcp/index.js"), exports);
 __exportStar(require("./models/index.js"), exports);
 __exportStar(require("./sandbox/index.js"), exports);

package/dist/jobs/batches.d.ts

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

@@ -0,0 +1,40 @@
+"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/index.d.ts

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

package/dist/jobs/index.js

@@ -0,0 +1,17 @@
+"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/job.d.ts

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

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

package/dist/jobs/jobs.d.ts

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

@@ -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_BATCH_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_BATCH_DATA_URL);
+        const data = await response.json();
+        return data.tasks[this.index] ?? {};
+    }
+    get indexKey() {
+        return env_js_1.env.BL_BATCH_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,13 +63,16 @@ 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/sandbox/action.d.ts

@@ -15,5 +15,4 @@ 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

@@ -61,9 +61,8 @@ class SandboxAction {
     get url() {
         if (this.forcedUrl)
             return this.forcedUrl;
-        // 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;
+        if (settings_js_1.settings.runInternalHostname)
+            return this.internalUrl;
         return this.externalUrl;
     }
     handleResponseError(response, data, error) {
@@ -71,37 +70,5 @@ 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);
-        const wsUrl = `${baseUrl}/ws/${path}?token=${settings_js_1.settings.token}`;
-        // 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/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, GetWatchFilesystemByPathData } from './types.gen';
+import type { DeleteFilesystemByPathData, GetFilesystemByPathData, PutFilesystemByPathData, DeleteNetworkProcessByPidMonitorData, PostNetworkProcessByPidMonitorData, GetNetworkProcessByPidPortsData, GetProcessData, PostProcessData, DeleteProcessByIdentifierData, GetProcessByIdentifierData, DeleteProcessByIdentifierKillData, GetProcessByIdentifierLogsData, GetProcessByIdentifierLogsStreamData } 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,12 +82,9 @@ export declare const getProcessByIdentifierLogs: <ThrowOnError extends boolean =
     [key: string]: string;
 }, import("./types.gen").ErrorResponse, ThrowOnError>;
 /**
- * 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.
+ * Get process logs in realtime
+ * Get the stdout and stderr output of a process in realtime
  */
-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>;
+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>;

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.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;
+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;
 /**
- * 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.
+ * Get process logs in realtime
+ * Get the stdout and stderr output of a process in realtime
  */
 const getProcessByIdentifierLogsStream = (options) => {
     return (options.client ?? client_gen_1.client).get({
@@ -162,14 +162,3 @@ 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

@@ -43,6 +43,7 @@ export type ProcessKillRequest = {
 export type ProcessRequest = {
     command: string;
     name?: string;
+    streamLogs?: boolean;
     timeout?: number;
     waitForCompletion?: boolean;
     waitForPorts?: Array<number>;
@@ -390,7 +391,12 @@ export type GetProcessByIdentifierLogsData = {
          */
         identifier: string;
     };
-    query?: never;
+    query?: {
+        /**
+         * Stream logs
+         */
+        stream?: boolean;
+    };
     url: '/process/{identifier}/logs';
 };
 export type GetProcessByIdentifierLogsErrors = {
@@ -421,7 +427,12 @@ export type GetProcessByIdentifierLogsStreamData = {
          */
         identifier: string;
     };
-    query?: never;
+    query?: {
+        /**
+         * Stream logs
+         */
+        stream?: boolean;
+    };
     url: '/process/{identifier}/logs/stream';
 };
 export type GetProcessByIdentifierLogsStreamErrors = {
@@ -437,40 +448,13 @@ export type GetProcessByIdentifierLogsStreamErrors = {
 export type GetProcessByIdentifierLogsStreamError = GetProcessByIdentifierLogsStreamErrors[keyof GetProcessByIdentifierLogsStreamErrors];
 export type GetProcessByIdentifierLogsStreamResponses = {
     /**
-     * Stream of process logs, one line per log (prefixed with stdout:/stderr:)
+     * Process logs
      */
-    200: string;
-};
-export type GetProcessByIdentifierLogsStreamResponse = GetProcessByIdentifierLogsStreamResponses[keyof GetProcessByIdentifierLogsStreamResponses];
-export type GetWatchFilesystemByPathData = {
-    body?: never;
-    path: {
-        /**
-         * Directory path to watch
-         */
-        path: string;
+    200: {
+        [key: string]: 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 GetProcessByIdentifierLogsStreamResponse = GetProcessByIdentifierLogsStreamResponses[keyof GetProcessByIdentifierLogsStreamResponses];
 export type ClientOptions = {
     baseUrl: `${string}://localhost:8080` | (string & {});
 };

package/dist/sandbox/filesystem.d.ts

@@ -14,31 +14,5 @@ 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;
-    }): {
-        close: () => void;
-    };
     private formatPath;
 }

package/dist/sandbox/filesystem.js

@@ -111,197 +111,6 @@ 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)({
-                path: { path },
-                baseUrl: this.url,
-                parseAs: 'stream',
-                signal: controller.signal,
-            });
-            if (error)
-                throw error;
-            const stream = data ?? response.body;
-            if (!stream)
-                throw new Error('No stream returned');
-            const reader = stream.getReader();
-            let buffer = '';
-            const decoder = new TextDecoder();
-            try {
-                while (!closed) {
-                    const { value, done } = await reader.read();
-                    if (done)
-                        break;
-                    buffer += decoder.decode(value, { stream: true });
-                    let lines = buffer.split('\n');
-                    buffer = lines.pop();
-                    for (const line of lines) {
-                        const filePath = line.trim();
-                        if (!filePath)
-                            continue;
-                        if (options?.withContent) {
-                            try {
-                                const content = await this.read(filePath);
-                                await callback(filePath, content);
-                            }
-                            catch (e) {
-                                await callback(filePath, undefined);
-                            }
-                        }
-                        else {
-                            await callback(filePath);
-                        }
-                    }
-                }
-            }
-            finally {
-                reader.releaseLock();
-            }
-        };
-        start().catch((err) => {
-            // Suppress AbortError when closing
-            if (!(err && err.name === 'AbortError')) {
-                if (options?.onError) {
-                    options.onError(err);
-                }
-            }
-            closed = true;
-            controller?.abort();
-        });
-        return {
-            close: () => {
-                closed = true;
-                controller?.abort();
-            },
-        };
-    }
     formatPath(path) {
         if (path === "/") {
             return path;

package/dist/sandbox/process.d.ts

@@ -3,33 +3,7 @@ import { SandboxAction } from "./action.js";
 import { DeleteProcessByIdentifierKillResponse, DeleteProcessByIdentifierResponse, GetProcessByIdentifierResponse, GetProcessResponse, PostProcessResponse, ProcessRequest } from "./client/index.js";
 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;
-    }): {
-        close: () => void;
-    };
     exec(process: ProcessRequest): Promise<PostProcessResponse>;
-    wait(identifier: string, { maxWait, interval }?: {
-        maxWait?: number;
-        interval?: number;
-    }): Promise<GetProcessByIdentifierResponse>;
     get(identifier: string): Promise<GetProcessByIdentifierResponse>;
     list(): Promise<GetProcessResponse>;
     stop(identifier: string): Promise<DeleteProcessByIdentifierResponse>;

package/dist/sandbox/process.js

@@ -1,176 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SandboxProcess = void 0;
-const settings_js_1 = require("../common/settings.js");
 const action_js_1 = require("./action.js");
 const index_js_1 = require("./client/index.js");
 class SandboxProcess extends action_js_1.SandboxAction {
     constructor(sandbox) {
         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 stream = await fetch(`${this.url}/process/${identifier}/logs/stream`, {
-                    method: 'GET',
-                    signal: controller.signal,
-                    headers: settings_js_1.settings.headers,
-                });
-                if (stream.status !== 200) {
-                    throw new Error(`Failed to stream logs: ${await stream.text()}`);
-                }
-                if (!stream.body)
-                    throw new Error('No stream body');
-                const reader = stream.body.getReader();
-                const decoder = new TextDecoder();
-                let buffer = '';
-                while (true) {
-                    const { done, value } = await reader.read();
-                    if (done)
-                        break;
-                    buffer += decoder.decode(value, { stream: true });
-                    let lines = buffer.split(/\r?\n/);
-                    buffer = lines.pop();
-                    for (const line of lines) {
-                        if (line.startsWith('stdout:')) {
-                            options.onStdout?.(line.slice(7));
-                            options.onLog?.(line.slice(7));
-                        }
-                        else if (line.startsWith('stderr:')) {
-                            options.onStderr?.(line.slice(7));
-                            options.onLog?.(line.slice(7));
-                        }
-                        else {
-                            options.onLog?.(line);
-                        }
-                    }
-                }
-            }
-            catch (err) {
-                if (err && err.name !== 'AbortError') {
-                    console.error("Stream error:", err);
-                    throw err;
-                }
-            }
-        })();
-        return {
-            close: () => controller.abort(),
-        };
-    }
     async exec(process) {
         const { response, data, error } = await (0, index_js_1.postProcess)({
             body: process,
@@ -179,25 +15,6 @@ class SandboxProcess extends action_js_1.SandboxAction {
         this.handleResponseError(response, data, error);
         return data;
     }
-    async wait(identifier, { maxWait = 60000, interval = 1000 } = {}) {
-        const startTime = Date.now();
-        let status = "running";
-        let data = await this.get(identifier);
-        while (status === "running") {
-            await new Promise((resolve) => setTimeout(resolve, interval));
-            try {
-                data = await this.get(identifier);
-                status = data.status ?? "running";
-            }
-            catch {
-                break;
-            }
-            if (Date.now() - startTime > maxWait) {
-                throw new Error("Process did not finish in time");
-            }
-        }
-        return data;
-    }
     async get(identifier) {
         const { response, data, error } = await (0, index_js_1.getProcessByIdentifier)({
             path: { identifier },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blaxel/core",
-  "version": "0.2.1-dev.47",
+  "version": "0.2.1-dev1",
   "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"
   },