@toolsdk.ai/registry 1.0.124 → 1.0.125

package/dist/domains/registry/__tests__/registry-utils.test.js

@@ -0,0 +1,307 @@
+import { describe, expect, it } from "vitest";
+import { transformAndFilterServers, transformServer } from "../registry-utils";
+describe("registry-utils", () => {
+    describe("transformServer", () => {
+        it("should transform npm+stdio package correctly", () => {
+            // Arrange
+            const officialServer = {
+                name: "io.github.Seey215/tavily-mcp",
+                title: "Tavily MCP Server",
+                description: "MCP server for advanced web search using Tavily API.",
+                repository: {
+                    url: "https://github.com/Seey215/tavily-mcp",
+                },
+                version: "0.2.9",
+                packages: [
+                    {
+                        registryType: "npm",
+                        identifier: "@toolsdk.ai/tavily-mcp",
+                        version: "0.2.9",
+                        transport: {
+                            type: "stdio",
+                        },
+                        environmentVariables: [
+                            {
+                                name: "TAVILY_API_KEY",
+                                description: "Your TAVILY_API_KEY",
+                                isRequired: true,
+                                isSecret: true,
+                            },
+                        ],
+                    },
+                ],
+            };
+            // Act
+            const result = transformServer(officialServer);
+            // Assert
+            expect(result).not.toBeNull();
+            expect(result).toMatchObject({
+                type: "mcp-server",
+                runtime: "node",
+                packageName: "@toolsdk.ai/tavily-mcp",
+                packageVersion: "0.2.9",
+                name: "Tavily MCP Server",
+                description: "MCP server for advanced web search using Tavily API.",
+                url: "https://github.com/Seey215/tavily-mcp",
+                env: {
+                    TAVILY_API_KEY: {
+                        description: "Your TAVILY_API_KEY",
+                        required: true,
+                    },
+                },
+            });
+        });
+        it("should use title as name if available", () => {
+            // Arrange
+            const officialServer = {
+                name: "io.github.test/package",
+                title: "Test Package Title",
+                packages: [
+                    {
+                        registryType: "npm",
+                        identifier: "@test/package",
+                        transport: {
+                            type: "stdio",
+                        },
+                    },
+                ],
+            };
+            // Act
+            const result = transformServer(officialServer);
+            // Assert
+            expect(result === null || result === void 0 ? void 0 : result.name).toBe("Test Package Title");
+        });
+        it("should use name if title is not available", () => {
+            // Arrange
+            const officialServer = {
+                name: "io.github.test/package",
+                packages: [
+                    {
+                        registryType: "npm",
+                        identifier: "@test/package",
+                        transport: {
+                            type: "stdio",
+                        },
+                    },
+                ],
+            };
+            // Act
+            const result = transformServer(officialServer);
+            // Assert
+            expect(result === null || result === void 0 ? void 0 : result.name).toBe("io.github.test/package");
+        });
+        it("should return null for non-npm packages", () => {
+            // Arrange
+            const officialServer = {
+                name: "io.github.test/docker-package",
+                packages: [
+                    {
+                        registryType: "docker",
+                        identifier: "test/package",
+                        transport: {
+                            type: "stdio",
+                        },
+                    },
+                ],
+            };
+            // Act
+            const result = transformServer(officialServer);
+            // Assert
+            expect(result).toBeNull();
+        });
+        it("should return null for non-stdio transport", () => {
+            // Arrange
+            const officialServer = {
+                name: "io.github.test/sse-package",
+                packages: [
+                    {
+                        registryType: "npm",
+                        identifier: "@test/package",
+                        transport: {
+                            type: "sse",
+                        },
+                    },
+                ],
+            };
+            // Act
+            const result = transformServer(officialServer);
+            // Assert
+            expect(result).toBeNull();
+        });
+        it("should select first npm+stdio package when multiple packages exist", () => {
+            // Arrange
+            const officialServer = {
+                name: "io.github.test/multi-package",
+                packages: [
+                    {
+                        registryType: "docker",
+                        identifier: "test/docker",
+                        transport: {
+                            type: "stdio",
+                        },
+                    },
+                    {
+                        registryType: "npm",
+                        identifier: "@test/first-npm",
+                        transport: {
+                            type: "stdio",
+                        },
+                    },
+                    {
+                        registryType: "npm",
+                        identifier: "@test/second-npm",
+                        transport: {
+                            type: "stdio",
+                        },
+                    },
+                ],
+            };
+            // Act
+            const result = transformServer(officialServer);
+            // Assert
+            expect(result).not.toBeNull();
+            expect(result === null || result === void 0 ? void 0 : result.packageName).toBe("@test/first-npm");
+        });
+        it("should handle empty environment variables", () => {
+            // Arrange
+            const officialServer = {
+                name: "io.github.test/no-env",
+                packages: [
+                    {
+                        registryType: "npm",
+                        identifier: "@test/package",
+                        transport: {
+                            type: "stdio",
+                        },
+                    },
+                ],
+            };
+            // Act
+            const result = transformServer(officialServer);
+            // Assert
+            expect(result).not.toBeNull();
+            expect(result === null || result === void 0 ? void 0 : result.env).toBeUndefined();
+        });
+        it("should handle optional environment variable fields", () => {
+            // Arrange
+            const officialServer = {
+                name: "io.github.test/package",
+                packages: [
+                    {
+                        registryType: "npm",
+                        identifier: "@test/package",
+                        transport: {
+                            type: "stdio",
+                        },
+                        environmentVariables: [
+                            {
+                                name: "API_KEY",
+                                // description and isRequired are optional
+                            },
+                        ],
+                    },
+                ],
+            };
+            // Act
+            const result = transformServer(officialServer);
+            // Assert
+            expect(result).not.toBeNull();
+            expect(result === null || result === void 0 ? void 0 : result.env).toEqual({
+                API_KEY: {
+                    description: "",
+                    required: false,
+                },
+            });
+        });
+    });
+    describe("transformAndFilterServers", () => {
+        it("should transform and filter multiple servers", () => {
+            // Arrange
+            const servers = [
+                {
+                    name: "io.github.test/npm-stdio",
+                    packages: [
+                        {
+                            registryType: "npm",
+                            identifier: "@test/npm-stdio",
+                            transport: { type: "stdio" },
+                        },
+                    ],
+                },
+                {
+                    name: "io.github.test/docker",
+                    packages: [
+                        {
+                            registryType: "docker",
+                            identifier: "test/docker",
+                            transport: { type: "stdio" },
+                        },
+                    ],
+                },
+                {
+                    name: "io.github.test/npm-sse",
+                    packages: [
+                        {
+                            registryType: "npm",
+                            identifier: "@test/npm-sse",
+                            transport: { type: "sse" },
+                        },
+                    ],
+                },
+                {
+                    name: "io.github.test/another-npm-stdio",
+                    packages: [
+                        {
+                            registryType: "npm",
+                            identifier: "@test/another-npm-stdio",
+                            transport: { type: "stdio" },
+                        },
+                    ],
+                },
+            ];
+            // Act
+            const result = transformAndFilterServers(servers);
+            // Assert
+            expect(result).toHaveLength(2);
+            expect(result[0].packageName).toBe("@test/npm-stdio");
+            expect(result[1].packageName).toBe("@test/another-npm-stdio");
+        });
+        it("should return empty array when no servers match criteria", () => {
+            // Arrange
+            const servers = [
+                {
+                    name: "io.github.test/docker",
+                    packages: [
+                        {
+                            registryType: "docker",
+                            identifier: "test/docker",
+                            transport: { type: "stdio" },
+                        },
+                    ],
+                },
+                {
+                    name: "io.github.test/npm-sse",
+                    packages: [
+                        {
+                            registryType: "npm",
+                            identifier: "@test/npm-sse",
+                            transport: { type: "sse" },
+                        },
+                    ],
+                },
+            ];
+            // Act
+            const result = transformAndFilterServers(servers);
+            // Assert
+            expect(result).toHaveLength(0);
+        });
+        it("should handle empty array", () => {
+            // Arrange
+            const servers = [];
+            // Act
+            const result = transformAndFilterServers(servers);
+            // Assert
+            expect(result).toHaveLength(0);
+        });
+    });
+});

