@toolsdk.ai/registry 1.0.113 → 1.0.114

package/dist/sandbox/mcp-sandbox-client.test.js

@@ -0,0 +1,491 @@
+// npx vitest run src/sandbox/mcp-sandbox-client.test.ts
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { MCPSandboxClient } from "./mcp-sandbox-client";
+// Mock Daytona SDK
+vi.mock("@daytonaio/sdk", () => {
+    const mockSandbox = {
+        process: {
+            codeRun: vi.fn(),
+        },
+        delete: vi.fn().mockResolvedValue(undefined),
+    };
+    const mockVolume = {
+        id: "mock-volume-id",
+    };
+    const mockDaytona = {
+        create: vi.fn().mockResolvedValue(mockSandbox),
+        volume: {
+            get: vi.fn().mockResolvedValue(mockVolume),
+        },
+    };
+    return {
+        Daytona: vi.fn(() => mockDaytona),
+        Image: {
+            base: vi.fn().mockReturnValue({
+                runCommands: vi.fn().mockReturnThis(),
+                workdir: vi.fn().mockReturnThis(),
+            }),
+        },
+    };
+});
+// Mock helper functions
+vi.mock("../helper", () => ({
+    extractLastOuterJSON: vi.fn((str) => str),
+    getPackageConfigByKey: vi.fn(async (key) => ({
+        type: "mcp-server",
+        packageName: `@test/${key}`,
+        name: "Test Package",
+        description: "Test Description",
+        runtime: "node",
+        env: {
+            TEST_API_KEY: {
+                description: "Test API Key",
+                required: true,
+            },
+        },
+    })),
+}));
+// Helper function to get mocked Daytona instance
+async function getMockedDaytonaInstance() {
+    const { Daytona } = await import("@daytonaio/sdk");
+    const DaytonaMock = Daytona;
+    return DaytonaMock.mock.results[0].value;
+}
+// Helper function to get mocked sandbox
+async function getMockedSandbox() {
+    const daytonaInstance = await getMockedDaytonaInstance();
+    return daytonaInstance.create.mock.results[0].value;
+}
+// Helper function to mock extractLastOuterJSON
+async function getMockedExtractJSON() {
+    const { extractLastOuterJSON } = await import("../helper");
+    return extractLastOuterJSON;
+}
+describe("MCPSandboxClient - MCP Sandbox Client Unit Tests", () => {
+    let client;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        client = new MCPSandboxClient("node");
+    });
+    afterEach(async () => {
+        if (client) {
+            await client.kill();
+        }
+    });
+    describe("Initialization Tests", () => {
+        it("should successfully initialize Sandbox", async () => {
+            await client.initialize();
+            // Verify Daytona is called correctly
+            const { Daytona } = await import("@daytonaio/sdk");
+            expect(Daytona).toHaveBeenCalledWith({
+                apiKey: expect.any(String),
+            });
+        });
+        it("should prevent duplicate initialization", async () => {
+            // First initialization
+            await client.initialize();
+            // Second initialization should return directly without creating new sandbox
+            await client.initialize();
+            const daytonaInstance = await getMockedDaytonaInstance();
+            // create should only be called once
+            expect(daytonaInstance.create).toHaveBeenCalledTimes(1);
+        });
+        it("should support concurrent initialization calls", async () => {
+            // Initiate multiple initialization requests simultaneously
+            const promises = [client.initialize(), client.initialize(), client.initialize()];
+            await Promise.all(promises);
+            const daytonaInstance = await getMockedDaytonaInstance();
+            // Even with concurrent calls, create should only be called once
+            expect(daytonaInstance.create).toHaveBeenCalledTimes(1);
+        });
+        it("should use correct runtime configuration", () => {
+            const nodeClient = new MCPSandboxClient("node");
+            const pythonClient = new MCPSandboxClient("python");
+            expect(nodeClient).toBeDefined();
+            expect(pythonClient).toBeDefined();
+        });
+    });
+    describe("listTools - List Tools Tests", () => {
+        it("should successfully list tools", async () => {
+            await client.initialize();
+            const mockTools = [
+                {
+                    name: "test_tool_1",
+                    description: "Test Tool 1",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            param1: { type: "string" },
+                        },
+                    },
+                },
+                {
+                    name: "test_tool_2",
+                    description: "Test Tool 2",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            param2: { type: "number" },
+                        },
+                    },
+                },
+            ];
+            const mockResponse = {
+                exitCode: 0,
+                result: JSON.stringify({
+                    toolCount: 2,
+                    tools: mockTools,
+                }),
+            };
+            const mockSandbox = await getMockedSandbox();
+            mockSandbox.process.codeRun.mockResolvedValue(mockResponse);
+            const extractMock = await getMockedExtractJSON();
+            extractMock.mockReturnValue(mockResponse.result);
+            const tools = await client.listTools("test-package");
+            expect(tools).toEqual(mockTools);
+            expect(tools).toHaveLength(2);
+            expect(mockSandbox.process.codeRun).toHaveBeenCalledWith(expect.any(String));
+        });
+        it("should throw error when Sandbox is not initialized", async () => {
+            await expect(client.listTools("test-package")).rejects.toThrow("Sandbox not initialized. Call initialize() first.");
+        });
+        it("should handle execution failure", async () => {
+            await client.initialize();
+            const mockResponse = {
+                exitCode: 1,
+                result: "Error: Failed to list tools",
+            };
+            const mockSandbox = await getMockedSandbox();
+            mockSandbox.process.codeRun.mockResolvedValue(mockResponse);
+            await expect(client.listTools("test-package")).rejects.toThrow("Failed to list tools");
+        });
+        it("should handle JSON parsing errors", async () => {
+            await client.initialize();
+            const mockResponse = {
+                exitCode: 0,
+                result: "invalid json",
+            };
+            const mockSandbox = await getMockedSandbox();
+            mockSandbox.process.codeRun.mockResolvedValue(mockResponse);
+            const extractMock = await getMockedExtractJSON();
+            extractMock.mockReturnValue("invalid json");
+            await expect(client.listTools("test-package")).rejects.toThrow();
+        });
+    });
+    describe("executeTool - Execute Tool Tests", () => {
+        it("should successfully execute tool", async () => {
+            await client.initialize();
+            const mockResult = {
+                result: { message: "Success", data: { value: 42 } },
+                isError: false,
+            };
+            const mockResponse = {
+                exitCode: 0,
+                result: JSON.stringify(mockResult),
+            };
+            const mockSandbox = await getMockedSandbox();
+            mockSandbox.process.codeRun.mockResolvedValue(mockResponse);
+            const extractMock = await getMockedExtractJSON();
+            extractMock.mockReturnValue(mockResponse.result);
+            const result = await client.executeTool("test-package", "test_tool", {
+                param1: "value1",
+            });
+            expect(result).toEqual(mockResult);
+            expect(mockSandbox.process.codeRun).toHaveBeenCalledWith(expect.any(String));
+        });
+        it("should support passing environment variables", async () => {
+            await client.initialize();
+            const mockResult = {
+                result: { message: "Success with env" },
+                isError: false,
+            };
+            const mockResponse = {
+                exitCode: 0,
+                result: JSON.stringify(mockResult),
+            };
+            const mockSandbox = await getMockedSandbox();
+            mockSandbox.process.codeRun.mockResolvedValue(mockResponse);
+            const extractMock = await getMockedExtractJSON();
+            extractMock.mockReturnValue(mockResponse.result);
+            const envs = {
+                TEST_API_KEY: "real-api-key-123",
+                TEST_SECRET: "secret-value",
+            };
+            const result = await client.executeTool("test-package", "test_tool", { param1: "value1" }, envs);
+            expect(result).toEqual(mockResult);
+            // Verify generated code contains environment variables
+            const generatedCode = mockSandbox.process.codeRun.mock.calls[0][0];
+            expect(generatedCode).toContain("TEST_API_KEY");
+        });
+        it("should handle tool execution errors", async () => {
+            await client.initialize();
+            const mockResult = {
+                result: null,
+                isError: true,
+                errorMessage: "Tool execution failed: Invalid parameters",
+            };
+            const mockResponse = {
+                exitCode: 0,
+                result: JSON.stringify(mockResult),
+            };
+            const mockSandbox = await getMockedSandbox();
+            mockSandbox.process.codeRun.mockResolvedValue(mockResponse);
+            const extractMock = await getMockedExtractJSON();
+            extractMock.mockReturnValue(mockResponse.result);
+            await expect(client.executeTool("test-package", "test_tool", { invalid: "param" })).rejects.toThrow("Tool execution failed: Invalid parameters");
+        });
+        it("should throw error when Sandbox is not initialized", async () => {
+            await expect(client.executeTool("test-package", "test_tool", {})).rejects.toThrow("Sandbox not initialized. Call initialize() first.");
+        });
+        it("should handle non-zero process exit code", async () => {
+            await client.initialize();
+            const mockResponse = {
+                exitCode: 1,
+                result: "Process crashed",
+            };
+            const mockSandbox = await getMockedSandbox();
+            mockSandbox.process.codeRun.mockResolvedValue(mockResponse);
+            await expect(client.executeTool("test-package", "test_tool", {})).rejects.toThrow("Failed to execute tool");
+        });
+        it("should correctly serialize complex argument objects", async () => {
+            await client.initialize();
+            const complexArgs = {
+                stringParam: "test",
+                numberParam: 42,
+                booleanParam: true,
+                arrayParam: [1, 2, 3],
+                objectParam: { nested: { value: "deep" } },
+            };
+            const mockResult = {
+                result: { success: true },
+                isError: false,
+            };
+            const mockResponse = {
+                exitCode: 0,
+                result: JSON.stringify(mockResult),
+            };
+            const mockSandbox = await getMockedSandbox();
+            mockSandbox.process.codeRun.mockResolvedValue(mockResponse);
+            const extractMock = await getMockedExtractJSON();
+            extractMock.mockReturnValue(mockResponse.result);
+            await client.executeTool("test-package", "test_tool", complexArgs);
+            const generatedCode = mockSandbox.process.codeRun.mock.calls[0][0];
+            expect(generatedCode).toContain(JSON.stringify(complexArgs));
+        });
+    });
+    describe("kill - Cleanup Tests", () => {
+        it("should successfully cleanup Sandbox", async () => {
+            await client.initialize();
+            const mockSandbox = await getMockedSandbox();
+            await client.kill();
+            expect(mockSandbox.delete).toHaveBeenCalledTimes(1);
+        });
+        it("should safely return when Sandbox is not initialized", async () => {
+            // Call kill directly without initialization
+            await expect(client.kill()).resolves.not.toThrow();
+        });
+        it("should handle deletion failure", async () => {
+            await client.initialize();
+            const mockSandbox = await getMockedSandbox();
+            mockSandbox.delete.mockRejectedValue(new Error("Delete failed"));
+            // Should not throw error even if deletion fails
+            await expect(client.kill()).resolves.not.toThrow();
+        });
+        it("should reset Sandbox state after kill", async () => {
+            await client.initialize();
+            await client.kill();
+            // Calling methods that require Sandbox should throw error
+            await expect(client.listTools("test-package")).rejects.toThrow("Sandbox not initialized");
+        });
+    });
+    describe("Code Generation Tests", () => {
+        it("generated listTools code should contain necessary imports", async () => {
+            await client.initialize();
+            const mockResponse = {
+                exitCode: 0,
+                result: JSON.stringify({ toolCount: 0, tools: [] }),
+            };
+            const mockSandbox = await getMockedSandbox();
+            mockSandbox.process.codeRun.mockResolvedValue(mockResponse);
+            const extractMock = await getMockedExtractJSON();
+            extractMock.mockReturnValue(mockResponse.result);
+            await client.listTools("test-package");
+            const generatedCode = mockSandbox.process.codeRun.mock.calls[0][0];
+            // Verify necessary imports
+            expect(generatedCode).toContain("import { Client }");
+            expect(generatedCode).toContain("import { StdioClientTransport }");
+            expect(generatedCode).toContain("@modelcontextprotocol/sdk");
+        });
+        it("generated executeTool code should contain tool name and arguments", async () => {
+            await client.initialize();
+            const mockResponse = {
+                exitCode: 0,
+                result: JSON.stringify({ result: {}, isError: false }),
+            };
+            const mockSandbox = await getMockedSandbox();
+            mockSandbox.process.codeRun.mockResolvedValue(mockResponse);
+            const extractMock = await getMockedExtractJSON();
+            extractMock.mockReturnValue(mockResponse.result);
+            await client.executeTool("test-package", "my_tool", { key: "value" });
+            const generatedCode = mockSandbox.process.codeRun.mock.calls[0][0];
+            expect(generatedCode).toContain("my_tool");
+            expect(generatedCode).toContain("client.callTool");
+            expect(generatedCode).toContain(JSON.stringify({ key: "value" }));
+        });
+        it("generated code should use pnpx to execute package", async () => {
+            await client.initialize();
+            const mockResponse = {
+                exitCode: 0,
+                result: JSON.stringify({ toolCount: 0, tools: [] }),
+            };
+            const mockSandbox = await getMockedSandbox();
+            mockSandbox.process.codeRun.mockResolvedValue(mockResponse);
+            const extractMock = await getMockedExtractJSON();
+            extractMock.mockReturnValue(mockResponse.result);
+            await client.listTools("test-package");
+            const generatedCode = mockSandbox.process.codeRun.mock.calls[0][0];
+            expect(generatedCode).toContain('command: "pnpx"');
+            expect(generatedCode).toContain('"--silent"');
+        });
+        it("generated code should contain environment variable configuration", async () => {
+            await client.initialize();
+            const mockResponse = {
+                exitCode: 0,
+                result: JSON.stringify({ result: {}, isError: false }),
+            };
+            const mockSandbox = await getMockedSandbox();
+            mockSandbox.process.codeRun.mockResolvedValue(mockResponse);
+            const extractMock = await getMockedExtractJSON();
+            extractMock.mockReturnValue(mockResponse.result);
+            await client.executeTool("test-package", "test_tool", {}, { TEST_API_KEY: "real-value" });
+            const generatedCode = mockSandbox.process.codeRun.mock.calls[0][0];
+            expect(generatedCode).toContain("PNPM_HOME");
+            expect(generatedCode).toContain("PNPM_STORE_PATH");
+            expect(generatedCode).toContain("TEST_API_KEY");
+        });
+        it("generated code should correctly handle missing environment variables", async () => {
+            await client.initialize();
+            const mockResponse = {
+                exitCode: 0,
+                result: JSON.stringify({ toolCount: 0, tools: [] }),
+            };
+            const mockSandbox = await getMockedSandbox();
+            mockSandbox.process.codeRun.mockResolvedValue(mockResponse);
+            const extractMock = await getMockedExtractJSON();
+            extractMock.mockReturnValue(mockResponse.result);
+            // Do not pass real environment variables
+            await client.listTools("test-package");
+            const generatedCode = mockSandbox.process.codeRun.mock.calls[0][0];
+            // Should use mock_value as default value
+            expect(generatedCode).toContain("mock_value");
+        });
+    });
+    describe("Edge Cases and Exception Tests", () => {
+        it("should handle empty tool list", async () => {
+            await client.initialize();
+            const mockResponse = {
+                exitCode: 0,
+                result: JSON.stringify({ toolCount: 0, tools: [] }),
+            };
+            const mockSandbox = await getMockedSandbox();
+            mockSandbox.process.codeRun.mockResolvedValue(mockResponse);
+            const extractMock = await getMockedExtractJSON();
+            extractMock.mockReturnValue(mockResponse.result);
+            const tools = await client.listTools("empty-package");
+            expect(tools).toEqual([]);
+            expect(tools).toHaveLength(0);
+        });
+        it("should handle empty argument object", async () => {
+            await client.initialize();
+            const mockResult = {
+                result: { success: true },
+                isError: false,
+            };
+            const mockResponse = {
+                exitCode: 0,
+                result: JSON.stringify(mockResult),
+            };
+            const mockSandbox = await getMockedSandbox();
+            mockSandbox.process.codeRun.mockResolvedValue(mockResponse);
+            const extractMock = await getMockedExtractJSON();
+            extractMock.mockReturnValue(mockResponse.result);
+            await expect(client.executeTool("test-package", "test_tool", {})).resolves.toEqual(mockResult);
+        });
+        it("should handle non-existent package", async () => {
+            const { getPackageConfigByKey } = await import("../helper");
+            const getPackageMock = getPackageConfigByKey;
+            getPackageMock.mockRejectedValueOnce(new Error("Package 'non-existent' not found in packages list."));
+            await client.initialize();
+            await expect(client.listTools("non-existent")).rejects.toThrow("Package 'non-existent' not found");
+        });
+        it("should handle network timeout", async () => {
+            await client.initialize();
+            const mockSandbox = await getMockedSandbox();
+            mockSandbox.process.codeRun.mockRejectedValueOnce(new Error("Network timeout"));
+            await expect(client.listTools("test-package")).rejects.toThrow("Network timeout");
+        });
+    });
+    describe("Complete Workflow Tests", () => {
+        it("should support complete workflow: initialize -> list tools -> execute tool -> cleanup", async () => {
+            // 1. Initialize
+            await client.initialize();
+            const mockSandbox = await getMockedSandbox();
+            // 2. List tools
+            const mockTools = [
+                {
+                    name: "hello_tool",
+                    description: "Say hello",
+                    inputSchema: {
+                        type: "object",
+                        properties: { name: { type: "string" } },
+                    },
+                },
+            ];
+            mockSandbox.process.codeRun.mockResolvedValueOnce({
+                exitCode: 0,
+                result: JSON.stringify({ toolCount: 1, tools: mockTools }),
+            });
+            const extractMock = await getMockedExtractJSON();
+            extractMock.mockImplementation((str) => str);
+            const tools = await client.listTools("test-package");
+            expect(tools).toHaveLength(1);
+            expect(tools[0].name).toBe("hello_tool");
+            // 3. Execute tool
+            mockSandbox.process.codeRun.mockResolvedValueOnce({
+                exitCode: 0,
+                result: JSON.stringify({
+                    result: { message: "Hello, World!" },
+                    isError: false,
+                }),
+            });
+            const result = await client.executeTool("test-package", "hello_tool", {
+                name: "World",
+            });
+            expect(result).toHaveProperty("result");
+            // 4. Cleanup
+            await client.kill();
+            expect(mockSandbox.delete).toHaveBeenCalled();
+        });
+        it("should support multiple tool executions", async () => {
+            await client.initialize();
+            const mockSandbox = await getMockedSandbox();
+            const extractMock = await getMockedExtractJSON();
+            extractMock.mockImplementation((str) => str);
+            // Execute multiple times
+            for (let i = 0; i < 3; i++) {
+                mockSandbox.process.codeRun.mockResolvedValueOnce({
+                    exitCode: 0,
+                    result: JSON.stringify({
+                        result: { iteration: i },
+                        isError: false,
+                    }),
+                });
+                const result = await client.executeTool("test-package", "test_tool", {
+                    index: i,
+                });
+                expect(result).toHaveProperty("result");
+            }
+            expect(mockSandbox.process.codeRun).toHaveBeenCalledTimes(3);
+        });
+    });
+});

