@blaxel/core 0.2.0-preview4 → 0.2.0-preview5

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

@@ -1,11 +1,3 @@
-export type Directory = {
-    files?: Array<File>;
-    path?: string;
-    /**
-     * @name Subdirectories
-     */
-    subdirectories?: Array<Subdirectory>;
-};
 export type ErrorResponse = {
     error?: string;
 };
@@ -14,6 +6,9 @@ export type File = {
     lastModified?: string;
     owner?: string;
     path?: string;
+    /**
+     * swagger:strfmt string
+     */
     permissions?: string;
     size?: number;
 };
@@ -28,6 +23,9 @@ export type FileWithContent = {
     lastModified?: string;
     owner?: string;
     path?: string;
+    /**
+     * swagger:strfmt string
+     */
     permissions?: string;
     size?: number;
 };
@@ -43,7 +41,6 @@ export type ProcessKillRequest = {
 export type ProcessRequest = {
     command: string;
     name?: string;
-    streamLogs?: boolean;
     timeout?: number;
     waitForCompletion?: boolean;
     waitForPorts?: Array<number>;
@@ -59,13 +56,18 @@ export type ProcessResponse = {
     status?: string;
     workingDir?: string;
 };
-export type Subdirectory = {
-    path?: string;
-};
 export type SuccessResponse = {
     message?: string;
     path?: string;
 };
+export type Directory = {
+    files?: Array<File>;
+    path?: string;
+    /**
+     * @name Subdirectories
+     */
+    subdirectories?: Array<Directory>;
+};
 export type DeleteFilesystemByPathData = {
     body?: never;
     path: {
@@ -391,12 +393,7 @@ export type GetProcessByIdentifierLogsData = {
          */
         identifier: string;
     };
-    query?: {
-        /**
-         * Stream logs
-         */
-        stream?: boolean;
-    };
+    query?: never;
     url: '/process/{identifier}/logs';
 };
 export type GetProcessByIdentifierLogsErrors = {
@@ -427,12 +424,7 @@ export type GetProcessByIdentifierLogsStreamData = {
          */
         identifier: string;
     };
-    query?: {
-        /**
-         * Stream logs
-         */
-        stream?: boolean;
-    };
+    query?: never;
     url: '/process/{identifier}/logs/stream';
 };
 export type GetProcessByIdentifierLogsStreamErrors = {
@@ -448,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;
 }

package/dist/sandbox/filesystem.js

@@ -13,6 +13,7 @@ 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;
@@ -23,6 +24,7 @@ class SandboxFileSystem extends action_js_1.SandboxAction {
             path: { path },
             body: { content },
             baseUrl: this.url,
+            client: this.client,
         });
         this.handleResponseError(response, data, error);
         return data;
@@ -32,6 +34,7 @@ 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) {
@@ -45,6 +48,7 @@ class SandboxFileSystem extends action_js_1.SandboxAction {
             path: { path },
             query: { recursive },
             baseUrl: this.url,
+            client: this.client,
         });
         this.handleResponseError(response, data, error);
         return data;
@@ -54,6 +58,7 @@ 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)) {
@@ -67,6 +72,7 @@ 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)) {
@@ -111,6 +117,74 @@ class SandboxFileSystem extends action_js_1.SandboxAction {
         }
         throw new Error("Unsupported file type");
     }
+    watch(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',
+                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,7 +3,18 @@ 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: {
+        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,24 +1,97 @@
 "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) {
+        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,
+                });
+                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,
             baseUrl: this.url,
+            client: this.client,
         });
         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 },
             baseUrl: this.url,
+            client: this.client,
         });
         this.handleResponseError(response, data, error);
         return data;
@@ -26,6 +99,7 @@ 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;
@@ -34,6 +108,7 @@ 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;
@@ -42,6 +117,7 @@ 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;
@@ -50,6 +126,7 @@ 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,13 +3,16 @@ 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;
-    constructor(sandbox: SandboxModel);
+    sessions: SandboxSessions;
+    constructor(sandbox: SandboxConfiguration);
     get metadata(): import("../client/types.gen.js").Metadata | undefined;
     get status(): string | undefined;
     get events(): import("../client/types.gen.js").CoreEvents | undefined;
@@ -22,4 +25,5 @@ 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,18 +7,21 @@ 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;
@@ -91,5 +94,8 @@ 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/sandbox/session.d.ts