package/dist/domains/registry/index.d.ts

@@ -0,0 +1,8 @@
+export { FederatedRegistryProvider } from "./providers/federated-registry-provider";
+export { LocalRegistryProvider } from "./providers/local-registry-provider";
+export { OfficialRegistryProvider } from "./providers/official-registry-provider";
+export type { RegistryProviderType } from "./registry-factory";
+export { getRegistryProvider, initRegistryFactory, resetRegistryFactory, } from "./registry-factory";
+export type { OfficialEnvironmentVariable, OfficialPackage, OfficialRepository, OfficialSearchResponse, OfficialServer, OfficialServerItem, OfficialTransport, } from "./registry-schema";
+export type { IRegistryProvider, RegistrySource } from "./registry-types";
+export { transformAndFilterServers, transformServer } from "./registry-utils";

package/dist/domains/registry/index.js

@@ -0,0 +1,9 @@
+// Types and interfaces
+export { FederatedRegistryProvider } from "./providers/federated-registry-provider";
+// Providers
+export { LocalRegistryProvider } from "./providers/local-registry-provider";
+export { OfficialRegistryProvider } from "./providers/official-registry-provider";
+// Factory
+export { getRegistryProvider, initRegistryFactory, resetRegistryFactory, } from "./registry-factory";
+// Utils
+export { transformAndFilterServers, transformServer } from "./registry-utils";

