@toolsdk.ai/registry 1.0.112 → 1.0.113

package/dist/api/package-handler.js

@@ -1,10 +1,13 @@
 import { createErrorResponse, createResponse } from "../utils";
 import { PackageSO } from "./package-so";
+const shouldUseSandbox = () => {
+    return process.env.USE_MCP_SANDBOX === "true";
+};
 export const packageHandler = {
     executeTool: async (c) => {
         const requestBody = await c.req.json();
         try {
-            const toolSO = new PackageSO();
+            const toolSO = new PackageSO(shouldUseSandbox());
             const result = await toolSO.executeTool(requestBody);
             const response = createResponse(result);
             return c.json(response, 200);
@@ -33,7 +36,7 @@ export const packageHandler = {
             return c.json(errorResponse, 200);
         }
         try {
-            const toolSO = new PackageSO();
+            const toolSO = new PackageSO(shouldUseSandbox());
             const result = await toolSO.getPackageDetail(packageName);
             const response = createResponse(result);
             return c.json(response, 200);
@@ -53,7 +56,7 @@ export const packageHandler = {
             return c.json(errorResponse, 200);
         }
         try {
-            const toolSO = new PackageSO();
+            const toolSO = new PackageSO(shouldUseSandbox());
             const result = await toolSO.listTools(packageName);
             const response = createResponse(result);
             return c.json(response, 200);

package/dist/api/package-so.d.ts

@@ -1,7 +1,19 @@
 import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import { MCPSandboxClient } from "../sandbox/mcp-sandbox-client.js";
 import type { MCPServerPackageConfig, ToolExecute } from "../types";
 export declare class PackageSO {
+    private useSandbox;
+    private sandboxClient;
+    private static sandboxInstances;
+    private static MAX_SANDBOXES;
+    private static IDLE_CLOSE_MS;
+    constructor(useSandbox?: boolean);
+    static acquireSandbox(key?: string): Promise<MCPSandboxClient>;
+    static releaseSandbox(key?: string): Promise<void>;
+    static cleanupSandboxInstances(): Promise<void>;
     executeTool(request: ToolExecute): Promise<unknown>;
+    private executeToolInSandbox;
     listTools(packageName: string): Promise<Tool[]>;
+    private listToolsInSandbox;
     getPackageDetail(packageName: string): Promise<MCPServerPackageConfig>;
 }

package/dist/api/package-so.js

@@ -1,11 +1,144 @@
 import fs from "node:fs";
 import path from "node:path";
 import { getMcpClient, getPackageConfigByKey, typedAllPackagesList } from "../helper.js";
+import { MCPSandboxClient } from "../sandbox/mcp-sandbox-client.js";
 import { getDirname } from "../utils";
 const __dirname = getDirname(import.meta.url);
 export class PackageSO {
+    constructor(useSandbox = false) {
+        this.useSandbox = false;
+        this.sandboxClient = null;
+        this.useSandbox = useSandbox;
+        if (useSandbox) {
+            const sandboxKey = "default";
+            const record = PackageSO.sandboxInstances.get(sandboxKey);
+            if (record) {
+                record.refCount++;
+                record.lastUsedAt = Date.now();
+                this.sandboxClient = record.client;
+                // Cancel all idle close timer
+                record.client.touch();
+            }
+            else {
+                // Create a new instance if none exists (subject to max limit)
+                this.sandboxClient = new MCPSandboxClient();
+                const newRecord = {
+                    client: this.sandboxClient,
+                    refCount: 1,
+                    lastUsedAt: Date.now(),
+                    idleCloseMs: PackageSO.IDLE_CLOSE_MS,
+                };
+                // Try to insert, evict LRU idle instance if MAX is reached
+                if (PackageSO.sandboxInstances.size >= PackageSO.MAX_SANDBOXES) {
+                    // Find the oldest idle instance (refCount === 0)
+                    let lruKey = null;
+                    let lruTime = Infinity;
+                    for (const [k, r] of PackageSO.sandboxInstances) {
+                        if (r.refCount === 0 && r.lastUsedAt < lruTime) {
+                            lruKey = k;
+                            lruTime = r.lastUsedAt;
+                        }
+                    }
+                    if (lruKey) {
+                        const evict = PackageSO.sandboxInstances.get(lruKey);
+                        // Immediately close and delete
+                        if (evict) {
+                            evict.client.kill().catch((e) => {
+                                console.error("[PackageSO] Error killing evicted sandbox:", e);
+                            });
+                            PackageSO.sandboxInstances.delete(lruKey);
+                        }
+                    }
+                    else {
+                        // No recyclable instances -> throw error to prevent exceeding system limit
+                        throw new Error("Cannot create new sandbox: max sandboxes reached and none are idle");
+                    }
+                }
+                PackageSO.sandboxInstances.set(sandboxKey, newRecord);
+            }
+        }
+    }
+    // Acquire / Release explicit APIs (for external or future use)
+    static async acquireSandbox(key = "default") {
+        const record = PackageSO.sandboxInstances.get(key);
+        if (record) {
+            record.refCount++;
+            record.lastUsedAt = Date.now();
+            record.client.touch();
+            return record.client;
+        }
+        // Create new instance (note MAX_SANDBOXES check, consistent with constructor logic)
+        if (PackageSO.sandboxInstances.size >= PackageSO.MAX_SANDBOXES) {
+            // Try to evict LRU idle instance
+            let lruKey = null;
+            let lruTime = Infinity;
+            for (const [k, r] of PackageSO.sandboxInstances) {
+                if (r.refCount === 0 && r.lastUsedAt < lruTime) {
+                    lruKey = k;
+                    lruTime = r.lastUsedAt;
+                }
+            }
+            if (lruKey) {
+                const evict = PackageSO.sandboxInstances.get(lruKey);
+                if (evict) {
+                    await evict.client
+                        .kill()
+                        .catch((e) => console.error("[PackageSO] Error killing evicted sandbox:", e));
+                    PackageSO.sandboxInstances.delete(lruKey);
+                }
+            }
+            else {
+                throw new Error("Cannot create new sandbox: max sandboxes reached and none are idle");
+            }
+        }
+        const client = new MCPSandboxClient();
+        const newRecord = {
+            client,
+            refCount: 1,
+            lastUsedAt: Date.now(),
+            idleCloseMs: PackageSO.IDLE_CLOSE_MS,
+        };
+        PackageSO.sandboxInstances.set(key, newRecord);
+        return client;
+    }
+    static async releaseSandbox(key = "default") {
+        const record = PackageSO.sandboxInstances.get(key);
+        if (!record)
+            return;
+        record.refCount = Math.max(0, record.refCount - 1);
+        record.lastUsedAt = Date.now();
+        if (record.refCount === 0) {
+            // schedule idle close after IDLE_CLOSE_MS
+            record.client.scheduleIdleClose(record.idleCloseMs || PackageSO.IDLE_CLOSE_MS);
+        }
+    }
+    // Cleanup all static sandbox instances safely
+    static async cleanupSandboxInstances() {
+        const killers = [];
+        for (const [key, record] of PackageSO.sandboxInstances) {
+            killers.push((async () => {
+                try {
+                    await record.client.kill();
+                }
+                catch (err) {
+                    console.error("[PackageSO] cleanup error for sandbox", key, err);
+                }
+            })());
+            PackageSO.sandboxInstances.delete(key);
+        }
+        await Promise.all(killers);
+    }
     async executeTool(request) {
         const mcpServerConfig = getPackageConfigByKey(request.packageName);
+        if (this.useSandbox && mcpServerConfig.runtime === "node") {
+            try {
+                const result = await this.executeToolInSandbox(request);
+                return result;
+            }
+            catch (error) {
+                console.warn(`[executeTool] Sandbox mode failed for tool ${request.toolKey} in package ${request.packageName}, falling back to local mode:`, error);
+            }
+        }
         const { client, closeConnection } = await getMcpClient(mcpServerConfig, request.envs || {});
         try {
             const result = await client.callTool({
@@ -19,8 +152,47 @@ export class PackageSO {
             await closeConnection();
         }
     }
+    async executeToolInSandbox(request) {
+        if (!this.sandboxClient) {
+            throw new Error("Sandbox client not initialized");
+        }
+        // Initialize if not already initialized (concurrency protection via MCPSandboxClient.initialize)
+        await this.sandboxClient.initialize();
+        // Mark usage
+        this.sandboxClient.touch();
+        try {
+            const result = await this.sandboxClient.executeTool(request.packageName, request.toolKey, request.inputData || {}, request.envs);
+            console.log(`Tool ${request.toolKey} executed successfully in sandbox`);
+            return result;
+        }
+        catch (error) {
+            // If it's a sandbox not found error, try reinitializing and retrying once
+            if (error instanceof Error && error.message.includes("sandbox was not found")) {
+                console.log("[PackageSO] Retrying tool execution after sandbox failure");
+                await this.sandboxClient.initialize();
+                // Retry tool execution
+                const result = await this.sandboxClient.executeTool(request.packageName, request.toolKey, request.inputData || {}, request.envs);
+                console.log(`Tool ${request.toolKey} executed successfully in sandbox (retry)`);
+                return result;
+            }
+            throw error;
+        }
+        finally {
+            // Release reference count
+            await PackageSO.releaseSandbox("default");
+        }
+    }
     async listTools(packageName) {
         const mcpServerConfig = getPackageConfigByKey(packageName);
+        if (this.useSandbox && mcpServerConfig.runtime === "node") {
+            try {
+                const tools = await this.listToolsInSandbox(packageName);
+                return tools;
+            }
+            catch (error) {
+                console.warn(`[listTools] Sandbox mode failed for package ${packageName}, falling back to local mode:`, error);
+            }
+        }
         const mockEnvs = {};
         if (mcpServerConfig.env) {
             Object.keys(mcpServerConfig.env).forEach((key) => {
@@ -37,6 +209,34 @@ export class PackageSO {
             await closeConnection();
         }
     }
+    async listToolsInSandbox(packageName) {
+        if (!this.sandboxClient) {
+            throw new Error("Sandbox client not initialized");
+        }
+        // Initialize only if sandbox is not initialized
+        await this.sandboxClient.initialize();
+        this.sandboxClient.touch();
+        try {
+            const tools = await this.sandboxClient.listTools(packageName);
+            console.log(`Tools list retrieved successfully for package ${packageName} in sandbox`);
+            return tools;
+        }
+        catch (error) {
+            // If it's a sandbox not found error, try reinitializing and retrying once
+            if (error instanceof Error && error.message.includes("sandbox was not found")) {
+                console.log("[PackageSO] Retrying tools listing after sandbox failure");
+                await this.sandboxClient.initialize();
+                // Retry listing tools
+                const tools = await this.sandboxClient.listTools(packageName);
+                console.log(`Tools list retrieved successfully for package ${packageName} in sandbox (retry)`);
+                return tools;
+            }
+            throw error;
+        }
+        finally {
+            await PackageSO.releaseSandbox("default");
+        }
+    }
     async getPackageDetail(packageName) {
         const packageInfo = typedAllPackagesList[packageName];
         if (!packageInfo) {
@@ -58,3 +258,6 @@ export class PackageSO {
         return packageConfigWithTools;
     }
 }
+PackageSO.sandboxInstances = new Map();
+PackageSO.MAX_SANDBOXES = 10;
+PackageSO.IDLE_CLOSE_MS = 5 * 60 * 1000;

package/dist/helper.js

@@ -101,6 +101,7 @@ export function updatePackageJsonDependencies({ packageDeps, enableValidation =
     const packageJsonFile = "./package.json";
     const packageJSONStr = fs.readFileSync(packageJsonFile, "utf-8");
     const newDeps = {
+        "@e2b/code-interpreter": "^2.0.0",
         "@modelcontextprotocol/sdk": "^1.12.0",
         "@hono/node-server": "1.15.0",
         "@hono/swagger-ui": "^0.5.2",

package/dist/sandbox/mcp-sandbox-client.d.ts

@@ -0,0 +1,37 @@
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+export declare class MCPSandboxClient {
+    private sandbox;
+    private initializing;
+    private readonly apiKey;
+    private toolCache;
+    private readonly E2B_SANDBOX_TIMEOUT_MS;
+    private readonly TOOL_CACHE_TTL;
+    TOOL_EXECUTION_TIMEOUT: number;
+    private lastTouchTime;
+    private readonly THROTTLE_DELAY_MS;
+    createdAt: number | null;
+    lastUsedAt: number | null;
+    private ttlTimer;
+    private autoCloseOnIdleTimer;
+    private idleCloseMs;
+    constructor(apiKey?: string);
+    initialize(): Promise<void>;
+    private setupTTLTimer;
+    /**
+     * Update sandbox last used time
+     */
+    touch(): void;
+    /**
+     * Actually perform the touch operation
+     */
+    private performTouch;
+    scheduleIdleClose(idleMs: number): void;
+    kill(): Promise<void>;
+    clearPackageCache(packageKey: string): void;
+    clearAllCache(): void;
+    listTools(packageKey: string): Promise<Tool[]>;
+    executeTool(packageKey: string, toolName: string, argumentsObj: Record<string, unknown>, envs?: Record<string, string>): Promise<unknown>;
+    private runCodeWithTimeout;
+    private generateMCPTestCode;
+    private generateEnvVariables;
+}