@blaxel/core 0.2.49-dev.214 → 0.2.49-dev1

package/dist/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;

package/dist/sandbox/sandbox.d.ts

@@ -0,0 +1,33 @@
+import { Sandbox as SandboxModel } from "../client/index.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 { SandboxConfiguration, SandboxCreateConfiguration, SandboxUpdateMetadata, SessionWithToken } from "./types.js";
+export declare class SandboxInstance {
+    private sandbox;
+    fs: SandboxFileSystem;
+    network: SandboxNetwork;
+    process: SandboxProcess;
+    previews: SandboxPreviews;
+    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;
+    get spec(): import("../client/types.gen.js").SandboxSpec | undefined;
+    wait({ maxWait, interval }?: {
+        maxWait?: number;
+        interval?: number;
+    }): Promise<this>;
+    static create(sandbox?: SandboxModel | SandboxCreateConfiguration, { safe }?: {
+        safe?: boolean;
+    }): Promise<SandboxInstance>;
+    static get(sandboxName: string): Promise<SandboxInstance>;
+    static list(): Promise<SandboxInstance[]>;
+    static delete(sandboxName: string): Promise<SandboxModel>;
+    static updateMetadata(sandboxName: string, metadata: SandboxUpdateMetadata): Promise<SandboxInstance>;
+    static createIfNotExists(sandbox: SandboxModel | SandboxCreateConfiguration): Promise<SandboxInstance>;
+    static fromSession(session: SessionWithToken): Promise<SandboxInstance>;
+}

package/dist/sandbox/sandbox.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxInstance = void 0;
+const uuid_1 = require("uuid");
+const index_js_1 = require("../client/index.js");
+const logger_js_1 = require("../common/logger.js");
+const settings_js_1 = require("../common/settings.js");
+const index_js_2 = require("./filesystem/index.js");
+const index_js_3 = require("./network/index.js");
+const preview_js_1 = require("./preview.js");
+const index_js_4 = require("./process/index.js");
+const session_js_1 = require("./session.js");
+const types_js_1 = require("./types.js");
+class SandboxInstance {
+    sandbox;
+    fs;
+    network;
+    process;
+    previews;
+    sessions;
+    constructor(sandbox) {
+        this.sandbox = sandbox;
+        this.fs = new index_js_2.SandboxFileSystem(sandbox);
+        this.network = new index_js_3.SandboxNetwork(sandbox);
+        this.process = new index_js_4.SandboxProcess(sandbox);
+        this.previews = new preview_js_1.SandboxPreviews(sandbox);
+        this.sessions = new session_js_1.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_js_1.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_js_1.settings.env;
+        const defaultName = `sandbox-${(0, uuid_1.v4)().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 = (0, types_js_1.normalizePorts)(sandbox.ports);
+            const envs = (0, types_js_1.normalizeEnvs)(sandbox.envs);
+            const volumes = (0, types_js_1.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 (0, index_js_1.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 (0, index_js_1.getSandbox)({
+            path: {
+                sandboxName,
+            },
+            throwOnError: true,
+        });
+        return new SandboxInstance(data);
+    }
+    static async list() {
+        const { data } = await (0, index_js_1.listSandboxes)({ throwOnError: true });
+        return data.map((sandbox) => new SandboxInstance(sandbox));
+    }
+    static async delete(sandboxName) {
+        const { data } = await (0, index_js_1.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 (0, index_js_1.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);
+    }
+}
+exports.SandboxInstance = SandboxInstance;

package/dist/sandbox/session.d.ts

@@ -0,0 +1,27 @@
+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>;
+    createIfExpired(options?: SessionCreateOptions, delta?: number): Promise<{
+        name: string;
+        url: string;
+        token: string;
+        expiresAt: string | Date;
+    }>;
+    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,123 @@
+"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,
+                expires: expiresAt.toISOString(),
+                requestHeaders: options.requestHeaders,
+                responseHeaders: options.responseHeaders,
+            },
+        };
+        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 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 (0, index_js_1.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 (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,51 @@
+import { Port, Sandbox, VolumeAttachment } from "../client/types.gen";
+import { PostProcessResponse, ProcessRequest } from "./client";
+export interface SessionCreateOptions {
+    expiresAt?: Date;
+    responseHeaders?: Record<string, string>;
+    requestHeaders?: Record<string, string>;
+}
+export interface SessionWithToken {
+    name: string;
+    url: string;
+    token: string;
+    expiresAt: Date;
+}
+export interface EnvVar {
+    name: string;
+    value: string;
+}
+export interface VolumeBinding {
+    name: string;
+    mountPath: string;
+    readOnly?: boolean;
+}
+export type SandboxConfiguration = {
+    forceUrl?: string;
+    headers?: Record<string, string>;
+    params?: Record<string, string>;
+} & Sandbox;
+export type SandboxUpdateMetadata = {
+    labels?: Record<string, string>;
+    displayName?: string;
+};
+export type SandboxCreateConfiguration = {
+    name?: string;
+    image?: string;
+    memory?: number;
+    ports?: (Port | Record<string, any>)[];
+    envs?: EnvVar[];
+    volumes?: (VolumeBinding | VolumeAttachment)[];
+    ttl?: string;
+    expires?: Date;
+    region?: string;
+};
+export declare function normalizePorts(ports?: (Port | Record<string, any>)[]): Port[] | undefined;
+export declare function normalizeEnvs(envs?: EnvVar[]): EnvVar[] | undefined;
+export declare function normalizeVolumes(volumes?: (VolumeBinding | VolumeAttachment)[]): VolumeAttachment[] | undefined;
+export type ProcessRequestWithLog = ProcessRequest & {
+    onLog?: (log: string) => void;
+};
+export type ProcessResponseWithLog = PostProcessResponse & {
+    close: () => void;
+};

package/dist/sandbox/types.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePorts = normalizePorts;
+exports.normalizeEnvs = normalizeEnvs;
+exports.normalizeVolumes = normalizeVolumes;
+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;
+}
+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;
+}
+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;
+}