package/dist/domains/registry/providers/federated-registry-provider.d.ts

@@ -0,0 +1,25 @@
+import type { MCPServerPackageConfig } from "../../package/package-types";
+import type { IRegistryProvider } from "../registry-types";
+import type { LocalRegistryProvider } from "./local-registry-provider";
+import type { OfficialRegistryProvider } from "./official-registry-provider";
+/**
+ * Federated Registry Provider
+ * Implements local-first federated query strategy
+ */
+export declare class FederatedRegistryProvider implements IRegistryProvider {
+    private readonly localProvider;
+    private readonly officialProvider;
+    constructor(localProvider: LocalRegistryProvider, officialProvider: OfficialRegistryProvider);
+    /**
+     * Get package configuration (local first)
+     * @param packageName - Package name
+     * @returns Package configuration, null if not found
+     */
+    getPackageConfig(packageName: string): Promise<MCPServerPackageConfig | null>;
+    /**
+     * Check if package exists
+     * @param packageName - Package name
+     * @returns Whether the package exists
+     */
+    exists(packageName: string): Promise<boolean>;
+}

package/dist/domains/registry/providers/federated-registry-provider.js

@@ -0,0 +1,49 @@
+/**
+ * Federated Registry Provider
+ * Implements local-first federated query strategy
+ */
+export class FederatedRegistryProvider {
+    constructor(localProvider, officialProvider) {
+        this.localProvider = localProvider;
+        this.officialProvider = officialProvider;
+    }
+    /**
+     * Get package configuration (local first)
+     * @param packageName - Package name
+     * @returns Package configuration, null if not found
+     */
+    async getPackageConfig(packageName) {
+        // 1. Query local first
+        const localConfig = await this.localProvider.getPackageConfig(packageName);
+        if (localConfig) {
+            return localConfig;
+        }
+        // 2. If not found locally, query official
+        try {
+            const officialConfig = await this.officialProvider.getPackageConfig(packageName);
+            return officialConfig;
+        }
+        catch (error) {
+            console.warn(`[FederatedRegistry] Failed to fetch from official: ${error}`);
+            return null; // Official API failed, return null
+        }
+    }
+    /**
+     * Check if package exists
+     * @param packageName - Package name
+     * @returns Whether the package exists
+     */
+    async exists(packageName) {
+        // 1. Check local first
+        if (await this.localProvider.exists(packageName)) {
+            return true;
+        }
+        // 2. Then check official
+        try {
+            return await this.officialProvider.exists(packageName);
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+}

package/dist/domains/registry/providers/local-registry-provider.d.ts

@@ -0,0 +1,23 @@
+import type { PackageRepository } from "../../package/package-repository";
+import type { MCPServerPackageConfig } from "../../package/package-types";
+import type { IRegistryProvider } from "../registry-types";
+/**
+ * Local Registry Provider adapter
+ * Wraps PackageRepository as an async interface
+ */
+export declare class LocalRegistryProvider implements IRegistryProvider {
+    private readonly packageRepository;
+    constructor(packageRepository: PackageRepository);
+    /**
+     * Get package configuration
+     * @param packageName - Package name
+     * @returns Package configuration, null if not found
+     */
+    getPackageConfig(packageName: string): Promise<MCPServerPackageConfig | null>;
+    /**
+     * Check if package exists
+     * @param packageName - Package name
+     * @returns Whether the package exists
+     */
+    exists(packageName: string): Promise<boolean>;
+}

package/dist/domains/registry/providers/local-registry-provider.js

@@ -0,0 +1,35 @@
+/**
+ * Local Registry Provider adapter
+ * Wraps PackageRepository as an async interface
+ */
+export class LocalRegistryProvider {
+    constructor(packageRepository) {
+        this.packageRepository = packageRepository;
+    }
+    /**
+     * Get package configuration
+     * @param packageName - Package name
+     * @returns Package configuration, null if not found
+     */
+    async getPackageConfig(packageName) {
+        if (!this.packageRepository.exists(packageName)) {
+            return null;
+        }
+        try {
+            const config = this.packageRepository.getPackageConfig(packageName);
+            return config;
+        }
+        catch (error) {
+            console.error(`[LocalRegistry] Failed to get package config for '${packageName}':`, error);
+            return null;
+        }
+    }
+    /**
+     * Check if package exists
+     * @param packageName - Package name
+     * @returns Whether the package exists
+     */
+    async exists(packageName) {
+        return this.packageRepository.exists(packageName);
+    }
+}

package/dist/domains/registry/providers/official-registry-provider.d.ts

@@ -0,0 +1,34 @@
+import type { MCPServerPackageConfig } from "../../package/package-types";
+import type { IRegistryProvider } from "../registry-types";
+/**
+ * Official Registry Provider
+ * Responsible for calling official API and transforming data
+ */
+export declare class OfficialRegistryProvider implements IRegistryProvider {
+    private readonly baseUrl;
+    private readonly timeout;
+    /**
+     * Get package configuration
+     * @param packageName - Package name (official Registry ID)
+     * @returns Package configuration, null if not found
+     */
+    getPackageConfig(packageName: string): Promise<MCPServerPackageConfig | null>;
+    /**
+     * Check if package exists
+     * @param packageName - Package name
+     * @returns Whether the package exists
+     */
+    exists(packageName: string): Promise<boolean>;
+    /**
+     * Search packages
+     * @param query - Search keyword
+     * @returns List of package configurations
+     */
+    search(query: string): Promise<MCPServerPackageConfig[]>;
+    /**
+     * Fetch data from official API
+     * @param endpoint - API endpoint
+     * @returns Response data
+     */
+    private fetchFromOfficial;
+}

package/dist/domains/registry/providers/official-registry-provider.js

@@ -0,0 +1,83 @@
+import { OfficialSearchResponseSchema, } from "../registry-schema";
+import { transformAndFilterServers } from "../registry-utils";
+/**
+ * Official Registry Provider
+ * Responsible for calling official API and transforming data
+ */
+export class OfficialRegistryProvider {
+    constructor() {
+        this.baseUrl = "https://registry.modelcontextprotocol.io/v0.1";
+        this.timeout = 5000; // 5 second timeout
+    }
+    /**
+     * Get package configuration
+     * @param packageName - Package name (official Registry ID)
+     * @returns Package configuration, null if not found
+     */
+    async getPackageConfig(packageName) {
+        try {
+            // 1. Call search API
+            const searchResults = await this.search(packageName);
+            // 2. Return first result (if exists)
+            if (searchResults.length > 0) {
+                return searchResults[0];
+            }
+            return null;
+        }
+        catch (error) {
+            console.warn(`[OfficialRegistry] Failed to get package config for '${packageName}':`, error);
+            return null;
+        }
+    }
+    /**
+     * Check if package exists
+     * @param packageName - Package name
+     * @returns Whether the package exists
+     */
+    async exists(packageName) {
+        const config = await this.getPackageConfig(packageName);
+        return config !== null;
+    }
+    /**
+     * Search packages
+     * @param query - Search keyword
+     * @returns List of package configurations
+     */
+    async search(query) {
+        try {
+            const response = await this.fetchFromOfficial(`/servers?search=${encodeURIComponent(query)}`);
+            const servers = response.servers.map((item) => item.server);
+            return transformAndFilterServers(servers);
+        }
+        catch (error) {
+            console.error(`[OfficialRegistry] Search error for '${query}':`, error);
+            return [];
+        }
+    }
+    /**
+     * Fetch data from official API
+     * @param endpoint - API endpoint
+     * @returns Response data
+     */
+    async fetchFromOfficial(endpoint) {
+        const url = `${this.baseUrl}${endpoint}`;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await fetch(url, {
+                signal: controller.signal,
+                headers: {
+                    Accept: "application/json",
+                },
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const data = await response.json();
+            return OfficialSearchResponseSchema.parse(data);
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+}

package/dist/domains/registry/registry-factory.d.ts

@@ -0,0 +1,21 @@
+import type { PackageRepository } from "../package/package-repository";
+import type { IRegistryProvider } from "./registry-types";
+/**
+ * Registry Provider type
+ */
+export type RegistryProviderType = "LOCAL" | "OFFICIAL" | "FEDERATED";
+/**
+ * Initialize Registry Factory
+ * @param packageRepository - Local package repository
+ */
+export declare function initRegistryFactory(packageRepository: PackageRepository): void;
+/**
+ * Get Registry Provider
+ * @param type - Provider type, defaults to FEDERATED
+ * @returns Registry Provider instance
+ */
+export declare function getRegistryProvider(type?: RegistryProviderType): IRegistryProvider;
+/**
+ * Reset factory (mainly used for testing)
+ */
+export declare function resetRegistryFactory(): void;

package/dist/domains/registry/registry-factory.js

@@ -0,0 +1,52 @@
+import { FederatedRegistryProvider } from "./providers/federated-registry-provider";
+import { LocalRegistryProvider } from "./providers/local-registry-provider";
+import { OfficialRegistryProvider } from "./providers/official-registry-provider";
+/**
+ * Registry Provider instance container
+ */
+let localProvider = null;
+let officialProvider = null;
+let federatedProvider = null;
+let initialized = false;
+/**
+ * Initialize Registry Factory
+ * @param packageRepository - Local package repository
+ */
+export function initRegistryFactory(packageRepository) {
+    if (initialized) {
+        return;
+    }
+    localProvider = new LocalRegistryProvider(packageRepository);
+    officialProvider = new OfficialRegistryProvider();
+    federatedProvider = new FederatedRegistryProvider(localProvider, officialProvider);
+    initialized = true;
+}
+/**
+ * Get Registry Provider
+ * @param type - Provider type, defaults to FEDERATED
+ * @returns Registry Provider instance
+ */
+export function getRegistryProvider(type = "FEDERATED") {
+    if (!initialized || !localProvider || !officialProvider || !federatedProvider) {
+        throw new Error("RegistryFactory not initialized. Call initRegistryFactory() first.");
+    }
+    switch (type) {
+        case "LOCAL":
+            return localProvider;
+        case "OFFICIAL":
+            return officialProvider;
+        case "FEDERATED":
+            return federatedProvider;
+        default:
+            throw new Error(`Unknown provider type: ${type}`);
+    }
+}
+/**
+ * Reset factory (mainly used for testing)
+ */
+export function resetRegistryFactory() {
+    localProvider = null;
+    officialProvider = null;
+    federatedProvider = null;
+    initialized = false;
+}