@toolsdk.ai/registry 1.0.116 → 1.0.118

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

@@ -5,6 +5,22 @@ 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";
+// Singleton Daytona client shared across all instances to prevent memory leaks
+let sharedDaytonaClient = null;
+function getDaytonaClient() {
+    if (!sharedDaytonaClient) {
+        const config = getDaytonaConfig();
+        const daytonaConfig = {
+            apiKey: config.apiKey,
+        };
+        if (config.apiUrl) {
+            daytonaConfig.apiUrl = config.apiUrl;
+        }
+        sharedDaytonaClient = new Daytona(daytonaConfig);
+        console.log("[DaytonaSandboxClient] Shared Daytona client initialized");
+    }
+    return sharedDaytonaClient;
+}
 /**
  * Daytona Sandbox Client
  * Implements SandboxClient interface for Daytona provider
@@ -27,14 +43,8 @@ export class DaytonaSandboxClient {
         }
         this.initializing = (async () => {
             try {
-                const config = getDaytonaConfig();
-                const daytonaConfig = {
-                    apiKey: config.apiKey,
-                };
-                if (config.apiUrl) {
-                    daytonaConfig.apiUrl = config.apiUrl;
-                }
-                const daytona = new Daytona(daytonaConfig);
+                // Use shared singleton Daytona client instead of creating new one per initialization
+                const daytona = getDaytonaClient();
                 const declarativeImage = Image.base("node:20")
                     .runCommands("npm install -g pnpm", "mkdir -p /workspace", "cd /workspace && npm init -y", "cd /workspace && pnpm add @modelcontextprotocol/sdk")
                     .workdir("/workspace");

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

@@ -13,7 +13,9 @@ export declare class SandockSandboxClient implements SandboxClient {
     initialize(): Promise<void>;
     private executeShellCommand;
     private executeCode;
+    private cleanupTempFileAsync;
     listTools(packageKey: string): Promise<Tool[]>;
     executeTool(packageKey: string, toolName: string, argumentsObj: Record<string, unknown>, envs?: Record<string, string>): Promise<unknown>;
     destroy(): Promise<void>;
+    private destroySandboxAsync;
 }

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

@@ -5,6 +5,21 @@ 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";
+// Singleton HTTP client shared across all instances to prevent memory leaks
+let sharedSandockClient = null;
+function getSandockClient() {
+    if (!sharedSandockClient) {
+        const config = getSandockConfig();
+        sharedSandockClient = createSandockClient({
+            baseUrl: config.apiUrl,
+            headers: {
+                Authorization: `Bearer ${config.apiKey}`,
+            },
+        });
+        console.log("[SandockSandboxClient] Shared HTTP client initialized");
+    }
+    return sharedSandockClient;
+}
 /**
  * Sandock Sandbox Client
  * Implements SandboxClient interface for Sandock provider
@@ -16,13 +31,8 @@ export class SandockSandboxClient {
         const __dirname = getDirname(import.meta.url);
         const packagesDir = path.join(__dirname, "../../../../packages");
         this.packageRepository = new PackageRepository(packagesDir);
-        const config = getSandockConfig();
-        this.client = createSandockClient({
-            baseUrl: config.apiUrl,
-            headers: {
-                Authorization: `Bearer ${config.apiKey}`,
-            },
-        });
+        // Use shared singleton client instead of creating new one per instance
+        this.client = getSandockClient();
     }
     async initialize() {
         if (this.sandboxId) {
@@ -39,6 +49,7 @@ export class SandockSandboxClient {
                     body: {
                         image: "seey/sandock-mcp:latest",
                         workdir: "/mcpspace",
+                        usePersistentCache: true,
                     },
                 });
                 if (error) {
@@ -97,23 +108,42 @@ export class SandockSandboxClient {
                 content: code,
             },
         });
-        const output = await this.executeShellCommand(`cd /mcpspace && node ${tempFile}`);
-        // Asynchronously clean up temp file without blocking result return
-        this.client
-            .DELETE("/api/sandbox/{id}/fs", {
-            params: {
-                path: { id: this.sandboxId },
-                query: { path: tempFile },
-            },
-        })
-            .catch((error) => {
-            console.warn("[SandockSandboxClient] Warning: Could not delete temp file:", error);
+        // Set custom pnpm store directory (volume-mounted cache directory) before executing code
+        const output = await this.executeShellCommand(`cd /mcpspace && pnpm config set store-dir /data/pnpm-store && node ${tempFile}`);
+        // Fire-and-forget: cleanup temp file in background without blocking result return
+        // The cleanup will complete asynchronously, and logs will appear when it does
+        this.cleanupTempFileAsync(tempFile, this.sandboxId).catch((err) => {
+            // This should never happen due to internal error handling, but just in case
+            console.error("[SandockSandboxClient] Unexpected error in cleanupTempFileAsync:", err);
         });
         return {
             exitCode: 0,
             result: output,
         };
     }
+    async cleanupTempFileAsync(tempFile, sandboxId) {
+        if (!sandboxId) {
+            console.warn("[SandockSandboxClient] Sandbox ID is null, skipping temp file cleanup");
+            return;
+        }
+        try {
+            const { error } = await this.client.DELETE("/api/sandbox/{id}/fs", {
+                params: {
+                    path: { id: sandboxId },
+                    query: { path: tempFile },
+                },
+            });
+            if (error) {
+                console.warn(`[SandockSandboxClient] Warning: Could not delete temp file ${tempFile}:`, error);
+            }
+            else {
+                console.log(`[SandockSandboxClient] Temp file ${tempFile} deleted successfully`);
+            }
+        }
+        catch (cleanupError) {
+            console.warn(`[SandockSandboxClient] Error during temp file cleanup for ${tempFile}:`, cleanupError);
+        }
+    }
     async listTools(packageKey) {
         const mcpServerConfig = this.packageRepository.getPackageConfig(packageKey);
         const testCode = generateMCPTestCode(mcpServerConfig, "listTools");
@@ -146,30 +176,45 @@ export class SandockSandboxClient {
         }
         const sandboxIdToDelete = this.sandboxId;
         this.sandboxId = null; // Clear immediately to avoid duplicate calls
-        // Asynchronously delete sandbox without blocking result return
-        this.client
-            .DELETE("/api/sandbox/{id}/fs", {
-            params: {
-                path: { id: sandboxIdToDelete },
-                query: { path: "/" },
-            },
-        })
-            .then(({ error }) => {
+        // Fire-and-forget: destroy sandbox in background without blocking
+        // The cleanup will complete asynchronously, and logs will appear when it does
+        this.destroySandboxAsync(sandboxIdToDelete).catch((err) => {
+            // This should never happen due to internal error handling, but just in case
+            console.error("[SandockSandboxClient] Unexpected error in destroySandboxAsync:", err);
+        });
+    }
+    async destroySandboxAsync(sandboxId) {
+        try {
+            // Delete sandbox completely using the fs delete API with root path
+            // This removes all files and effectively shuts down the sandbox
+            const { error } = await this.client.DELETE("/api/sandbox/{id}/fs", {
+                params: {
+                    path: { id: sandboxId },
+                    query: { path: "/" },
+                },
+            });
             if (error) {
-                console.warn(`[SandockSandboxClient] Warning: Could not delete sandbox: ${JSON.stringify(error)}`);
+                // Check if error is "not found" (already deleted)
+                const errorStr = JSON.stringify(error);
+                if (errorStr.includes("not found") || errorStr.includes("404")) {
+                    console.log(`[SandockSandboxClient] Sandbox ${sandboxId} already deleted (not found on platform)`);
+                }
+                else {
+                    console.warn(`[SandockSandboxClient] Warning: Could not delete sandbox ${sandboxId}: ${errorStr}`);
+                }
             }
             else {
-                console.log("[SandockSandboxClient] Sandbox deleted successfully");
+                console.log(`[SandockSandboxClient] Sandbox ${sandboxId} deleted successfully`);
             }
-        })
-            .catch((err) => {
+        }
+        catch (err) {
             const errorMessage = err.message;
             if (errorMessage.includes("not found") || errorMessage.includes("404")) {
-                console.log("[SandockSandboxClient] Sandbox already deleted (not found on platform)");
+                console.log(`[SandockSandboxClient] Sandbox ${sandboxId} already deleted (not found on platform)`);
             }
             else {
-                console.warn("[SandockSandboxClient] Warning: Could not delete sandbox:", errorMessage);
+                console.warn(`[SandockSandboxClient] Warning: Could not delete sandbox ${sandboxId}: ${errorMessage}`);
             }
-        });
+        }
     }
 }

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

@@ -17,10 +17,11 @@ import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
 
 async function runMCP() {
   let client;
+  let transport;
   try {
     const packageName = "${mcpServerConfig.packageName}";
 
-    const transport = new StdioClientTransport({
+    transport = new StdioClientTransport({
       command: "pnpx",
       args: ["--silent", packageName],
       env: {
@@ -28,7 +29,6 @@ async function runMCP() {
           Object.entries(process.env).filter(([_, v]) => v !== undefined)
         ),
         PNPM_HOME: "/root/.local/share/pnpm",
-        PNPM_STORE_PATH: "/pnpm-store",
         ${generateEnvVariables(mcpServerConfig.env, envs)}
       },
     });
@@ -69,6 +69,13 @@ async function runMCP() {
         console.error("Error closing MCP client:", closeError);
       }
     }
+    if (transport) {
+      try {
+        await transport.close();
+      } catch (transportError) {
+        console.error("Error closing transport:", transportError);
+      }
+    }
   }
 }
 
@@ -100,6 +107,13 @@ runMCP();
         console.error("Error closing MCP client:", closeError);
       }
     }
+    if (transport) {
+      try {
+        await transport.close();
+      } catch (transportError) {
+        console.error("Error closing transport:", transportError);
+      }
+    }
   }
 }
 

package/dist/shared/utils/mcp-client-util.js

@@ -32,6 +32,13 @@ async function createMcpClient(mcpServerConfig, transport) {
         catch (e) {
             console.warn(`${packageName} mcp client close failure.`, e);
         }
+        // Close transport to release child process and file descriptors
+        try {
+            await transport.close();
+        }
+        catch (e) {
+            console.warn(`${packageName} mcp transport close failure.`, e);
+        }
     };
     return { client, transport, closeConnection };
 }

package/package.json

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