@toolsdk.ai/registry 1.0.124 → 1.0.125

package/dist/api/index.js

@@ -4,11 +4,15 @@ import { serve } from "@hono/node-server";
 import { swaggerUI } from "@hono/swagger-ui";
 import { OpenAPIHono } from "@hono/zod-openapi";
 import { configRoutes } from "../domains/config/config-route";
+import { repository } from "../domains/package/package-handler";
 import { packageRoutes } from "../domains/package/package-route";
+import { initRegistryFactory } from "../domains/registry/registry-factory";
 import { searchRoutes } from "../domains/search/search-route";
 import { SearchSO } from "../domains/search/search-so";
 import { getServerPort, isSearchEnabled } from "../shared/config/environment";
 import { getDirname } from "../shared/utils";
+// Initialize Registry Factory with the local repository
+initRegistryFactory(repository);
 const initializeSearchService = async () => {
     try {
         await SearchSO.getInstance();

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

@@ -1,4 +1,6 @@
 import type { MCPSandboxProvider } from "../sandbox/sandbox-types";
+import { PackageRepository } from "./package-repository";
+export declare const repository: PackageRepository;
 export declare const packageHandler: {
     getPackageDetail: (packageName: string, sandboxProvider?: MCPSandboxProvider) => Promise<{
         success: boolean;

package/dist/domains/package/package-handler.js

@@ -6,7 +6,7 @@ import { PackageRepository } from "./package-repository";
 import { PackageSO } from "./package-so";
 const __dirname = getDirname(import.meta.url);
 const packagesDir = path.join(__dirname, "../../../packages");
-const repository = new PackageRepository(packagesDir);
+export const repository = new PackageRepository(packagesDir);
 export const packageHandler = {
     getPackageDetail: async (packageName, sandboxProvider) => {
         try {

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

@@ -1,5 +1,6 @@
+import { getRegistryProvider } from "../registry/registry-factory";
 export class PackageSO {
-    constructor(_packageName, _config, _packageInfo, _repository, _executor) {
+    constructor(_packageName, _config, _packageInfo, _executor) {
         this._packageName = _packageName;
         this._config = _config;
         this._packageInfo = _packageInfo;
@@ -24,10 +25,16 @@ export class PackageSO {
         return this._config;
     }
     static async init(packageName, repository, executor) {
-        const config = repository.getPackageConfig(packageName);
+        // Use FederatedRegistryProvider, which checks for local packages first and falls back to the official registry if not found locally.
+        const provider = getRegistryProvider("FEDERATED");
+        const config = await provider.getPackageConfig(packageName);
+        if (!config) {
+            throw new Error(`Package '${packageName}' not found`);
+        }
+        // Get package metadata (category, validated) from local repository index if available.
         const allPackages = repository.getAllPackages();
         const packageInfo = allPackages[packageName] || {};
-        return new PackageSO(packageName, config, packageInfo, repository, executor);
+        return new PackageSO(packageName, config, packageInfo, executor);
     }
     async getTools() {
         return await this._executor.listTools(this.packageName);

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

@@ -1,15 +1,20 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
+import { initRegistryFactory, resetRegistryFactory } from "../registry/registry-factory";
 import { PackageSO } from "./package-so";
 describe("PackageSO", () => {
     let mockRepository;
     let mockExecutor;
     beforeEach(() => {
+        // Reset factory before each test
+        resetRegistryFactory();
         // Mock PackageRepository
         mockRepository = {
             getPackageConfig: vi.fn(),
             getAllPackages: vi.fn(),
             exists: vi.fn(),
         };
+        // Initialize Registry Factory with mock repository
+        initRegistryFactory(mockRepository);
         // Mock ToolExecutor
         mockExecutor = {
             listTools: vi.fn(),
@@ -32,6 +37,7 @@ describe("PackageSO", () => {
                 category: "filesystem",
                 validated: true,
             };
+            vi.spyOn(mockRepository, "exists").mockReturnValue(true);
             vi.spyOn(mockRepository, "getPackageConfig").mockReturnValue(mockConfig);
             vi.spyOn(mockRepository, "getAllPackages").mockReturnValue({
                 [packageName]: mockPackageInfo,
@@ -44,6 +50,7 @@ describe("PackageSO", () => {
             expect(packageSO.description).toBe("A server for filesystem operations");
             expect(packageSO.category).toBe("filesystem");
             expect(packageSO.validated).toBe(true);
+            expect(mockRepository.exists).toHaveBeenCalledWith(packageName);
             expect(mockRepository.getPackageConfig).toHaveBeenCalledWith(packageName);
             expect(mockRepository.getAllPackages).toHaveBeenCalled();
         });
@@ -57,6 +64,7 @@ describe("PackageSO", () => {
                 name: "New Package",
                 description: "A new package",
             };
+            vi.spyOn(mockRepository, "exists").mockReturnValue(true);
             vi.spyOn(mockRepository, "getPackageConfig").mockReturnValue(mockConfig);
             vi.spyOn(mockRepository, "getAllPackages").mockReturnValue({});
             // Act
@@ -77,6 +85,7 @@ describe("PackageSO", () => {
                 name: "Test Package",
                 description: null,
             };
+            vi.spyOn(mockRepository, "exists").mockReturnValue(true);
             vi.spyOn(mockRepository, "getPackageConfig").mockReturnValue(mockConfig);
             vi.spyOn(mockRepository, "getAllPackages").mockReturnValue({});
             // Act
@@ -119,6 +128,7 @@ describe("PackageSO", () => {
                     },
                 },
             ];
+            vi.spyOn(mockRepository, "exists").mockReturnValue(true);
             vi.spyOn(mockRepository, "getPackageConfig").mockReturnValue(mockConfig);
             vi.spyOn(mockRepository, "getAllPackages").mockReturnValue({});
             vi.spyOn(mockExecutor, "listTools").mockResolvedValue(mockTools);
@@ -142,6 +152,7 @@ describe("PackageSO", () => {
                 description: "Test description",
             };
             const errorMessage = "Failed to list tools";
+            vi.spyOn(mockRepository, "exists").mockReturnValue(true);
             vi.spyOn(mockRepository, "getPackageConfig").mockReturnValue(mockConfig);
             vi.spyOn(mockRepository, "getAllPackages").mockReturnValue({});
             vi.spyOn(mockExecutor, "listTools").mockRejectedValue(new Error(errorMessage));
@@ -165,6 +176,7 @@ describe("PackageSO", () => {
                 name: "Test Package",
                 description: "Test description",
             };
+            vi.spyOn(mockRepository, "exists").mockReturnValue(true);
             vi.spyOn(mockRepository, "getPackageConfig").mockReturnValue(mockConfig);
             vi.spyOn(mockRepository, "getAllPackages").mockReturnValue({});
             vi.spyOn(mockExecutor, "executeTool").mockResolvedValue(mockResult);
@@ -194,6 +206,7 @@ describe("PackageSO", () => {
                 name: "Test Package",
                 description: "Test description",
             };
+            vi.spyOn(mockRepository, "exists").mockReturnValue(true);
             vi.spyOn(mockRepository, "getPackageConfig").mockReturnValue(mockConfig);
             vi.spyOn(mockRepository, "getAllPackages").mockReturnValue({});
             vi.spyOn(mockExecutor, "executeTool").mockResolvedValue(mockResult);
@@ -222,6 +235,7 @@ describe("PackageSO", () => {
                 name: "Test Package",
                 description: "Test description",
             };
+            vi.spyOn(mockRepository, "exists").mockReturnValue(true);
             vi.spyOn(mockRepository, "getPackageConfig").mockReturnValue(mockConfig);
             vi.spyOn(mockRepository, "getAllPackages").mockReturnValue({});
             vi.spyOn(mockExecutor, "executeTool").mockRejectedValue(new Error(errorMessage));
@@ -256,6 +270,7 @@ describe("PackageSO", () => {
                     },
                 },
             ];
+            vi.spyOn(mockRepository, "exists").mockReturnValue(true);
             vi.spyOn(mockRepository, "getPackageConfig").mockReturnValue(mockConfig);
             vi.spyOn(mockRepository, "getAllPackages").mockReturnValue({
                 [packageName]: mockPackageInfo,
@@ -266,11 +281,11 @@ describe("PackageSO", () => {
             const detail = await packageSO.getDetailWithTools();
             // Assert
             expect(detail).toEqual({
+                type: "mcp-server",
+                runtime: "node",
                 name: "Test Package",
                 packageName: "@test/package",
                 description: "A test package for demonstration",
-                category: "testing",
-                validated: true,
                 tools: mockTools,
             });
         });
@@ -284,6 +299,7 @@ describe("PackageSO", () => {
                 name: "Test Package",
                 description: "Test description",
             };
+            vi.spyOn(mockRepository, "exists").mockReturnValue(true);
             vi.spyOn(mockRepository, "getPackageConfig").mockReturnValue(mockConfig);
             vi.spyOn(mockRepository, "getAllPackages").mockReturnValue({});
             vi.spyOn(mockExecutor, "listTools").mockRejectedValue(new Error("Failed to get tools"));
@@ -309,6 +325,7 @@ describe("PackageSO", () => {
                 description: "A minimal package",
             };
             const mockTools = [];
+            vi.spyOn(mockRepository, "exists").mockReturnValue(true);
             vi.spyOn(mockRepository, "getPackageConfig").mockReturnValue(mockConfig);
             vi.spyOn(mockRepository, "getAllPackages").mockReturnValue({});
             vi.spyOn(mockExecutor, "listTools").mockResolvedValue(mockTools);
@@ -317,12 +334,12 @@ describe("PackageSO", () => {
             const detail = await packageSO.getDetailWithTools();
             // Assert
             expect(detail).toEqual({
+                type: "mcp-server",
+                runtime: "node",
                 name: "Minimal Package",
                 packageName: "@test/minimal-package",
                 description: "A minimal package",
-                category: undefined,
-                validated: undefined,
-                tools: mockTools,
+                tools: [],
             });
         });
     });
@@ -342,6 +359,7 @@ describe("PackageSO", () => {
                 category: "test-category",
                 validated: false,
             };
+            vi.spyOn(mockRepository, "exists").mockReturnValue(true);
             vi.spyOn(mockRepository, "getPackageConfig").mockReturnValue(mockConfig);
             vi.spyOn(mockRepository, "getAllPackages").mockReturnValue({
                 [packageName]: mockPackageInfo,
@@ -366,6 +384,7 @@ describe("PackageSO", () => {
                 name: "Test Package",
                 description: "Test description",
             };
+            vi.spyOn(mockRepository, "exists").mockReturnValue(true);
             vi.spyOn(mockRepository, "getPackageConfig").mockReturnValue(mockConfig);
             vi.spyOn(mockRepository, "getAllPackages").mockReturnValue({});
             // Act

package/dist/domains/registry/__tests__/federated-registry-provider.test.d.ts

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

package/dist/domains/registry/__tests__/federated-registry-provider.test.js

@@ -0,0 +1,125 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { FederatedRegistryProvider } from "../providers/federated-registry-provider";
+describe("FederatedRegistryProvider", () => {
+    let mockLocalProvider;
+    let mockOfficialProvider;
+    let provider;
+    beforeEach(() => {
+        // Mock LocalRegistryProvider
+        mockLocalProvider = {
+            getPackageConfig: vi.fn(),
+            exists: vi.fn(),
+        };
+        // Mock OfficialRegistryProvider
+        mockOfficialProvider = {
+            getPackageConfig: vi.fn(),
+            exists: vi.fn(),
+            search: vi.fn(),
+        };
+        provider = new FederatedRegistryProvider(mockLocalProvider, mockOfficialProvider);
+    });
+    describe("getPackageConfig", () => {
+        it("should return local config when package exists locally", async () => {
+            // Arrange
+            const packageName = "@modelcontextprotocol/server-filesystem";
+            const mockConfig = {
+                type: "mcp-server",
+                runtime: "node",
+                packageName,
+                name: "Filesystem Server",
+                description: "A server for filesystem operations",
+            };
+            vi.spyOn(mockLocalProvider, "getPackageConfig").mockResolvedValue(mockConfig);
+            // Act
+            const result = await provider.getPackageConfig(packageName);
+            // Assert
+            expect(result).toEqual(mockConfig);
+            expect(mockLocalProvider.getPackageConfig).toHaveBeenCalledWith(packageName);
+            expect(mockOfficialProvider.getPackageConfig).not.toHaveBeenCalled();
+        });
+        it("should query official provider when local returns null", async () => {
+            // Arrange
+            const packageName = "@toolsdk.ai/tavily-mcp";
+            const officialConfig = {
+                type: "mcp-server",
+                runtime: "node",
+                packageName,
+                name: "Tavily MCP Server",
+                description: "MCP server for Tavily search",
+            };
+            vi.spyOn(mockLocalProvider, "getPackageConfig").mockResolvedValue(null);
+            vi.spyOn(mockOfficialProvider, "getPackageConfig").mockResolvedValue(officialConfig);
+            // Act
+            const result = await provider.getPackageConfig(packageName);
+            // Assert
+            expect(result).toEqual(officialConfig);
+            expect(mockLocalProvider.getPackageConfig).toHaveBeenCalledWith(packageName);
+            expect(mockOfficialProvider.getPackageConfig).toHaveBeenCalledWith(packageName);
+        });
+        it("should return null when both providers return null", async () => {
+            // Arrange
+            const packageName = "non-existent-package";
+            vi.spyOn(mockLocalProvider, "getPackageConfig").mockResolvedValue(null);
+            vi.spyOn(mockOfficialProvider, "getPackageConfig").mockResolvedValue(null);
+            // Act
+            const result = await provider.getPackageConfig(packageName);
+            // Assert
+            expect(result).toBeNull();
+        });
+        it("should return null when official provider throws error", async () => {
+            // Arrange
+            const packageName = "@toolsdk.ai/tavily-mcp";
+            vi.spyOn(mockLocalProvider, "getPackageConfig").mockResolvedValue(null);
+            vi.spyOn(mockOfficialProvider, "getPackageConfig").mockRejectedValue(new Error("Network error"));
+            // Act
+            const result = await provider.getPackageConfig(packageName);
+            // Assert
+            expect(result).toBeNull();
+        });
+    });
+    describe("exists", () => {
+        it("should return true when package exists locally", async () => {
+            // Arrange
+            const packageName = "@modelcontextprotocol/server-filesystem";
+            vi.spyOn(mockLocalProvider, "exists").mockResolvedValue(true);
+            // Act
+            const result = await provider.exists(packageName);
+            // Assert
+            expect(result).toBe(true);
+            expect(mockLocalProvider.exists).toHaveBeenCalledWith(packageName);
+            expect(mockOfficialProvider.exists).not.toHaveBeenCalled();
+        });
+        it("should check official provider when local returns false", async () => {
+            // Arrange
+            const packageName = "@toolsdk.ai/tavily-mcp";
+            vi.spyOn(mockLocalProvider, "exists").mockResolvedValue(false);
+            vi.spyOn(mockOfficialProvider, "exists").mockResolvedValue(true);
+            // Act
+            const result = await provider.exists(packageName);
+            // Assert
+            expect(result).toBe(true);
+            expect(mockLocalProvider.exists).toHaveBeenCalledWith(packageName);
+            expect(mockOfficialProvider.exists).toHaveBeenCalledWith(packageName);
+        });
+        it("should return false when both providers return false", async () => {
+            // Arrange
+            const packageName = "non-existent-package";
+            vi.spyOn(mockLocalProvider, "exists").mockResolvedValue(false);
+            vi.spyOn(mockOfficialProvider, "exists").mockResolvedValue(false);
+            // Act
+            const result = await provider.exists(packageName);
+            // Assert
+            expect(result).toBe(false);
+        });
+        it("should return false when official provider throws error", async () => {
+            // Arrange
+            const packageName = "@toolsdk.ai/tavily-mcp";
+            vi.spyOn(mockLocalProvider, "exists").mockResolvedValue(false);
+            vi.spyOn(mockOfficialProvider, "exists").mockRejectedValue(new Error("Network error"));
+            // Act
+            const result = await provider.exists(packageName);
+            // Assert
+            expect(result).toBe(false);
+        });
+    });
+});

package/dist/domains/registry/__tests__/local-registry-provider.test.d.ts

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

package/dist/domains/registry/__tests__/local-registry-provider.test.js

@@ -0,0 +1,80 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { LocalRegistryProvider } from "../providers/local-registry-provider";
+describe("LocalRegistryProvider", () => {
+    let mockRepository;
+    let provider;
+    beforeEach(() => {
+        // Mock PackageRepository
+        mockRepository = {
+            getPackageConfig: vi.fn(),
+            getAllPackages: vi.fn(),
+            exists: vi.fn(),
+        };
+        provider = new LocalRegistryProvider(mockRepository);
+    });
+    describe("getPackageConfig", () => {
+        it("should return package config when package exists", async () => {
+            // Arrange
+            const packageName = "@modelcontextprotocol/server-filesystem";
+            const mockConfig = {
+                type: "mcp-server",
+                runtime: "node",
+                packageName,
+                name: "Filesystem Server",
+                description: "A server for filesystem operations",
+            };
+            vi.spyOn(mockRepository, "exists").mockReturnValue(true);
+            vi.spyOn(mockRepository, "getPackageConfig").mockReturnValue(mockConfig);
+            // Act
+            const result = await provider.getPackageConfig(packageName);
+            // Assert
+            expect(result).toEqual(mockConfig);
+            expect(mockRepository.exists).toHaveBeenCalledWith(packageName);
+            expect(mockRepository.getPackageConfig).toHaveBeenCalledWith(packageName);
+        });
+        it("should return null when package does not exist", async () => {
+            // Arrange
+            const packageName = "non-existent-package";
+            vi.spyOn(mockRepository, "exists").mockReturnValue(false);
+            // Act
+            const result = await provider.getPackageConfig(packageName);
+            // Assert
+            expect(result).toBeNull();
+            expect(mockRepository.exists).toHaveBeenCalledWith(packageName);
+            expect(mockRepository.getPackageConfig).not.toHaveBeenCalled();
+        });
+        it("should return null when getPackageConfig throws error", async () => {
+            // Arrange
+            const packageName = "@modelcontextprotocol/server-filesystem";
+            vi.spyOn(mockRepository, "exists").mockReturnValue(true);
+            vi.spyOn(mockRepository, "getPackageConfig").mockImplementation(() => {
+                throw new Error("File read error");
+            });
+            // Act
+            const result = await provider.getPackageConfig(packageName);
+            // Assert
+            expect(result).toBeNull();
+        });
+    });
+    describe("exists", () => {
+        it("should return true when package exists", async () => {
+            // Arrange
+            const packageName = "@modelcontextprotocol/server-filesystem";
+            vi.spyOn(mockRepository, "exists").mockReturnValue(true);
+            // Act
+            const result = await provider.exists(packageName);
+            // Assert
+            expect(result).toBe(true);
+            expect(mockRepository.exists).toHaveBeenCalledWith(packageName);
+        });
+        it("should return false when package does not exist", async () => {
+            // Arrange
+            const packageName = "non-existent-package";
+            vi.spyOn(mockRepository, "exists").mockReturnValue(false);
+            // Act
+            const result = await provider.exists(packageName);
+            // Assert
+            expect(result).toBe(false);
+        });
+    });
+});

package/dist/domains/registry/__tests__/official-registry-provider.integration.test.d.ts

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

package/dist/domains/registry/__tests__/official-registry-provider.integration.test.js

@@ -0,0 +1,70 @@
+import { describe, expect, it } from "vitest";
+import { OfficialRegistryProvider } from "../providers/official-registry-provider";
+/**
+ * Integration tests for OfficialRegistryProvider
+ * These tests call the real official API
+ */
+describe("OfficialRegistryProvider - Integration", () => {
+    const provider = new OfficialRegistryProvider();
+    describe("search", () => {
+        it("should search and return results from official API", async () => {
+            // Act - search for tavily
+            const results = await provider.search("tavily");
+            // Assert
+            expect(results).toBeDefined();
+            expect(Array.isArray(results)).toBe(true);
+            // Log results for debugging
+            console.log(`Found ${results.length} results for 'tavily'`);
+            if (results.length > 0) {
+                console.log("First result:", JSON.stringify(results[0], null, 2));
+            }
+        }, 10000); // 10s timeout for network call
+        it("should return empty array for non-existent package", async () => {
+            // Act
+            const results = await provider.search("non-existent-package-xyz-123");
+            // Assert
+            expect(results).toBeDefined();
+            expect(Array.isArray(results)).toBe(true);
+            expect(results.length).toBe(0);
+        }, 10000);
+    });
+    describe("getPackageConfig", () => {
+        it("should get config for tavily-mcp package", async () => {
+            // Act
+            const config = await provider.getPackageConfig("tavily");
+            // Assert
+            if (config) {
+                console.log("Tavily package config:", JSON.stringify(config, null, 2));
+                expect(config.type).toBe("mcp-server");
+                expect(config.runtime).toBe("node");
+                expect(config.packageName).toBeDefined();
+                expect(config.name).toBeDefined();
+            }
+            else {
+                console.log("No tavily package found");
+            }
+        }, 10000);
+        it("should return null for non-existent package", async () => {
+            // Act
+            const config = await provider.getPackageConfig("non-existent-package-xyz-123");
+            // Assert
+            expect(config).toBeNull();
+        }, 10000);
+    });
+    describe("exists", () => {
+        it("should return true for existing package", async () => {
+            // Act
+            const exists = await provider.exists("tavily");
+            // Assert
+            console.log(`Tavily exists: ${exists}`);
+            // We expect it to exist, but don't fail the test if the API changes
+            expect(typeof exists).toBe("boolean");
+        }, 10000);
+        it("should return false for non-existent package", async () => {
+            // Act
+            const exists = await provider.exists("non-existent-package-xyz-123");
+            // Assert
+            expect(exists).toBe(false);
+        }, 10000);
+    });
+});

package/dist/domains/registry/__tests__/registry-utils.test.d.ts

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