@blaxel/core 0.2.43-dev.196 → 0.2.43-dev.199

package/dist/cjs-browser/sandbox/filesystem/filesystem.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxFileSystem = 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 SandboxFileSystem extends action_js_1.SandboxAction {
+    process;
+    constructor(sandbox, process) {
+        super(sandbox);
+        this.process = process;
+        this.process = process;
+    }
+    async mkdir(path, permissions = "0755") {
+        path = this.formatPath(path);
+        const { response, data, error } = await (0, index_js_1.putFilesystemByPath)({
+            path: { path },
+            body: { isDirectory: true, permissions },
+            baseUrl: this.url,
+            client: this.client,
+        });
+        this.handleResponseError(response, data, error);
+        return data;
+    }
+    async write(path, content) {
+        path = this.formatPath(path);
+        const { response, data, error } = await (0, index_js_1.putFilesystemByPath)({
+            path: { path },
+            body: { content },
+            baseUrl: this.url,
+            client: this.client,
+        });
+        this.handleResponseError(response, data, error);
+        return data;
+    }
+    async writeBinary(path, content) {
+        path = this.formatPath(path);
+        const formData = new FormData();
+        // Convert content to Blob regardless of input type
+        let fileBlob;
+        if (content instanceof Blob || content instanceof File) {
+            fileBlob = content;
+        }
+        else if (Buffer.isBuffer(content)) {
+            // Convert Buffer to Blob
+            fileBlob = new Blob([content]);
+        }
+        else if (content instanceof Uint8Array) {
+            // Convert Uint8Array to Blob
+            fileBlob = new Blob([content]);
+        }
+        else {
+            throw new Error("Unsupported content type");
+        }
+        // Append the file as a Blob
+        formData.append("file", fileBlob, "test-binary.bin");
+        formData.append("permissions", "0644");
+        formData.append("path", path);
+        // Build URL
+        let url = `${this.url}/filesystem/${path}`;
+        if (this.forcedUrl) {
+            url = `${this.forcedUrl.toString()}/filesystem/${path}`;
+        }
+        // Make the request using fetch instead of axios for better FormData handling
+        const response = await fetch(url, {
+            method: 'PUT',
+            headers: {
+                ...settings_js_1.settings.headers,
+            },
+            body: formData,
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to write binary: ${response.status} ${errorText}`);
+        }
+        return await response.json();
+    }
+    async writeTree(files, destinationPath = null) {
+        const options = {
+            body: {
+                files: files.reduce((acc, file) => {
+                    acc[file.path] = file.content;
+                    return acc;
+                }, {}),
+            },
+            baseUrl: this.url,
+            client: this.client,
+        };
+        const path = this.formatPath(destinationPath ?? "");
+        const { response, data, error } = await this.client.put({
+            url: `/filesystem/tree/${path}`,
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+            }
+        });
+        this.handleResponseError(response, data, error);
+        return data;
+    }
+    async read(path) {
+        path = this.formatPath(path);
+        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) {
+            return data.content;
+        }
+        throw new Error("Unsupported file type");
+    }
+    async rm(path, recursive = false) {
+        path = this.formatPath(path);
+        const { response, data, error } = await (0, index_js_1.deleteFilesystemByPath)({
+            path: { path },
+            query: { recursive },
+            baseUrl: this.url,
+            client: this.client,
+        });
+        this.handleResponseError(response, data, error);
+        return data;
+    }
+    async ls(path) {
+        path = this.formatPath(path);
+        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)) {
+            throw new Error(JSON.stringify({ error: "Directory not found" }));
+        }
+        return data;
+    }
+    async cp(source, destination, { maxWait = 1000 * 60 * 60 } = {}) {
+        let process = await this.process.exec({
+            command: `cp -r ${source} ${destination}`,
+        });
+        process = await this.process.wait(process.pid, { maxWait, interval: 100 });
+        if (process.status === "failed") {
+            throw new Error(`Could not copy ${source} to ${destination} cause: ${process.logs}`);
+        }
+        return {
+            message: "Files copied",
+            source,
+            destination,
+        };
+    }
+    watch(path, callback, options) {
+        path = this.formatPath(path);
+        let closed = false;
+        const controller = new AbortController();
+        const start = async () => {
+            const query = {};
+            if (options?.ignore) {
+                query.ignore = options.ignore.join(",");
+            }
+            const { response, data, error } = await (0, index_js_1.getWatchFilesystemByPath)({
+                client: this.client,
+                path: { path },
+                query,
+                baseUrl: this.url,
+                parseAs: 'stream',
+                signal: controller.signal,
+            });
+            if (error)
+                throw new Error(error instanceof Error ? error.message : JSON.stringify(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 });
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop();
+                    for (const line of lines) {
+                        const trimmed = line.trim();
+                        if (!trimmed)
+                            continue;
+                        // Skip keepalive messages
+                        if (line.startsWith("[keepalive]")) {
+                            continue;
+                        }
+                        const fileEvent = JSON.parse(trimmed);
+                        if (options?.withContent && ["CREATE", "WRITE"].includes(fileEvent.op)) {
+                            try {
+                                let filePath = "";
+                                if (fileEvent.path.endsWith("/")) {
+                                    filePath = fileEvent.path + fileEvent.name;
+                                }
+                                else {
+                                    filePath = fileEvent.path + "/" + fileEvent.name;
+                                }
+                                const content = await this.read(filePath);
+                                await callback({ ...fileEvent, content });
+                            }
+                            catch {
+                                await callback({ ...fileEvent, content: undefined });
+                            }
+                        }
+                        else {
+                            await callback(fileEvent);
+                        }
+                    }
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+        };
+        start().catch((err) => {
+            // Suppress AbortError when closing
+            if (!(err && typeof err === 'object' && 'name' in err && err.name === 'AbortError')) {
+                if (options?.onError) {
+                    options.onError(err instanceof Error ? err : new Error(String(err)));
+                }
+            }
+            closed = true;
+            controller.abort();
+        });
+        return {
+            close: () => {
+                closed = true;
+                controller.abort();
+            },
+        };
+    }
+    formatPath(path) {
+        return path;
+    }
+}
+exports.SandboxFileSystem = SandboxFileSystem;

package/dist/cjs-browser/sandbox/filesystem/index.js

@@ -0,0 +1,18 @@
+"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("./filesystem.js"), exports);
+__exportStar(require("./types.js"), exports);

package/dist/cjs-browser/sandbox/filesystem/types.js

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

package/dist/cjs-browser/sandbox/index.js

@@ -0,0 +1,36 @@
+"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.putFilesystemByPath = exports.postProcess = exports.postNetworkProcessByPidMonitor = exports.getProcessByIdentifierLogsStream = exports.getProcessByIdentifierLogs = exports.getProcessByIdentifier = exports.getProcess = exports.getNetworkProcessByPidPorts = exports.getFilesystemByPath = exports.deleteProcessByIdentifierKill = exports.deleteProcessByIdentifier = exports.deleteNetworkProcessByPidMonitor = exports.deleteFilesystemByPath = void 0;
+var index_js_1 = require("./client/index.js");
+/* Export SDK functions */
+Object.defineProperty(exports, "deleteFilesystemByPath", { enumerable: true, get: function () { return index_js_1.deleteFilesystemByPath; } });
+Object.defineProperty(exports, "deleteNetworkProcessByPidMonitor", { enumerable: true, get: function () { return index_js_1.deleteNetworkProcessByPidMonitor; } });
+Object.defineProperty(exports, "deleteProcessByIdentifier", { enumerable: true, get: function () { return index_js_1.deleteProcessByIdentifier; } });
+Object.defineProperty(exports, "deleteProcessByIdentifierKill", { enumerable: true, get: function () { return index_js_1.deleteProcessByIdentifierKill; } });
+Object.defineProperty(exports, "getFilesystemByPath", { enumerable: true, get: function () { return index_js_1.getFilesystemByPath; } });
+Object.defineProperty(exports, "getNetworkProcessByPidPorts", { enumerable: true, get: function () { return index_js_1.getNetworkProcessByPidPorts; } });
+Object.defineProperty(exports, "getProcess", { enumerable: true, get: function () { return index_js_1.getProcess; } });
+Object.defineProperty(exports, "getProcessByIdentifier", { enumerable: true, get: function () { return index_js_1.getProcessByIdentifier; } });
+Object.defineProperty(exports, "getProcessByIdentifierLogs", { enumerable: true, get: function () { return index_js_1.getProcessByIdentifierLogs; } });
+Object.defineProperty(exports, "getProcessByIdentifierLogsStream", { enumerable: true, get: function () { return index_js_1.getProcessByIdentifierLogsStream; } });
+Object.defineProperty(exports, "postNetworkProcessByPidMonitor", { enumerable: true, get: function () { return index_js_1.postNetworkProcessByPidMonitor; } });
+Object.defineProperty(exports, "postProcess", { enumerable: true, get: function () { return index_js_1.postProcess; } });
+Object.defineProperty(exports, "putFilesystemByPath", { enumerable: true, get: function () { return index_js_1.putFilesystemByPath; } });
+__exportStar(require("./filesystem/index.js"), exports);
+__exportStar(require("./sandbox.js"), exports);
+__exportStar(require("./types.js"), exports);
+// Re-export everything from client except ClientOptions to avoid conflict

package/dist/cjs-browser/sandbox/network/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("./network.js"), exports);

package/dist/cjs-browser/sandbox/network/network.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxNetwork = void 0;
+const action_js_1 = require("../action.js");
+class SandboxNetwork extends action_js_1.SandboxAction {
+    constructor(sandbox) {
+        super(sandbox);
+    }
+}
+exports.SandboxNetwork = SandboxNetwork;

package/dist/cjs-browser/sandbox/preview.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxPreviews = exports.SandboxPreview = exports.SandboxPreviewTokens = exports.SandboxPreviewToken = void 0;
+const index_js_1 = require("../client/index.js");
+class SandboxPreviewToken {
+    previewToken;
+    constructor(previewToken) {
+        this.previewToken = previewToken;
+    }
+    get value() {
+        return this.previewToken.spec?.token ?? "";
+    }
+    get expiresAt() {
+        return this.previewToken.spec?.expiresAt ?? new Date();
+    }
+    get expired() {
+        return this.previewToken.spec?.expired ?? false;
+    }
+}
+exports.SandboxPreviewToken = SandboxPreviewToken;
+class SandboxPreviewTokens {
+    preview;
+    constructor(preview) {
+        this.preview = preview;
+    }
+    get previewName() {
+        return this.preview.metadata?.name ?? "";
+    }
+    get resourceName() {
+        return this.preview.metadata?.resourceName ?? "";
+    }
+    async create(expiresAt) {
+        const { data } = await (0, index_js_1.createSandboxPreviewToken)({
+            path: {
+                sandboxName: this.resourceName,
+                previewName: this.previewName,
+            },
+            body: {
+                spec: {
+                    expiresAt: expiresAt.toISOString(),
+                },
+            },
+            throwOnError: true,
+        });
+        return new SandboxPreviewToken(data);
+    }
+    async list() {
+        const { data } = await (0, index_js_1.listSandboxPreviewTokens)({
+            path: {
+                sandboxName: this.resourceName,
+                previewName: this.previewName,
+            },
+            throwOnError: true,
+        });
+        return data.map((token) => new SandboxPreviewToken(token));
+    }
+    async delete(tokenName) {
+        const { data } = await (0, index_js_1.deleteSandboxPreviewToken)({
+            path: {
+                sandboxName: this.resourceName,
+                previewName: this.previewName,
+                tokenName,
+            },
+            throwOnError: true,
+        });
+        return data;
+    }
+}
+exports.SandboxPreviewTokens = SandboxPreviewTokens;
+class SandboxPreview {
+    preview;
+    tokens;
+    constructor(preview) {
+        this.preview = preview;
+        this.tokens = new SandboxPreviewTokens(this);
+    }
+    get name() {
+        return this.preview.metadata?.name ?? "";
+    }
+    get metadata() {
+        return this.preview.metadata;
+    }
+    get spec() {
+        return this.preview.spec;
+    }
+}
+exports.SandboxPreview = SandboxPreview;
+class SandboxPreviews {
+    sandbox;
+    constructor(sandbox) {
+        this.sandbox = sandbox;
+    }
+    get sandboxName() {
+        return this.sandbox.metadata?.name ?? "";
+    }
+    async list() {
+        const { data } = await (0, index_js_1.listSandboxPreviews)({
+            path: {
+                sandboxName: this.sandboxName,
+            },
+            throwOnError: true,
+        });
+        return data.map((preview) => new SandboxPreview(preview));
+    }
+    async create(preview) {
+        const { data } = await (0, index_js_1.createSandboxPreview)({
+            path: {
+                sandboxName: this.sandboxName,
+            },
+            body: preview,
+            throwOnError: true,
+        });
+        return new SandboxPreview(data);
+    }
+    async createIfNotExists(preview) {
+        try {
+            const previewInstance = await this.get(preview.metadata?.name ?? "");
+            return previewInstance;
+        }
+        catch (e) {
+            if (typeof e === "object" && e !== null && "code" in e && e.code === 404) {
+                return this.create(preview);
+            }
+            throw e;
+        }
+    }
+    async get(previewName) {
+        const { data } = await (0, index_js_1.getSandboxPreview)({
+            path: {
+                sandboxName: this.sandboxName,
+                previewName,
+            },
+            throwOnError: true,
+        });
+        return new SandboxPreview(data);
+    }
+    async delete(previewName) {
+        const { data } = await (0, index_js_1.deleteSandboxPreview)({
+            path: {
+                sandboxName: this.sandboxName,
+                previewName,
+            },
+            throwOnError: true,
+        });
+        return data;
+    }
+}
+exports.SandboxPreviews = SandboxPreviews;

package/dist/cjs-browser/sandbox/process/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("./process.js"), exports);

package/dist/cjs-browser/sandbox/process/process.js

@@ -0,0 +1,189 @@
+"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();
+        void (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 result = await reader.read();
+                    if (result.done)
+                        break;
+                    if (result.value && result.value instanceof Uint8Array) {
+                        buffer += decoder.decode(result.value, { stream: true });
+                    }
+                    const lines = buffer.split(/\r?\n/);
+                    buffer = lines.pop();
+                    for (const line of lines) {
+                        if (line.startsWith("[keepalive]")) {
+                            continue;
+                        }
+                        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 && typeof err === 'object' && 'name' in err && err.name !== 'AbortError') {
+                    console.error("Stream error:", err);
+                    throw new Error(err instanceof Error ? err.message : 'Unknown stream error');
+                }
+            }
+        })();
+        return {
+            close: () => controller.abort(),
+        };
+    }
+    async exec(process) {
+        let onLog;
+        if ('onLog' in process && process.onLog) {
+            onLog = process.onLog;
+            delete process.onLog;
+        }
+        // Store original wait_for_completion setting
+        const shouldWaitForCompletion = process.waitForCompletion;
+        // Always start process without wait_for_completion to avoid server-side blocking
+        if (shouldWaitForCompletion && onLog) {
+            process.waitForCompletion = false;
+        }
+        const { response, data, error } = await (0, index_js_1.postProcess)({
+            body: process,
+            baseUrl: this.url,
+            client: this.client,
+        });
+        this.handleResponseError(response, data, error);
+        let result = data;
+        // Handle wait_for_completion with parallel log streaming
+        if (shouldWaitForCompletion && onLog) {
+            const streamControl = this.streamLogs(result.pid, { onLog });
+            try {
+                // Wait for process completion
+                result = await this.wait(result.pid, { interval: 500, maxWait: 1000 * 60 * 60 });
+            }
+            finally {
+                // Clean up log streaming
+                if (streamControl) {
+                    streamControl.close();
+                }
+            }
+        }
+        else {
+            // For non-blocking execution, set up log streaming immediately if requested
+            if (onLog) {
+                const streamControl = this.streamLogs(result.pid, { onLog });
+                return {
+                    ...result,
+                    close() {
+                        if (streamControl) {
+                            streamControl.close();
+                        }
+                    },
+                };
+            }
+        }
+        return { ...result, close: () => { } };
+    }
+    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;
+    }
+    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;
+    }
+    async stop(identifier) {
+        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;
+    }
+    async kill(identifier) {
+        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;
+    }
+    async logs(identifier, type = "all") {
+        const { response, data, error } = await (0, index_js_1.getProcessByIdentifierLogs)({
+            path: { identifier },
+            baseUrl: this.url,
+            client: this.client,
+        });
+        this.handleResponseError(response, data, error);
+        if (type === "all") {
+            return data?.logs || "";
+        }
+        else if (type === "stdout") {
+            return data?.stdout || "";
+        }
+        else if (type === "stderr") {
+            return data?.stderr || "";
+        }
+        throw new Error("Unsupported log type");
+    }
+}
+exports.SandboxProcess = SandboxProcess;