@toolsdk.ai/registry 1.0.113 → 1.0.115

package/dist/domains/package/package-so.test.js

@@ -0,0 +1,378 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { PackageSO } from "./package-so";
+describe("PackageSO", () => {
+    let mockRepository;
+    let mockExecutor;
+    beforeEach(() => {
+        // Mock PackageRepository
+        mockRepository = {
+            getPackageConfig: vi.fn(),
+            getAllPackages: vi.fn(),
+            exists: vi.fn(),
+        };
+        // Mock ToolExecutor
+        mockExecutor = {
+            listTools: vi.fn(),
+            executeTool: vi.fn(),
+        };
+    });
+    describe("init", () => {
+        it("should successfully initialize PackageSO instance", async () => {
+            // Arrange
+            const packageName = "@modelcontextprotocol/server-filesystem";
+            const mockConfig = {
+                type: "mcp-server",
+                runtime: "node",
+                packageName,
+                name: "Filesystem Server",
+                description: "A server for filesystem operations",
+            };
+            const mockPackageInfo = {
+                path: "path/to/package",
+                category: "filesystem",
+                validated: true,
+            };
+            vi.spyOn(mockRepository, "getPackageConfig").mockReturnValue(mockConfig);
+            vi.spyOn(mockRepository, "getAllPackages").mockReturnValue({
+                [packageName]: mockPackageInfo,
+            });
+            // Act
+            const packageSO = await PackageSO.init(packageName, mockRepository, mockExecutor);
+            // Assert
+            expect(packageSO.packageName).toBe(packageName);
+            expect(packageSO.name).toBe("Filesystem Server");
+            expect(packageSO.description).toBe("A server for filesystem operations");
+            expect(packageSO.category).toBe("filesystem");
+            expect(packageSO.validated).toBe(true);
+            expect(mockRepository.getPackageConfig).toHaveBeenCalledWith(packageName);
+            expect(mockRepository.getAllPackages).toHaveBeenCalled();
+        });
+        it("should handle case when package config exists but packageInfo does not", async () => {
+            // Arrange
+            const packageName = "@test/new-package";
+            const mockConfig = {
+                type: "mcp-server",
+                runtime: "node",
+                packageName,
+                name: "New Package",
+                description: "A new package",
+            };
+            vi.spyOn(mockRepository, "getPackageConfig").mockReturnValue(mockConfig);
+            vi.spyOn(mockRepository, "getAllPackages").mockReturnValue({});
+            // Act
+            const packageSO = await PackageSO.init(packageName, mockRepository, mockExecutor);
+            // Assert
+            expect(packageSO.packageName).toBe(packageName);
+            expect(packageSO.name).toBe("New Package");
+            expect(packageSO.category).toBeUndefined();
+            expect(packageSO.validated).toBeUndefined();
+        });
+        it("should handle null description", async () => {
+            // Arrange
+            const packageName = "@test/package";
+            const mockConfig = {
+                type: "mcp-server",
+                runtime: "node",
+                packageName,
+                name: "Test Package",
+                description: null,
+            };
+            vi.spyOn(mockRepository, "getPackageConfig").mockReturnValue(mockConfig);
+            vi.spyOn(mockRepository, "getAllPackages").mockReturnValue({});
+            // Act
+            const packageSO = await PackageSO.init(packageName, mockRepository, mockExecutor);
+            // Assert
+            expect(packageSO.description).toBeNull();
+        });
+    });
+    describe("getTools", () => {
+        it("should successfully return tools list", async () => {
+            // Arrange
+            const packageName = "@test/package";
+            const mockConfig = {
+                type: "mcp-server",
+                runtime: "node",
+                packageName,
+                name: "Test Package",
+                description: "Test description",
+            };
+            const mockTools = [
+                {
+                    name: "read_file",
+                    description: "Read a file",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            path: { type: "string" },
+                        },
+                    },
+                },
+                {
+                    name: "write_file",
+                    description: "Write a file",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            path: { type: "string" },
+                            content: { type: "string" },
+                        },
+                    },
+                },
+            ];
+            vi.spyOn(mockRepository, "getPackageConfig").mockReturnValue(mockConfig);
+            vi.spyOn(mockRepository, "getAllPackages").mockReturnValue({});
+            vi.spyOn(mockExecutor, "listTools").mockResolvedValue(mockTools);
+            const packageSO = await PackageSO.init(packageName, mockRepository, mockExecutor);
+            // Act
+            const tools = await packageSO.getTools();
+            // Assert
+            expect(tools).toEqual(mockTools);
+            expect(tools).toHaveLength(2);
+            expect(mockExecutor.listTools).toHaveBeenCalledWith(packageName);
+            expect(mockExecutor.listTools).toHaveBeenCalledTimes(1);
+        });
+        it("should throw error when executor fails", async () => {
+            // Arrange
+            const packageName = "@test/package";
+            const mockConfig = {
+                type: "mcp-server",
+                runtime: "node",
+                packageName,
+                name: "Test Package",
+                description: "Test description",
+            };
+            const errorMessage = "Failed to list tools";
+            vi.spyOn(mockRepository, "getPackageConfig").mockReturnValue(mockConfig);
+            vi.spyOn(mockRepository, "getAllPackages").mockReturnValue({});
+            vi.spyOn(mockExecutor, "listTools").mockRejectedValue(new Error(errorMessage));
+            const packageSO = await PackageSO.init(packageName, mockRepository, mockExecutor);
+            // Act & Assert
+            await expect(packageSO.getTools()).rejects.toThrow(errorMessage);
+        });
+    });
+    describe("executeTool", () => {
+        it("should successfully execute tool", async () => {
+            // Arrange
+            const packageName = "@test/package";
+            const toolKey = "read_file";
+            const inputData = { path: "/tmp/test.txt" };
+            const envs = { ENV_VAR: "test_value" };
+            const mockResult = { content: "file content", success: true };
+            const mockConfig = {
+                type: "mcp-server",
+                runtime: "node",
+                packageName,
+                name: "Test Package",
+                description: "Test description",
+            };
+            vi.spyOn(mockRepository, "getPackageConfig").mockReturnValue(mockConfig);
+            vi.spyOn(mockRepository, "getAllPackages").mockReturnValue({});
+            vi.spyOn(mockExecutor, "executeTool").mockResolvedValue(mockResult);
+            const packageSO = await PackageSO.init(packageName, mockRepository, mockExecutor);
+            // Act
+            const result = await packageSO.executeTool(toolKey, inputData, envs);
+            // Assert
+            expect(result).toEqual(mockResult);
+            expect(mockExecutor.executeTool).toHaveBeenCalledWith({
+                packageName,
+                toolKey,
+                inputData,
+                envs,
+            });
+            expect(mockExecutor.executeTool).toHaveBeenCalledTimes(1);
+        });
+        it("should execute normally without envs parameter", async () => {
+            // Arrange
+            const packageName = "@test/package";
+            const toolKey = "read_file";
+            const inputData = { path: "/tmp/test.txt" };
+            const mockResult = { content: "file content" };
+            const mockConfig = {
+                type: "mcp-server",
+                runtime: "node",
+                packageName,
+                name: "Test Package",
+                description: "Test description",
+            };
+            vi.spyOn(mockRepository, "getPackageConfig").mockReturnValue(mockConfig);
+            vi.spyOn(mockRepository, "getAllPackages").mockReturnValue({});
+            vi.spyOn(mockExecutor, "executeTool").mockResolvedValue(mockResult);
+            const packageSO = await PackageSO.init(packageName, mockRepository, mockExecutor);
+            // Act
+            const result = await packageSO.executeTool(toolKey, inputData);
+            // Assert
+            expect(result).toEqual(mockResult);
+            expect(mockExecutor.executeTool).toHaveBeenCalledWith({
+                packageName,
+                toolKey,
+                inputData,
+                envs: undefined,
+            });
+        });
+        it("should throw error when tool execution fails", async () => {
+            // Arrange
+            const packageName = "@test/package";
+            const toolKey = "unknown_tool";
+            const inputData = { param: "value" };
+            const errorMessage = "Unknown tool: unknown_tool";
+            const mockConfig = {
+                type: "mcp-server",
+                runtime: "node",
+                packageName,
+                name: "Test Package",
+                description: "Test description",
+            };
+            vi.spyOn(mockRepository, "getPackageConfig").mockReturnValue(mockConfig);
+            vi.spyOn(mockRepository, "getAllPackages").mockReturnValue({});
+            vi.spyOn(mockExecutor, "executeTool").mockRejectedValue(new Error(errorMessage));
+            const packageSO = await PackageSO.init(packageName, mockRepository, mockExecutor);
+            // Act & Assert
+            await expect(packageSO.executeTool(toolKey, inputData)).rejects.toThrow(errorMessage);
+        });
+    });
+    describe("getDetailWithTools", () => {
+        it("should return complete package details with tools list", async () => {
+            // Arrange
+            const packageName = "@test/package";
+            const mockConfig = {
+                type: "mcp-server",
+                runtime: "node",
+                packageName,
+                name: "Test Package",
+                description: "A test package for demonstration",
+            };
+            const mockPackageInfo = {
+                path: "path/to/package",
+                category: "testing",
+                validated: true,
+            };
+            const mockTools = [
+                {
+                    name: "test_tool",
+                    description: "A test tool",
+                    inputSchema: {
+                        type: "object",
+                        properties: {},
+                    },
+                },
+            ];
+            vi.spyOn(mockRepository, "getPackageConfig").mockReturnValue(mockConfig);
+            vi.spyOn(mockRepository, "getAllPackages").mockReturnValue({
+                [packageName]: mockPackageInfo,
+            });
+            vi.spyOn(mockExecutor, "listTools").mockResolvedValue(mockTools);
+            const packageSO = await PackageSO.init(packageName, mockRepository, mockExecutor);
+            // Act
+            const detail = await packageSO.getDetailWithTools();
+            // Assert
+            expect(detail).toEqual({
+                name: "Test Package",
+                packageName: "@test/package",
+                description: "A test package for demonstration",
+                category: "testing",
+                validated: true,
+                tools: mockTools,
+            });
+        });
+        it("should return undefined tools when getting tools fails", async () => {
+            // Arrange
+            const packageName = "@test/package";
+            const mockConfig = {
+                type: "mcp-server",
+                runtime: "node",
+                packageName,
+                name: "Test Package",
+                description: "Test description",
+            };
+            vi.spyOn(mockRepository, "getPackageConfig").mockReturnValue(mockConfig);
+            vi.spyOn(mockRepository, "getAllPackages").mockReturnValue({});
+            vi.spyOn(mockExecutor, "listTools").mockRejectedValue(new Error("Failed to get tools"));
+            const consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => { });
+            const packageSO = await PackageSO.init(packageName, mockRepository, mockExecutor);
+            // Act
+            const detail = await packageSO.getDetailWithTools();
+            // Assert
+            expect(detail.tools).toBeUndefined();
+            expect(detail.name).toBe("Test Package");
+            expect(detail.packageName).toBe(packageName);
+            expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining(`[PackageSO] Failed to get tools for ${packageName}`), expect.any(Error));
+            consoleWarnSpy.mockRestore();
+        });
+        it("should correctly handle packages without category and validated", async () => {
+            // Arrange
+            const packageName = "@test/minimal-package";
+            const mockConfig = {
+                type: "mcp-server",
+                runtime: "node",
+                packageName,
+                name: "Minimal Package",
+                description: "A minimal package",
+            };
+            const mockTools = [];
+            vi.spyOn(mockRepository, "getPackageConfig").mockReturnValue(mockConfig);
+            vi.spyOn(mockRepository, "getAllPackages").mockReturnValue({});
+            vi.spyOn(mockExecutor, "listTools").mockResolvedValue(mockTools);
+            const packageSO = await PackageSO.init(packageName, mockRepository, mockExecutor);
+            // Act
+            const detail = await packageSO.getDetailWithTools();
+            // Assert
+            expect(detail).toEqual({
+                name: "Minimal Package",
+                packageName: "@test/minimal-package",
+                description: "A minimal package",
+                category: undefined,
+                validated: undefined,
+                tools: mockTools,
+            });
+        });
+    });
+    describe("Getters", () => {
+        it("should correctly access all properties through getters", async () => {
+            // Arrange
+            const packageName = "@test/package";
+            const mockConfig = {
+                type: "mcp-server",
+                runtime: "node",
+                packageName,
+                name: "Test Package",
+                description: "Test description",
+            };
+            const mockPackageInfo = {
+                path: "path/to/package",
+                category: "test-category",
+                validated: false,
+            };
+            vi.spyOn(mockRepository, "getPackageConfig").mockReturnValue(mockConfig);
+            vi.spyOn(mockRepository, "getAllPackages").mockReturnValue({
+                [packageName]: mockPackageInfo,
+            });
+            // Act
+            const packageSO = await PackageSO.init(packageName, mockRepository, mockExecutor);
+            // Assert
+            expect(packageSO.packageName).toBe(packageName);
+            expect(packageSO.name).toBe("Test Package");
+            expect(packageSO.description).toBe("Test description");
+            expect(packageSO.category).toBe("test-category");
+            expect(packageSO.validated).toBe(false);
+            expect(packageSO.config).toEqual(mockConfig);
+        });
+        it("should return complete config object through config getter", async () => {
+            // Arrange
+            const packageName = "@test/package";
+            const mockConfig = {
+                type: "mcp-server",
+                runtime: "node",
+                packageName,
+                name: "Test Package",
+                description: "Test description",
+            };
+            vi.spyOn(mockRepository, "getPackageConfig").mockReturnValue(mockConfig);
+            vi.spyOn(mockRepository, "getAllPackages").mockReturnValue({});
+            // Act
+            const packageSO = await PackageSO.init(packageName, mockRepository, mockExecutor);
+            // Assert
+            expect(packageSO.config).toBe(mockConfig);
+            expect(packageSO.config).toEqual(mockConfig);
+        });
+    });
+});

