@toolsdk.ai/registry 1.0.96 → 1.0.98

package/README.md

@@ -1,5 +1,7 @@
 # Awesome MCP Registry
 
+[![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 Awesome MCP Registry](https://img.shields.io/badge/MCP_Servers-4082-blue)
 ![awesome-mcp-registry License](https://img.shields.io/badge/LICENSE-MIT-ff69b4)
 

package/dist/api/index.d.ts

@@ -1,3 +1,3 @@
-import { Hono } from 'hono';
-declare const app: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+import { OpenAPIHono } from '@hono/zod-openapi';
+declare const app: OpenAPIHono;
 export default app;

package/dist/api/index.js

@@ -1,15 +1,29 @@
 import dotenv from 'dotenv';
 import path from 'path';
-import { Hono } from 'hono';
 import { serve } from '@hono/node-server';
 import { packageRoutes } from './package-route';
+import { OpenAPIHono } from '@hono/zod-openapi';
+import { swaggerUI } from '@hono/swagger-ui';
 dotenv.config({ path: path.resolve(process.cwd(), '.env.local') });
 dotenv.config({ path: path.resolve(process.cwd(), '.env') });
-const app = new Hono();
+const app = new OpenAPIHono();
 app.route('/api/v1', packageRoutes);
 app.get('/', (c) => {
     return c.text('MCP Registry API Server is running!');
 });
+app.get('/api/meta', (c) => {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const packageJson = require('../../package.json');
+    return c.json({ version: packageJson.version });
+});
+app.doc('/api/v1/doc', {
+    openapi: '3.0.0',
+    info: {
+        version: '1.0.0',
+        title: 'MCP Registry API',
+    },
+});
+app.get('/swagger', swaggerUI({ url: '/api/v1/doc' }));
 app.notFound((c) => {
     return c.json({ success: false, code: 404, message: 'Route not found' }, 404);
 });

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

@@ -1,12 +1,16 @@
 import { Context } from 'hono';
 export declare const packageHandler: {
-    executeTool: (c: Context) => Promise<(globalThis.Response & import("hono").TypedResponse<never, 200 | 500, "json">) | (globalThis.Response & import("hono").TypedResponse<{
-        success: false;
+    executeTool: (c: Context) => Promise<(globalThis.Response & import("hono").TypedResponse<never, 200, "json">) | (globalThis.Response & import("hono").TypedResponse<{
+        success: boolean;
         code: number;
         message: string;
     }, 404, "json">)>;
     getPackageDetail: (c: Context) => Promise<(globalThis.Response & import("hono").TypedResponse<{
-        success: false;
+        success: boolean;
+        code: number;
+        message: string;
+    }, 404, "json">) | (globalThis.Response & import("hono").TypedResponse<{
+        success: boolean;
         code: number;
         message: string;
     }, 400, "json">) | (globalThis.Response & import("hono").TypedResponse<{
@@ -17,9 +21,9 @@ export declare const packageHandler: {
             type: "mcp-server";
             packageName: string;
             runtime: "node" | "python" | "java" | "go";
-            key?: string | undefined;
-            name?: string | undefined;
             description?: string | undefined;
+            name?: string | undefined;
+            key?: string | undefined;
             packageVersion?: string | undefined;
             bin?: string | undefined;
             binArgs?: string[] | undefined;
@@ -34,6 +38,85 @@ export declare const packageHandler: {
                     required: boolean;
                 };
             } | undefined;
+            tools?: {
+                [x: string]: never;
+                name: string;
+                inputSchema: {
+                    [x: string]: never;
+                    type: "object";
+                    properties?: {
+                        [x: string]: never;
+                    } | undefined;
+                    required?: string[] | undefined;
+                };
+                description?: string | undefined;
+                title?: string | undefined;
+                outputSchema?: {
+                    [x: string]: never;
+                    type: "object";
+                    properties?: {
+                        [x: string]: never;
+                    } | undefined;
+                    required?: string[] | undefined;
+                } | undefined;
+                annotations?: {
+                    [x: string]: never;
+                    title?: string | undefined;
+                    readOnlyHint?: boolean | undefined;
+                    destructiveHint?: boolean | undefined;
+                    idempotentHint?: boolean | undefined;
+                    openWorldHint?: boolean | undefined;
+                } | undefined;
+                _meta?: {
+                    [x: string]: never;
+                } | undefined;
+            }[] | undefined;
         } | undefined;
-    }, 200 | 404, "json">)>;
+    }, 200, "json">)>;
+    listTools: (c: Context) => Promise<(globalThis.Response & import("hono").TypedResponse<{
+        success: boolean;
+        code: number;
+        message: string;
+    }, 404, "json">) | (globalThis.Response & import("hono").TypedResponse<{
+        success: boolean;
+        code: number;
+        message: string;
+    }, 400, "json">) | (globalThis.Response & import("hono").TypedResponse<{
+        success: boolean;
+        code: number;
+        message: string;
+        data?: {
+            [x: string]: never;
+            name: string;
+            inputSchema: {
+                [x: string]: never;
+                type: "object";
+                properties?: {
+                    [x: string]: never;
+                } | undefined;
+                required?: string[] | undefined;
+            };
+            description?: string | undefined;
+            title?: string | undefined;
+            outputSchema?: {
+                [x: string]: never;
+                type: "object";
+                properties?: {
+                    [x: string]: never;
+                } | undefined;
+                required?: string[] | undefined;
+            } | undefined;
+            annotations?: {
+                [x: string]: never;
+                title?: string | undefined;
+                readOnlyHint?: boolean | undefined;
+                destructiveHint?: boolean | undefined;
+                idempotentHint?: boolean | undefined;
+                openWorldHint?: boolean | undefined;
+            } | undefined;
+            _meta?: {
+                [x: string]: never;
+            } | undefined;
+        }[] | undefined;
+    }, 200, "json">)>;
 };

package/dist/api/package-handler.js

@@ -1,20 +1,24 @@
 import { PackageSO } from './package-so';
+import { createErrorResponse, createResponse } from '../utils';
 export const packageHandler = {
     executeTool: async (c) => {
         const requestBody = await c.req.json();
         try {
             const toolSO = new PackageSO();
             const result = await toolSO.executeTool(requestBody);
-            const statusCode = result.success ? 200 : 500;
-            return c.json(result, statusCode);
+            const response = createResponse(result);
+            return c.json(response, 200);
         }
         catch (error) {
-            if (error instanceof Error && (error.message.includes('not found') || error.message.includes('Unknown tool'))) {
-                return c.json({
-                    success: false,
-                    code: 404,
-                    message: `Package '${requestBody.packageName}' or tool '${requestBody.toolKey}' not found`,
-                }, 404);
+            if (error instanceof Error) {
+                if (error.message.includes('not found')) {
+                    const errorResponse = createErrorResponse(`Package '${requestBody.packageName}' not found`, 404);
+                    return c.json(errorResponse, 404);
+                }
+                if (error.message.includes('Unknown tool')) {
+                    const errorResponse = createErrorResponse(`Tool '${requestBody.toolKey}' not found in package '${requestBody.packageName}`, 404);
+                    return c.json(errorResponse, 404);
+                }
             }
             // Other errors are still thrown
             throw error;
@@ -23,15 +27,41 @@ export const packageHandler = {
     getPackageDetail: async (c) => {
         const packageName = c.req.query('packageName');
         if (!packageName) {
-            return c.json({
-                success: false,
-                code: 400,
-                message: 'Missing packageName query parameter',
-            }, 400);
-        }
-        const toolSO = new PackageSO();
-        const result = await toolSO.getPackageDetail(packageName);
-        const statusCode = result.success ? 200 : 404;
-        return c.json(result, statusCode);
+            const errorResponse = createErrorResponse('Missing packageName query parameter', 400);
+            return c.json(errorResponse, 400);
+        }
+        try {
+            const toolSO = new PackageSO();
+            const result = await toolSO.getPackageDetail(packageName);
+            const response = createResponse(result);
+            return c.json(response, 200);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('not found')) {
+                const errorResponse = createErrorResponse(`Package '${packageName}' not found`, 404);
+                return c.json(errorResponse, 404);
+            }
+            throw error;
+        }
+    },
+    listTools: async (c) => {
+        const packageName = c.req.query('packageName');
+        if (!packageName) {
+            const errorResponse = createErrorResponse('Missing packageName query parameter', 400);
+            return c.json(errorResponse, 400);
+        }
+        try {
+            const toolSO = new PackageSO();
+            const result = await toolSO.listTools(packageName);
+            const response = createResponse(result);
+            return c.json(response, 200);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('not found')) {
+                const errorResponse = createErrorResponse(`Package '${packageName}' not found`, 404);
+                return c.json(errorResponse, 404);
+            }
+            throw error;
+        }
     },
 };

package/dist/api/package-route.d.ts

@@ -1,2 +1,2 @@
-import { Hono } from 'hono';
-export declare const packageRoutes: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+import { OpenAPIHono } from '@hono/zod-openapi';
+export declare const packageRoutes: OpenAPIHono;

package/dist/api/package-route.js

@@ -1,36 +1,72 @@
 /* eslint-disable @typescript-eslint/no-require-imports */
-import { Hono } from 'hono';
 import { packageHandler } from './package-handler';
-export const packageRoutes = new Hono();
-packageRoutes.post('/packages/run', packageHandler.executeTool);
-packageRoutes.get('/packages/detail', packageHandler.getPackageDetail);
-packageRoutes.get('/config/categories', (c) => {
-    const categories = require('../../config/categories.mjs').default;
-    const response = {
-        success: true,
-        code: 200,
-        message: 'Categories retrieved successfully',
-        data: categories,
-    };
-    return c.json(response);
-});
-packageRoutes.get('/config/featured', (c) => {
+import { OpenAPIHono, createRoute } from '@hono/zod-openapi';
+import { FeaturedResponseSchema, CategoriesResponseSchema, PackagesListResponseSchema, PackageDetailResponseSchema, ToolsResponseSchema, ToolExecuteSchema, ExecuteToolResponseSchema, packageNameQuerySchema, } from '../schema';
+import { createResponse, createRouteResponses } from '../utils';
+export const packageRoutes = new OpenAPIHono();
+const featuredRoute = createRoute({
+    method: 'get',
+    path: '/config/featured',
+    responses: createRouteResponses(FeaturedResponseSchema),
+});
+packageRoutes.openapi(featuredRoute, (c) => {
     const featured = require('../../config/featured.mjs').default;
-    const response = {
-        success: true,
-        code: 200,
-        message: 'Featured list retrieved successfully',
-        data: featured,
-    };
-    return c.json(response);
-});
-packageRoutes.get('/indexes/packages-list', async (c) => {
+    const response = createResponse(featured);
+    return c.json(response, 200);
+});
+const categoriesRoute = createRoute({
+    method: 'get',
+    path: '/config/categories',
+    responses: createRouteResponses(CategoriesResponseSchema),
+});
+packageRoutes.openapi(categoriesRoute, (c) => {
+    const categories = require('../../config/categories.mjs').default;
+    const response = createResponse(categories);
+    return c.json(response, 200);
+});
+const packagesListRoute = createRoute({
+    method: 'get',
+    path: '/indexes/packages-list',
+    responses: createRouteResponses(PackagesListResponseSchema),
+});
+packageRoutes.openapi(packagesListRoute, async (c) => {
     const packagesList = (await import('../../indexes/packages-list.json')).default;
-    const response = {
-        success: true,
-        code: 200,
-        message: 'Packages list retrieved successfully',
-        data: packagesList,
-    };
-    return c.json(response);
+    const response = createResponse(packagesList);
+    return c.json(response, 200);
+});
+const packageDetailRoute = createRoute({
+    method: 'get',
+    path: '/packages/detail',
+    request: { query: packageNameQuerySchema },
+    responses: createRouteResponses(PackageDetailResponseSchema, {
+        includeErrorResponses: true,
+    }),
+});
+packageRoutes.openapi(packageDetailRoute, packageHandler.getPackageDetail);
+const toolsRoute = createRoute({
+    method: 'get',
+    path: '/packages/tools',
+    request: { query: packageNameQuerySchema },
+    responses: createRouteResponses(ToolsResponseSchema, {
+        includeErrorResponses: true,
+    }),
+});
+packageRoutes.openapi(toolsRoute, packageHandler.listTools);
+const executeToolRoute = createRoute({
+    method: 'post',
+    path: '/packages/run',
+    request: {
+        body: {
+            content: {
+                'application/json': {
+                    schema: ToolExecuteSchema,
+                },
+            },
+            required: true,
+        },
+    },
+    responses: createRouteResponses(ExecuteToolResponseSchema, {
+        includeErrorResponses: true,
+    }),
 });
+packageRoutes.openapi(executeToolRoute, packageHandler.executeTool);

package/dist/api/package-so.d.ts

@@ -1,5 +1,7 @@
-import type { MCPServerPackageConfig, ToolExecute, Response } from '../types';
+import type { MCPServerPackageConfig, ToolExecute } from '../types';
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
 export declare class PackageSO {
-    executeTool(request: ToolExecute): Promise<Response<unknown>>;
-    getPackageDetail(packageName: string): Promise<Response<MCPServerPackageConfig>>;
+    executeTool(request: ToolExecute): Promise<unknown>;
+    listTools(packageName: string): Promise<Tool[]>;
+    getPackageDetail(packageName: string): Promise<MCPServerPackageConfig>;
 }

package/dist/api/package-so.js

@@ -11,12 +11,25 @@ export class PackageSO {
                 arguments: request.inputData,
             });
             console.log(`Tool ${request.toolKey} executed successfully`);
-            return {
-                success: true,
-                code: 200,
-                message: 'Tool executed successfully',
-                data: result,
-            };
+            return result;
+        }
+        finally {
+            await closeConnection();
+        }
+    }
+    async listTools(packageName) {
+        const mcpServerConfig = getPackageConfigByKey(packageName);
+        const mockEnvs = {};
+        if (mcpServerConfig.env) {
+            Object.keys(mcpServerConfig.env).forEach((key) => {
+                mockEnvs[key] = 'mock_value';
+            });
+        }
+        const { client, closeConnection } = await getMcpClient(mcpServerConfig, mockEnvs);
+        try {
+            const { tools } = await client.listTools();
+            console.log(`Tools list retrieved successfully for package ${packageName}`);
+            return tools;
         }
         finally {
             await closeConnection();
@@ -25,20 +38,21 @@ export class PackageSO {
     async getPackageDetail(packageName) {
         const packageInfo = typedAllPackagesList[packageName];
         if (!packageInfo) {
-            return {
-                success: false,
-                code: 404,
-                message: `Package ${packageName} not found`,
-            };
+            throw new Error(`Package ${packageName} not found`);
         }
         const jsonFilePath = path.join(__dirname, '../../packages/', packageInfo.path);
         const jsonStr = fs.readFileSync(jsonFilePath, 'utf-8');
         const packageConfig = JSON.parse(jsonStr);
-        return {
-            success: true,
-            code: 200,
-            message: 'Package detail retrieved successfully',
-            data: packageConfig,
-        };
+        let tools;
+        try {
+            tools = await this.listTools(packageName);
+        }
+        catch (error) {
+            console.warn(`Warn retrieving tools for package ${packageName}:`, error.message);
+            // if tools cannot be retrieved, set tools to undefined
+            tools = undefined;
+        }
+        const packageConfigWithTools = Object.assign(Object.assign({}, packageConfig), { tools });
+        return packageConfigWithTools;
     }
 }

package/dist/api/package.test.js

@@ -11,8 +11,7 @@ describe('PackageSO - MCP Tool Execution Service Test', () => {
             envs: {},
         };
         const result = await toolSO.executeTool(request);
-        expect(result.success).toBe(true);
-        expect(result.data).toEqual({
+        expect(result).toEqual({
             content: [],
             message: 'Hello, Mike!',
         });

package/dist/helper.d.ts

@@ -6,8 +6,8 @@ export declare const typedAllPackagesList: Record<string, {
     category?: string | undefined;
     validated?: boolean | undefined;
     tools?: Record<string, {
-        name?: string | undefined;
         description?: string | undefined;
+        name?: string | undefined;
     }> | undefined;
 }>;
 export declare function getPackageConfigByKey(packageKey: string): MCPServerPackageConfig;

package/dist/helper.js

@@ -76,8 +76,10 @@ export function updatePackageJsonDependencies({ packageDeps, enableValidation =
     const newDeps = {
         '@modelcontextprotocol/sdk': '^1.12.0',
         '@hono/node-server': '1.15.0',
+        '@hono/swagger-ui': '^0.5.2',
+        '@hono/zod-openapi': '^0.16.4',
         lodash: '^4.17.21',
-        zod: '^3.23.30',
+        zod: '^3.25.67',
         axios: '^1.9.0',
         hono: '4.8.3',
         semver: '^7.5.4',