@@ -0,0 +1,21 @@
+import { Sandbox } from "../client/index.js";
+import { SessionCreateOptions, SessionWithToken } from "./types.js";
+export declare class SandboxSessions {
+    private sandbox;
+    constructor(sandbox: Sandbox);
+    get sandboxName(): string;
+    create(options?: SessionCreateOptions): Promise<SessionWithToken>;
+    list(): Promise<{
+        name: string;
+        url: string;
+        token: string;
+        expiresAt: string | Date;
+    }[]>;
+    get(name: string): Promise<{
+        url: string;
+        token: string;
+        expiresAt: string | Date;
+    }>;
+    delete(name: string): Promise<import("../client/types.gen.js").Preview>;
+    getToken(previewName: string): Promise<import("../client/types.gen.js").PreviewToken | null>;
+}

package/dist/sandbox/session.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxSessions = void 0;
+const index_js_1 = require("../client/index.js");
+const preview_js_1 = require("./preview.js");
+class SandboxSessions {
+    sandbox;
+    constructor(sandbox) {
+        this.sandbox = sandbox;
+    }
+    get sandboxName() {
+        return this.sandbox.metadata?.name ?? "";
+    }
+    async create(options = {}) {
+        const expiresAt = options.expiresAt ?? new Date(Date.now() + 24 * 60 * 60 * 1000); // 1 day from now
+        const body = {
+            metadata: {
+                name: "session-" + Date.now(),
+            },
+            spec: {
+                port: 443,
+                public: false,
+            },
+        };
+        const { data } = await (0, index_js_1.createSandboxPreview)({
+            path: {
+                sandboxName: this.sandboxName,
+            },
+            body,
+            throwOnError: true,
+        });
+        const preview = new preview_js_1.SandboxPreview(data);
+        // Create a token for the preview with the given expiresAt
+        const tokenObj = await preview.tokens.create(expiresAt);
+        return {
+            name: body.metadata.name,
+            url: preview.spec?.url ?? "",
+            token: tokenObj.value,
+            expiresAt: typeof tokenObj.expiresAt === 'string' ? new Date(tokenObj.expiresAt) : tokenObj.expiresAt,
+        };
+    }
+    async list() {
+        const { data } = await (0, index_js_1.listSandboxPreviews)({
+            path: {
+                sandboxName: this.sandboxName,
+            },
+            throwOnError: true,
+        });
+        return await Promise.all(data.filter((preview) => preview.metadata?.name?.includes("session-")).map(async (preview) => {
+            const token = await this.getToken(preview.metadata?.name ?? "");
+            return {
+                name: preview.metadata?.name ?? "",
+                url: preview.spec?.url ?? "",
+                token: token?.spec?.token ?? "",
+                expiresAt: token?.spec?.expiresAt ?? new Date(),
+            };
+        }));
+    }
+    async get(name) {
+        const { data } = await (0, index_js_1.getSandboxPreview)({
+            path: {
+                sandboxName: this.sandboxName,
+                previewName: name,
+            },
+            throwOnError: true,
+        });
+        const token = await this.getToken(name);
+        return {
+            url: data.spec?.url ?? "",
+            token: token?.spec?.token ?? "",
+            expiresAt: token?.spec?.expiresAt ?? new Date(),
+        };
+    }
+    async delete(name) {
+        const { data } = await (0, index_js_1.deleteSandboxPreview)({
+            path: {
+                sandboxName: this.sandboxName,
+                previewName: name,
+            },
+            throwOnError: true,
+        });
+        return data;
+    }
+    async getToken(previewName) {
+        const { data } = await (0, index_js_1.listSandboxPreviewTokens)({
+            path: {
+                sandboxName: this.sandboxName,
+                previewName,
+            },
+            throwOnError: true,
+        });
+        if (data.length === 0)
+            return null;
+        return data[0];
+    }
+}
+exports.SandboxSessions = SandboxSessions;

package/dist/sandbox/types.d.ts

@@ -0,0 +1,15 @@
+import { Sandbox } from "../client/types.gen";
+export interface SessionCreateOptions {
+    expiresAt?: Date;
+}
+export interface SessionWithToken {
+    name: string;
+    url: string;
+    token: string;
+    expiresAt: Date;
+}
+export type SandboxConfiguration = {
+    forceUrl?: string;
+    headers?: Record<string, string>;
+    params?: Record<string, string>;
+} & Sandbox;

package/dist/sandbox/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/telemetry/telemetry.d.ts

@@ -55,4 +55,5 @@ 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,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.telemetryRegistry = void 0;
 exports.startSpan = startSpan;
+exports.withSpan = withSpan;
 /**
  * No-operation implementation of Span
  */
@@ -57,3 +58,16 @@ 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-preview4",
+  "version": "0.2.0-preview5",
   "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"
   },