package/dist/domains/package/package-types.d.ts

@@ -0,0 +1,9 @@
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { z } from "zod";
+import type { MCPServerPackageConfigSchema, PackageConfigSchema, PackagesListSchema } from "../../shared/schemas";
+export type MCPServerPackageConfig = z.infer<typeof MCPServerPackageConfigSchema>;
+export type PackageConfig = z.infer<typeof PackageConfigSchema>;
+export type PackagesList = z.infer<typeof PackagesListSchema>;
+export interface MCPServerPackageConfigWithTools extends MCPServerPackageConfig {
+    tools?: Tool[];
+}

package/dist/domains/package/package-types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,17 @@
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { SandboxClient } from "../sandbox-types";
+/**
+ * Daytona Sandbox Client
+ * Implements SandboxClient interface for Daytona provider
+ */
+export declare class DaytonaSandboxClient implements SandboxClient {
+    private sandbox;
+    private initializing;
+    private readonly packageRepository;
+    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/daytona-client.js

@@ -0,0 +1,112 @@
+import path from "node:path";
+import { Daytona, Image } from "@daytonaio/sdk";
+import { getDaytonaConfig } 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";
+/**
+ * Daytona Sandbox Client
+ * Implements SandboxClient interface for Daytona provider
+ */
+export class DaytonaSandboxClient {
+    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);
+    }
+    async initialize() {
+        if (this.sandbox) {
+            return;
+        }
+        if (this.initializing) {
+            await this.initializing;
+            return;
+        }
+        this.initializing = (async () => {
+            try {
+                const config = getDaytonaConfig();
+                const daytonaConfig = {
+                    apiKey: config.apiKey,
+                };
+                if (config.apiUrl) {
+                    daytonaConfig.apiUrl = config.apiUrl;
+                }
+                const daytona = new Daytona(daytonaConfig);
+                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");
+                this.sandbox = await daytona.create({
+                    language: "javascript",
+                    image: declarativeImage,
+                    autoDeleteInterval: 0,
+                });
+                console.log("[DaytonaSandboxClient] Sandbox created successfully");
+            }
+            finally {
+                this.initializing = null;
+            }
+        })();
+        await this.initializing;
+    }
+    async executeCode(code) {
+        if (!this.sandbox) {
+            throw new Error("Sandbox not initialized. Call initialize() first.");
+        }
+        const response = await this.sandbox.process.codeRun(code);
+        return {
+            exitCode: response.exitCode,
+            result: response.result,
+        };
+    }
+    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("[DaytonaSandboxClient] 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
+            .delete()
+            .then(() => {
+            console.log("[DaytonaSandboxClient] Sandbox destroyed successfully");
+        })
+            .catch((err) => {
+            const errorMessage = err.message;
+            if (errorMessage.includes("not found")) {
+                console.log("[DaytonaSandboxClient] Sandbox already destroyed (not found on platform)");
+            }
+            else {
+                console.warn("[DaytonaSandboxClient] Warning: Could not destroy sandbox:", errorMessage);
+            }
+        });
+    }
+}

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

@@ -0,0 +1,19 @@
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { SandboxClient } from "../sandbox-types";
+/**
+ * Sandock Sandbox Client
+ * Implements SandboxClient interface for Sandock provider
+ */
+export declare class SandockSandboxClient implements SandboxClient {
+    private sandboxId;
+    private initializing;
+    private readonly packageRepository;
+    private readonly client;
+    constructor(_runtime?: "node" | "python" | "java" | "go");
+    initialize(): Promise<void>;
+    private executeShellCommand;
+    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>;
+}