@blaxel/core 0.2.36-dev.185 → 0.2.36-dev.190

package/dist/esm/sandbox/preview.js

@@ -0,0 +1,141 @@
+import { createSandboxPreview, createSandboxPreviewToken, deleteSandboxPreview, deleteSandboxPreviewToken, getSandboxPreview, listSandboxPreviews, listSandboxPreviewTokens } from "../client/index.js";
+export 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;
+    }
+}
+export 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 createSandboxPreviewToken({
+            path: {
+                sandboxName: this.resourceName,
+                previewName: this.previewName,
+            },
+            body: {
+                spec: {
+                    expiresAt: expiresAt.toISOString(),
+                },
+            },
+            throwOnError: true,
+        });
+        return new SandboxPreviewToken(data);
+    }
+    async list() {
+        const { data } = await listSandboxPreviewTokens({
+            path: {
+                sandboxName: this.resourceName,
+                previewName: this.previewName,
+            },
+            throwOnError: true,
+        });
+        return data.map((token) => new SandboxPreviewToken(token));
+    }
+    async delete(tokenName) {
+        const { data } = await deleteSandboxPreviewToken({
+            path: {
+                sandboxName: this.resourceName,
+                previewName: this.previewName,
+                tokenName,
+            },
+            throwOnError: true,
+        });
+        return data;
+    }
+}
+export 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;
+    }
+}
+export class SandboxPreviews {
+    sandbox;
+    constructor(sandbox) {
+        this.sandbox = sandbox;
+    }
+    get sandboxName() {
+        return this.sandbox.metadata?.name ?? "";
+    }
+    async list() {
+        const { data } = await listSandboxPreviews({
+            path: {
+                sandboxName: this.sandboxName,
+            },
+            throwOnError: true,
+        });
+        return data.map((preview) => new SandboxPreview(preview));
+    }
+    async create(preview) {
+        const { data } = await 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 getSandboxPreview({
+            path: {
+                sandboxName: this.sandboxName,
+                previewName,
+            },
+            throwOnError: true,
+        });
+        return new SandboxPreview(data);
+    }
+    async delete(previewName) {
+        const { data } = await deleteSandboxPreview({
+            path: {
+                sandboxName: this.sandboxName,
+                previewName,
+            },
+            throwOnError: true,
+        });
+        return data;
+    }
+}

package/dist/esm/sandbox/process/index.js

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

package/dist/esm/sandbox/process/process.js

