@toolsdk.ai/registry 1.0.123 → 1.0.125

package/README.md

@@ -6,10 +6,10 @@
 
 [![Product Hunt](https://api.producthunt.com/widgets/embed-image/v1/top-post-badge.svg?post_id=997428&theme=light&period=daily)](https://www.producthunt.com/products/toolsdk-ai)
 
-![How many MCP Servers in ToolSDK MCP Registry](https://img.shields.io/badge/MCP_Servers-4108-blue)
+![How many MCP Servers in ToolSDK MCP Registry](https://img.shields.io/badge/MCP_Servers-4109-blue)
 ![toolsdk-mcp-registry License](https://img.shields.io/badge/LICENSE-MIT-ff69b4)
 
-🚀 **Open-source**, **production-ready**, and **developer-friendly** registry for 4108+ Model Context Protocol (MCP) servers, plugins, and AI agent tools.
+🚀 **Open-source**, **production-ready**, and **developer-friendly** registry for 4109+ Model Context Protocol (MCP) servers, plugins, and AI agent tools.
 
 Perfect for **AI automation**, **chatbot development**, **LLM integrations**, and **enterprise AI deployments**.
 
@@ -24,7 +24,7 @@ Perfect for **AI automation**, **chatbot development**, **LLM integrations**, an
 ### 🎯 Key Features
 
 - 🔐 **Private & Self-Hosted** - Deploy your own secure MCP registry with Docker in minutes
-- 🤖 **4108+ AI Tools** - Largest curated collection of MCP servers for Claude, LLMs, and AI agents
+- 🤖 **4109+ AI Tools** - Largest curated collection of MCP servers for Claude, LLMs, and AI agents
 - ⚡ **Remote Execution** - Run MCP tools in isolated sandbox environments via REST API
 - 🔍 **Powerful Search** - Fast, full-text search powered by Meilisearch
 - 📦 **NPM Integration** - Use as a TypeScript/Node.js SDK in your projects
@@ -46,7 +46,7 @@ Perfect for **AI automation**, **chatbot development**, **LLM integrations**, an
 
 This open-source registry provides:
 
-- 📚 **Structured Database** - 4108+ validated MCP servers with metadata
+- 📚 **Structured Database** - 4109+ validated MCP servers with metadata
 - 🔗 **Multiple Formats** - JSON, npm package, and generated documentation
 - 🌐 **REST API** - Query and execute tools remotely
 - 📖 **Auto-Generated Docs** - Always up-to-date README and API documentation
@@ -134,7 +134,7 @@ That's it! Your self-hosted MCP registry is now running with:
 
 - 🌐 **Web Interface**: http://localhost:3003
 - 📚 **Swagger API Docs**: http://localhost:3003/swagger  
-- 🔍 **Search & Execute** 4108+ MCP tools remotely
+- 🔍 **Search & Execute** 4109+ MCP tools remotely
 - 🤖 **Integrate** with your AI agents, chatbots, and LLM applications
 
 #### 💻 Remote Tool Execution Example
@@ -241,7 +241,7 @@ Help grow the world's largest open-source MCP registry! Share your AI tools, plu
 
 - [Fork this repository](https://github.com/toolsdk-ai/toolsdk-mcp-registry/fork)
 - Create `your-mcp-server.json` in [packages/uncategorized](./packages/uncategorized)
-- Submit a PR and join 4108+ MCP servers!
+- Submit a PR and join 4109+ MCP servers!
 
 **3. Get Discovered**
 
@@ -259,9 +259,9 @@ Your MCP server will be:
 
 ## 📋 MCP Servers Directory
 
-**4108+ AI Agent Tools, LLM Integrations & Automation Servers**
+**4109+ AI Agent Tools, LLM Integrations & Automation Servers**
 
-- ✅ **Validated & Tested** (709) - Production-ready MCP servers
+- ✅ **Validated & Tested** (710) - Production-ready MCP servers
 - ⚙️ **Community Contributed** (3399) - Requires configuration
 
 Browse by category: Developer Tools, AI Agents, Databases, Cloud Platforms, APIs, and more!
@@ -970,6 +970,7 @@ Run code securely, perfect for coding agents and AI-driven programming tasks.
 - [✅ node-code-sandbox-mcp](https://github.com/ssdeanx/node-code-sandbox-mcp): Provides a secure Docker-based environment for executing Node.js code with npm dependencies, shell commands, and file operations while maintaining proper isolation for testing and web development prototyping.  (7 tools) (node) 
 - [✅ nrepl-mcp-server](https://github.com/johancodinha/nrepl-mcp-server): Integrates with Clojure nREPL instances to enable code evaluation, namespace listing, and public var inspection for AI-assisted Clojure development.  (3 tools) (node) 
 - [✅ python-local](https://github.com/alec2435/python_mcp): Provides an interactive Python REPL environment for executing code within conversations, maintaining separate state for each session and supporting both expressions and statements.  (1 tools) (python) 
+- [✅ sandock-mcp](https://github.com/sandock-ai/sandock): A Model Context Protocol server for running code in a secure sandbox by Sandock.  (1 tools) (node) 
 - [❌ @pydantic/mcp-run-python](https://github.com/pydantic/pydantic-ai/tree/HEAD/mcp-run-python): Provides a browser-compatible Python execution environment with package management capabilities for running code snippets safely without requiring a backend Python installation.  (node) 
 - [❌ @yepcode/mcp-server](https://github.com/yepcode/mcp-server-js): Enables secure execution of LLM-generated scripts and processes in isolated environments with environment variable management for teams needing to run code directly from AI assistants.  (node) 
 - [❌ ai-meta-tool-creator](https://github.com/alxspiker/ai-meta-mcp-server): Enables AI to dynamically create, execute, and manage custom tools in a secure sandbox environment for JavaScript, Python, or shell code with persistent storage capabilities.  (node) 

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 {};