package/dist/types.d.ts

@@ -6,6 +6,7 @@ export type PackageConfig = z.infer<typeof PackageConfigSchema>;
 export type CategoryConfig = z.infer<typeof CategoryConfigSchema>;
 export type PackagesList = z.infer<typeof PackagesListSchema>;
 export type ToolExecute = z.infer<typeof ToolExecuteSchema>;
+export type MCPSandboxProvider = "LOCAL" | "DAYTONA" | "SANDOCK";
 export interface Response<T> {
     success: boolean;
     code: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolsdk.ai/registry",
-  "version": "1.0.113",
+  "version": "1.0.114",
   "description": "An Open, Structured, and Standard Registry for MCP Servers and Packages.",
   "keywords": [],
   "license": "MIT",
@@ -87,6 +87,7 @@
     "@cyanheads/pubmed-mcp-server": "1.2.3",
     "@cyanheads/toolkit-mcp-server": "1.0.1",
     "@dasheck0/face-generator": "1.0.1",
+    "@daytonaio/sdk": "0.109.0",
     "@debugg-ai/debugg-ai-mcp": "1.0.15",
     "@delorenj/mcp-server-ticketmaster": "0.2.5",
     "@deventerprisesoftware/scrapi-mcp": "0.0.3",

package/packages/search-data-extraction/ref-tools-mcp.json

@@ -4,7 +4,12 @@
   "description": "Integrates with Ref.tools documentation search service to provide curated technical documentation access, web search fallback, and URL-to-markdown conversion for efficient developer reference during coding workflows.",
   "url": "https://github.com/ref-tools/ref-tools-mcp",
   "runtime": "node",
-  "license": "unknown",
-  "env": {},
+  "license": "mit",
+  "env": {
+    "REF_API_KEY": {
+      "description": "sign up to get an API key",
+      "required": true
+    }
+  },
   "name": "Ref Tools MCP"
 }