@@ -0,0 +1,185 @@
+import { settings } from "../../common/settings.js";
+import { SandboxAction } from "../action.js";
+import { deleteProcessByIdentifier, deleteProcessByIdentifierKill, getProcess, getProcessByIdentifier, getProcessByIdentifierLogs, postProcess } from "../client/index.js";
+export class SandboxProcess extends SandboxAction {
+    constructor(sandbox) {
+        super(sandbox);
+    }
+    streamLogs(identifier, options) {
+        const controller = new AbortController();
+        void (async () => {
+            try {
+                const headers = this.sandbox.forceUrl ? this.sandbox.headers : 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 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 getProcessByIdentifier({
+            path: { identifier },
+            baseUrl: this.url,
+            client: this.client,
+        });
+        this.handleResponseError(response, data, error);
+        return data;
+    }
+    async list() {
+        const { response, data, error } = await getProcess({
+            baseUrl: this.url,
+            client: this.client,
+        });
+        this.handleResponseError(response, data, error);
+        return data;
+    }
+    async stop(identifier) {
+        const { response, data, error } = await deleteProcessByIdentifier({
+            path: { identifier },
+            baseUrl: this.url,
+            client: this.client,
+        });
+        this.handleResponseError(response, data, error);
+        return data;
+    }
+    async kill(identifier) {
+        const { response, data, error } = await 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 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");
+    }
+}

package/dist/esm/sandbox/sandbox.js

@@ -0,0 +1,174 @@
+import { v4 as uuidv4 } from "uuid";
+import { createSandbox, deleteSandbox, getSandbox, listSandboxes, updateSandbox } from "../client/index.js";
+import { logger } from "../common/logger.js";
+import { settings } from "../common/settings.js";
+import { SandboxFileSystem } from "./filesystem/index.js";
+import { SandboxNetwork } from "./network/index.js";
+import { SandboxPreviews } from "./preview.js";
+import { SandboxProcess } from "./process/index.js";
+import { SandboxSessions } from "./session.js";
+import { normalizeEnvs, normalizePorts, normalizeVolumes } from "./types.js";
+export class SandboxInstance {
+    sandbox;
+    fs;
+    network;
+    process;
+    previews;
+    sessions;
+    constructor(sandbox) {
+        this.sandbox = sandbox;
+        this.fs = new SandboxFileSystem(sandbox);
+        this.network = new SandboxNetwork(sandbox);
+        this.process = new SandboxProcess(sandbox);
+        this.previews = new SandboxPreviews(sandbox);
+        this.sessions = new SandboxSessions(sandbox);
+    }
+    get metadata() {
+        return this.sandbox.metadata;
+    }
+    get status() {
+        return this.sandbox.status;
+    }
+    get events() {
+        return this.sandbox.events;
+    }
+    get spec() {
+        return this.sandbox.spec;
+    }
+    /* eslint-disable */
+    async wait({ maxWait = 60000, interval = 1000 } = {}) {
+        logger.warn("⚠️  Warning: sandbox.wait() is deprecated. You don't need to wait for the sandbox to be deployed anymore.");
+        return this;
+    }
+    static async create(sandbox, { safe = true } = {}) {
+        const env = settings.env;
+        const defaultName = `sandbox-${uuidv4().replace(/-/g, '').substring(0, 8)}`;
+        const defaultImage = `blaxel/${env}-base:latest`;
+        const defaultMemory = 4096;
+        // Handle SandboxCreateConfiguration or simple dict with name/image/memory/ports/envs/volumes keys
+        if (!sandbox || 'name' in sandbox || 'image' in sandbox || 'memory' in sandbox || 'ports' in sandbox || 'envs' in sandbox || 'volumes' in sandbox) {
+            if (!sandbox)
+                sandbox = {};
+            if (!sandbox.name)
+                sandbox.name = defaultName;
+            if (!sandbox.image)
+                sandbox.image = defaultImage;
+            if (!sandbox.memory)
+                sandbox.memory = defaultMemory;
+            const ports = normalizePorts(sandbox.ports);
+            const envs = normalizeEnvs(sandbox.envs);
+            const volumes = normalizeVolumes(sandbox.volumes);
+            const ttl = sandbox.ttl;
+            const expires = sandbox.expires;
+            const region = sandbox.region;
+            sandbox = {
+                metadata: { name: sandbox.name },
+                spec: {
+                    region: region,
+                    runtime: {
+                        image: sandbox.image,
+                        memory: sandbox.memory,
+                        ports: ports,
+                        envs: envs,
+                        generation: "mk3",
+                    },
+                    volumes: volumes
+                }
+            };
+            if (ttl) {
+                sandbox.spec.runtime.ttl = ttl;
+            }
+            if (expires) {
+                sandbox.spec.runtime.expires = expires.toISOString();
+            }
+        }
+        sandbox = sandbox;
+        if (!sandbox.metadata) {
+            sandbox.metadata = { name: defaultName };
+        }
+        if (!sandbox.spec) {
+            sandbox.spec = { runtime: { image: defaultImage, memory: defaultMemory } };
+        }
+        if (!sandbox.spec.runtime) {
+            sandbox.spec.runtime = { image: defaultImage, memory: defaultMemory };
+        }
+        sandbox.spec.runtime.image = sandbox.spec.runtime.image || defaultImage;
+        sandbox.spec.runtime.memory = sandbox.spec.runtime.memory || defaultMemory;
+        sandbox.spec.runtime.generation = sandbox.spec.runtime.generation || "mk3";
+        const { data } = await createSandbox({
+            body: sandbox,
+            throwOnError: true,
+        });
+        const instance = new SandboxInstance(data);
+        // TODO remove this part once we have a better way to handle this
+        if (safe) {
+            try {
+                await instance.fs.ls('/');
+            }
+            catch { }
+        }
+        return instance;
+    }
+    static async get(sandboxName) {
+        const { data } = await getSandbox({
+            path: {
+                sandboxName,
+            },
+            throwOnError: true,
+        });
+        return new SandboxInstance(data);
+    }
+    static async list() {
+        const { data } = await listSandboxes({ throwOnError: true });
+        return data.map((sandbox) => new SandboxInstance(sandbox));
+    }
+    static async delete(sandboxName) {
+        const { data } = await deleteSandbox({
+            path: {
+                sandboxName,
+            },
+            throwOnError: true,
+        });
+        return data;
+    }
+    static async updateMetadata(sandboxName, metadata) {
+        const sandbox = await SandboxInstance.get(sandboxName);
+        const body = { ...sandbox.sandbox, metadata: { ...sandbox.metadata, ...metadata } };
+        const { data } = await updateSandbox({
+            path: { sandboxName },
+            body,
+            throwOnError: true,
+        });
+        const instance = new SandboxInstance(data);
+        return instance;
+    }
+    static async createIfNotExists(sandbox) {
+        try {
+            return await SandboxInstance.create(sandbox);
+        }
+        catch (e) {
+            if (typeof e === "object" && e !== null && "code" in e && (e.code === 409 || e.code === 'SANDBOX_ALREADY_EXISTS')) {
+                const name = 'name' in sandbox ? sandbox.name : sandbox.metadata?.name;
+                if (!name) {
+                    throw new Error("Sandbox name is required");
+                }
+                const sandboxInstance = await SandboxInstance.get(name);
+                return sandboxInstance;
+            }
+            throw e;
+        }
+    }
+    /* eslint-disable */
+    static async fromSession(session) {
+        // Create a minimal sandbox configuration for session-based access
+        const sandboxName = session.name.includes("-") ? session.name.split("-")[0] : session.name;
+        const sandbox = {
+            metadata: { name: sandboxName },
+            forceUrl: session.url,
+            headers: { "X-Blaxel-Preview-Token": session.token },
+            params: { bl_preview_token: session.token }
+        };
+        // Create instance using constructor instead of direct property assignment
+        return new SandboxInstance(sandbox);
+    }
+}

package/dist/esm/sandbox/session.js

@@ -0,0 +1,119 @@
+import { createSandboxPreview, deleteSandboxPreview, getSandboxPreview, listSandboxPreviews, listSandboxPreviewTokens } from "../client/index.js";
+import { SandboxPreview } from "./preview.js";
+export 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,
+                expires: expiresAt.toISOString(),
+                requestHeaders: options.requestHeaders,
+                responseHeaders: options.responseHeaders,
+            },
+        };
+        const { data } = await createSandboxPreview({
+            path: {
+                sandboxName: this.sandboxName,
+            },
+            body,
+            throwOnError: true,
+        });
+        const preview = new 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 createIfExpired(options = {}, delta = 1000 * 60 * 60) {
+        // First, list all sessions
+        const allSessions = await this.list();
+        // Variable to hold our final session
+        let sessionData;
+        const now = new Date();
+        const threshold = new Date(now.getTime() + delta);
+        // If no valid session exists, create a new one
+        if (allSessions.length > 0) {
+            sessionData = allSessions[0];
+            if (new Date(sessionData.expiresAt) < threshold) {
+                await this.delete(sessionData.name);
+                sessionData = await this.create(options);
+            }
+        }
+        else {
+            // Create a new session
+            sessionData = await this.create(options);
+        }
+        return sessionData;
+    }
+    async list() {
+        const { data } = await listSandboxPreviews({
+            path: {
+                sandboxName: this.sandboxName,
+            },
+            throwOnError: true,
+        });
+        if (data === null)
+            return [];
+        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 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 deleteSandboxPreview({
+            path: {
+                sandboxName: this.sandboxName,
+                previewName: name,
+            },
+            throwOnError: true,
+        });
+        return data;
+    }
+    async getToken(previewName) {
+        const { data } = await listSandboxPreviewTokens({
+            path: {
+                sandboxName: this.sandboxName,
+                previewName,
+            },
+            throwOnError: true,
+        });
+        if (data.length === 0)
+            return null;
+        return data[0];
+    }
+}

