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

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

@@ -0,0 +1,180 @@
+"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.process = new index_js_4.SandboxProcess(sandbox);
+        this.fs = new index_js_2.SandboxFileSystem(sandbox, this.process);
+        this.network = new index_js_3.SandboxNetwork(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 || 'lifecycle' 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;
+            const lifecycle = sandbox.lifecycle;
+            sandbox = {
+                metadata: { name: sandbox.name },
+                spec: {
+                    region: region,
+                    runtime: {
+                        image: sandbox.image,
+                        memory: sandbox.memory,
+                        ports: ports,
+                        envs: envs,
+                        generation: "mk3",
+                    },
+                    volumes: volumes,
+                    lifecycle: lifecycle
+                }
+            };
+            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/cjs-browser/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/cjs-browser/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;
+}

package/dist/cjs-browser/telemetry/telemetry.js

@@ -0,0 +1,80 @@
+"use strict";
+// @blaxel/core/src/telemetry/interface.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.telemetryRegistry = void 0;
+exports.startSpan = startSpan;
+exports.withSpan = withSpan;
+exports.flush = flush;
+/**
+ * No-operation implementation of Span
+ */
+class NoopSpan {
+    setAttribute() { }
+    setAttributes() { }
+    recordException() { }
+    setStatus() { }
+    end() { }
+    getContext() { return null; }
+}
+/**
+ * No-operation implementation of TelemetryProvider
+ */
+class NoopTelemetryProvider {
+    startSpan() {
+        return new NoopSpan();
+    }
+    flush() {
+        return Promise.resolve();
+    }
+}
+/**
+ * Registry for managing the global telemetry provider
+ */
+class TelemetryRegistry {
+    static instance;
+    provider = new NoopTelemetryProvider();
+    constructor() { }
+    static getInstance() {
+        if (!TelemetryRegistry.instance) {
+            TelemetryRegistry.instance = new TelemetryRegistry();
+        }
+        return TelemetryRegistry.instance;
+    }
+    /**
+     * Register a telemetry provider implementation
+     */
+    registerProvider(provider) {
+        this.provider = provider;
+    }
+    /**
+     * Get the current telemetry provider
+     */
+    getProvider() {
+        return this.provider;
+    }
+}
+// Export singleton instance
+exports.telemetryRegistry = TelemetryRegistry.getInstance();
+// Convenience functions that delegate to the provider
+/**
+ * Create a span with the registered provider
+ */
+function startSpan(name, options) {
+    return exports.telemetryRegistry.getProvider().startSpan(name, options);
+}
+async function withSpan(name, fn, options) {
+    const span = startSpan(name, options);
+    try {
+        const result = await fn();
+        span.end();
+        return result;
+    }
+    catch (error) {
+        span.recordException(error);
+        span.end();
+        throw error;
+    }
+}
+async function flush() {
+    await exports.telemetryRegistry.getProvider().flush();
+}

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getToolMetadata = exports.blTool = exports.blTools = exports.BLTools = exports.getTool = void 0;
+const index_js_1 = require("../cache/index.js");
+const client_js_1 = require("../client/client.js");
+const internal_js_1 = require("../common/internal.js");
+const mcpTool_js_1 = require("./mcpTool.js");
+const getTool = async (name, options) => {
+    return await (0, mcpTool_js_1.getMcpTool)(name, options);
+};
+exports.getTool = getTool;
+class BLTools {
+    toolNames;
+    constructor(toolNames) {
+        this.toolNames = toolNames;
+    }
+}
+exports.BLTools = BLTools;
+const blTools = (names) => {
+    return new BLTools(names);
+};
+exports.blTools = blTools;
+const blTool = (name) => {
+    return new BLTools([name]);
+};
+exports.blTool = blTool;
+const getToolMetadata = async (tool) => {
+    const forcedUrl = (0, internal_js_1.getForcedUrl)('function', tool);
+    if (forcedUrl) {
+        return {
+            metadata: {
+                name: tool,
+            },
+            spec: {
+                runtime: {
+                    type: "mcp",
+                },
+            },
+        };
+    }
+    const cacheData = await (0, index_js_1.findFromCache)("Function", tool);
+    if (cacheData) {
+        return cacheData;
+    }
+    const { data } = await (0, client_js_1.getFunction)({
+        path: {
+            functionName: tool,
+        },
+    });
+    return data || null;
+};
+exports.getToolMetadata = getToolMetadata;