@toolsdk.ai/registry 1.0.118 → 1.0.119

package/dist/domains/sandbox/clients/e2b-client.d.ts

@@ -0,0 +1,19 @@
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { SandboxClient } from "../sandbox-types";
+/**
+ * E2B Sandbox Client
+ * Implements SandboxClient interface for E2B provider
+ */
+export declare class E2BSandboxClient implements SandboxClient {
+    private sandbox;
+    private initializing;
+    private readonly packageRepository;
+    private readonly apiKey;
+    private readonly runtime;
+    constructor(runtime?: "node" | "python" | "java" | "go");
+    initialize(): Promise<void>;
+    private executeCode;
+    listTools(packageKey: string): Promise<Tool[]>;
+    executeTool(packageKey: string, toolName: string, argumentsObj: Record<string, unknown>, envs?: Record<string, string>): Promise<unknown>;
+    destroy(): Promise<void>;
+}

package/dist/domains/sandbox/clients/e2b-client.js

@@ -0,0 +1,130 @@
+import path from "node:path";
+import { Sandbox } from "@e2b/code-interpreter";
+import { getE2BConfig } from "../../../shared/config/environment";
+import { getDirname } from "../../../shared/utils/file-util";
+import { extractLastOuterJSON } from "../../../shared/utils/string-util";
+import { PackageRepository } from "../../package/package-repository";
+import { generateMCPTestCode } from "../sandbox-utils";
+/**
+ * E2B Sandbox Client
+ * Implements SandboxClient interface for E2B provider
+ */
+export class E2BSandboxClient {
+    constructor(runtime = "node") {
+        this.sandbox = null;
+        this.initializing = null;
+        const __dirname = getDirname(import.meta.url);
+        const packagesDir = path.join(__dirname, "../../../../packages");
+        this.packageRepository = new PackageRepository(packagesDir);
+        const config = getE2BConfig();
+        this.apiKey = config.apiKey;
+        this.runtime = runtime;
+    }
+    async initialize() {
+        if (this.sandbox) {
+            return;
+        }
+        if (this.initializing) {
+            await this.initializing;
+            return;
+        }
+        this.initializing = (async () => {
+            try {
+                const templateMap = {
+                    python: "mcp-sandbox-python",
+                    node: "mcp-sandbox-node",
+                    java: "mcp-sandbox-java",
+                    go: "mcp-sandbox-go",
+                };
+                const template = templateMap[this.runtime];
+                if (!template) {
+                    throw new Error(`[E2BSandboxClient] Unsupported runtime: ${this.runtime}`);
+                }
+                this.sandbox = await Sandbox.create(template, {
+                    apiKey: this.apiKey,
+                    timeoutMs: 30 * 1000,
+                });
+                console.log(`[E2BSandboxClient] Sandbox (${template}) created successfully`);
+            }
+            finally {
+                this.initializing = null;
+            }
+        })();
+        await this.initializing;
+    }
+    async executeCode(code) {
+        var _a;
+        if (!this.sandbox) {
+            throw new Error("Sandbox not initialized. Call initialize() first.");
+        }
+        // Map runtime to language string expected by the sandbox
+        const runtimeToLanguage = {
+            node: "javascript",
+            python: "python",
+            java: "java",
+            go: "go",
+        };
+        const language = runtimeToLanguage[this.runtime] || "javascript";
+        const result = await this.sandbox.runCode(code, { language });
+        if (result.error) {
+            return {
+                exitCode: 1,
+                result: result.error.toString(),
+            };
+        }
+        const stdout = ((_a = result.logs) === null || _a === void 0 ? void 0 : _a.stdout) || [];
+        const output = stdout[stdout.length - 1] || "";
+        return {
+            exitCode: 0,
+            result: output,
+        };
+    }
+    async listTools(packageKey) {
+        const mcpServerConfig = this.packageRepository.getPackageConfig(packageKey);
+        const testCode = generateMCPTestCode(mcpServerConfig, "listTools");
+        const response = await this.executeCode(testCode);
+        if (response.exitCode !== 0) {
+            throw new Error(`Failed to list tools: ${response.result}`);
+        }
+        const parsedResultStr = extractLastOuterJSON(response.result);
+        const result = JSON.parse(parsedResultStr);
+        return result.tools;
+    }
+    async executeTool(packageKey, toolName, argumentsObj, envs) {
+        const mcpServerConfig = this.packageRepository.getPackageConfig(packageKey);
+        const testCode = generateMCPTestCode(mcpServerConfig, "executeTool", toolName, argumentsObj, envs);
+        const response = await this.executeCode(testCode);
+        if (response.exitCode !== 0) {
+            throw new Error(`Failed to execute tool: ${response.result}`);
+        }
+        const parsedResultStr = extractLastOuterJSON(response.result);
+        const result = JSON.parse(parsedResultStr);
+        if (result.isError) {
+            console.error("[E2BSandboxClient] Tool execution error:", result.errorMessage);
+            throw new Error(result.errorMessage);
+        }
+        return result;
+    }
+    async destroy() {
+        if (!this.sandbox) {
+            return;
+        }
+        const sandboxToDelete = this.sandbox;
+        this.sandbox = null; // Clear immediately to avoid duplicate calls
+        // Asynchronously clean up sandbox without blocking result return
+        sandboxToDelete
+            .kill()
+            .then(() => {
+            console.log("[E2BSandboxClient] Sandbox destroyed successfully");
+        })
+            .catch((err) => {
+            const errorMessage = err.message;
+            if (errorMessage.includes("not found")) {
+                console.log("[E2BSandboxClient] Sandbox already destroyed (not found on platform)");
+            }
+            else {
+                console.warn("[E2BSandboxClient] Warning: Could not destroy sandbox:", errorMessage);
+            }
+        });
+    }
+}

package/dist/domains/sandbox/sandbox-factory.js

@@ -1,4 +1,5 @@
 import { DaytonaSandboxClient } from "./clients/daytona-client";
+import { E2BSandboxClient } from "./clients/e2b-client";
 import { SandockSandboxClient } from "./clients/sandock-client";
 /**
  * Sandbox Factory
@@ -13,7 +14,7 @@ export class SandboxFactory {
             case "DAYTONA":
                 return new DaytonaSandboxClient(runtime);
             case "E2B":
-                throw new Error("E2B sandbox provider is not yet implemented");
+                return new E2BSandboxClient(runtime);
             case "LOCAL":
                 throw new Error("LOCAL provider should not use sandbox client");
             default:

package/dist/shared/config/environment.d.ts

@@ -8,6 +8,9 @@ export declare function getSandockConfig(): {
     apiKey: string;
     apiUrl: string;
 };
+export declare function getE2BConfig(): {
+    apiKey: string;
+};
 export declare function getMeiliSearchConfig(): {
     host: string;
     apiKey: string | null;

package/dist/shared/config/environment.js

@@ -26,6 +26,11 @@ export function getSandockConfig() {
         apiUrl: process.env.SANDOCK_API_URL || "https://sandock.ai",
     };
 }
+export function getE2BConfig() {
+    return {
+        apiKey: process.env.E2B_API_KEY || "",
+    };
+}
 export function getMeiliSearchConfig() {
     return {
         host: process.env.MEILI_HTTP_ADDR || "http://localhost:7700",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolsdk.ai/registry",
-  "version": "1.0.118",
+  "version": "1.0.119",
   "description": "An Open, Structured, and Standard Registry for MCP Servers and Packages.",
   "keywords": [
     "mcp",