package/dist/esm/sandbox/types.js

@@ -0,0 +1,76 @@
+export function normalizePorts(ports) {
+    if (!ports || ports.length === 0) {
+        return undefined;
+    }
+    const portObjects = [];
+    for (const port of ports) {
+        if (typeof port === 'object' && port !== null) {
+            if ('name' in port || 'target' in port || 'protocol' in port) {
+                // It's a Port-like object, ensure protocol defaults to HTTP
+                const normalizedPort = {
+                    name: typeof port.name === 'string' ? port.name : undefined,
+                    target: typeof port.target === 'number' ? port.target : undefined,
+                    protocol: typeof port.protocol === 'string' ? port.protocol : "HTTP"
+                };
+                portObjects.push(normalizedPort);
+            }
+            else {
+                throw new Error(`Invalid port type: ${typeof port}. Expected Port object or object with port properties.`);
+            }
+        }
+        else {
+            throw new Error(`Invalid port type: ${typeof port}. Expected Port object or object with port properties.`);
+        }
+    }
+    return portObjects;
+}
+export function normalizeEnvs(envs) {
+    if (!envs || envs.length === 0) {
+        return undefined;
+    }
+    const envObjects = [];
+    for (const env of envs) {
+        if (typeof env === 'object' && env !== null) {
+            // Validate that the object has the required keys
+            if (!('name' in env) || !('value' in env)) {
+                throw new Error(`Environment variable object must have 'name' and 'value' keys: ${JSON.stringify(env)}`);
+            }
+            if (typeof env.name !== 'string' || typeof env.value !== 'string') {
+                throw new Error(`Environment variable 'name' and 'value' must be strings: ${JSON.stringify(env)}`);
+            }
+            envObjects.push({ name: env.name, value: env.value });
+        }
+        else {
+            throw new Error(`Invalid env type: ${typeof env}. Expected object with 'name' and 'value' keys.`);
+        }
+    }
+    return envObjects;
+}
+export function normalizeVolumes(volumes) {
+    if (!volumes || volumes.length === 0) {
+        return undefined;
+    }
+    const volumeObjects = [];
+    for (const volume of volumes) {
+        if (typeof volume === 'object' && volume !== null) {
+            // Validate that the object has the required keys
+            if (!('name' in volume) || !('mountPath' in volume)) {
+                throw new Error(`Volume binding object must have 'name' and 'mountPath' keys: ${JSON.stringify(volume)}`);
+            }
+            if (typeof volume.name !== 'string' || typeof volume.mountPath !== 'string') {
+                throw new Error(`Volume binding 'name' and 'mountPath' must be strings: ${JSON.stringify(volume)}`);
+            }
+            // Convert VolumeBinding to VolumeAttachment format
+            const volumeAttachment = {
+                name: volume.name,
+                mountPath: volume.mountPath,
+                readOnly: 'readOnly' in volume ? volume.readOnly : false
+            };
+            volumeObjects.push(volumeAttachment);
+        }
+        else {
+            throw new Error(`Invalid volume type: ${typeof volume}. Expected object with 'name' and 'mountPath' keys.`);
+        }
+    }
+    return volumeObjects;
+}