@toolsdk.ai/registry 1.0.114 → 1.0.115

package/dist/domains/package/package-repository.js

@@ -0,0 +1,26 @@
+import fs from "node:fs";
+import path from "node:path";
+import allPackagesList from "../../../indexes/packages-list.json";
+import { MCPServerPackageConfigSchema } from "../../shared/schemas";
+export class PackageRepository {
+    constructor(packagesDir) {
+        this.packagesList = allPackagesList;
+        this.packagesDir = packagesDir;
+    }
+    getPackageConfig(packageName) {
+        const packageInfo = this.packagesList[packageName];
+        if (!packageInfo) {
+            throw new Error(`Package '${packageName}' not found`);
+        }
+        const configPath = path.join(this.packagesDir, packageInfo.path);
+        const configContent = fs.readFileSync(configPath, "utf-8");
+        const packageConfig = MCPServerPackageConfigSchema.parse(JSON.parse(configContent));
+        return packageConfig;
+    }
+    getAllPackages() {
+        return this.packagesList;
+    }
+    exists(packageName) {
+        return !!this.packagesList[packageName];
+    }
+}

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

@@ -0,0 +1,2 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+export declare const packageRoutes: OpenAPIHono<import("hono").Env, {}, "/">;

package/dist/{api → domains/package}/package-route.js

@@ -1,55 +1,9 @@
-import path from "node:path";
 import { createRoute, OpenAPIHono } from "@hono/zod-openapi";
-import { getPythonDependencies } from "../helper";
-import { CategoriesResponseSchema, ExecuteToolResponseSchema, FeaturedResponseSchema, PackageDetailResponseSchema, PackagesListResponseSchema, packageNameQuerySchema, ToolExecuteSchema, ToolsResponseSchema, } from "../schema";
-import { createResponse, createRouteResponses, getDirname } from "../utils";
+import { createResponse, createRouteResponses } from "../../shared/utils/response-util";
+import { getPythonDependencies } from "../../shared/utils/validation-util";
 import { packageHandler } from "./package-handler";
-const __dirname = getDirname(import.meta.url);
+import { ExecuteToolResponseSchema, PackageDetailResponseSchema, PackagesListResponseSchema, packageNameQuerySchema, ToolExecuteSchema, ToolsResponseSchema, } from "./package-schema";
 export const packageRoutes = new OpenAPIHono();
-const featuredRoute = createRoute({
-    method: "get",
-    path: "/config/featured",
-    responses: createRouteResponses(FeaturedResponseSchema),
-});
-packageRoutes.openapi(featuredRoute, async (c) => {
-    const featuredPath = path.join(__dirname, "../../config/featured.mjs");
-    const featuredModule = await import(`file://${featuredPath}`);
-    const featured = featuredModule.default;
-    const response = createResponse(featured);
-    return c.json(response, 200);
-});
-const categoriesRoute = createRoute({
-    method: "get",
-    path: "/config/categories",
-    responses: createRouteResponses(CategoriesResponseSchema),
-});
-packageRoutes.openapi(categoriesRoute, async (c) => {
-    const categoriesPath = path.join(__dirname, "../../config/categories.mjs");
-    const categoriesModule = await import(`file://${categoriesPath}`);
-    const categories = categoriesModule.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 = createResponse(packagesList);
-    return c.json(response, 200);
-});
-const pythonTomlRoute = createRoute({
-    method: "get",
-    path: "/python-mcp/pyproject",
-    responses: createRouteResponses(PackagesListResponseSchema),
-});
-packageRoutes.openapi(pythonTomlRoute, async (c) => {
-    const pythonDependencies = getPythonDependencies();
-    const response = createResponse(pythonDependencies);
-    return c.json(response, 200);
-});
 const packageDetailRoute = createRoute({
     method: "get",
     path: "/packages/detail",
@@ -58,7 +12,11 @@ const packageDetailRoute = createRoute({
         includeErrorResponses: true,
     }),
 });
-packageRoutes.openapi(packageDetailRoute, packageHandler.getPackageDetail);
+packageRoutes.openapi(packageDetailRoute, async (c) => {
+    const { packageName } = c.req.valid("query");
+    const result = await packageHandler.getPackageDetail(packageName);
+    return c.json(result, 200);
+});
 const toolsRoute = createRoute({
     method: "get",
     path: "/packages/tools",
@@ -67,7 +25,11 @@ const toolsRoute = createRoute({
         includeErrorResponses: true,
     }),
 });
-packageRoutes.openapi(toolsRoute, packageHandler.listTools);
+packageRoutes.openapi(toolsRoute, async (c) => {
+    const { packageName } = c.req.valid("query");
+    const result = await packageHandler.listTools(packageName);
+    return c.json(result, 200);
+});
 const executeToolRoute = createRoute({
     method: "post",
     path: "/packages/run",
@@ -85,4 +47,28 @@ const executeToolRoute = createRoute({
         includeErrorResponses: true,
     }),
 });
-packageRoutes.openapi(executeToolRoute, packageHandler.executeTool);
+packageRoutes.openapi(executeToolRoute, async (c) => {
+    const body = c.req.valid("json");
+    const result = await packageHandler.executeTool(body.packageName, body.toolKey, body.inputData, body.envs);
+    return c.json(result, 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 = createResponse(packagesList);
+    return c.json(response, 200);
+});
+const pythonTomlRoute = createRoute({
+    method: "get",
+    path: "/python-mcp/pyproject",
+    responses: createRouteResponses(PackagesListResponseSchema),
+});
+packageRoutes.openapi(pythonTomlRoute, async (c) => {
+    const pythonDependencies = getPythonDependencies();
+    const response = createResponse(pythonDependencies);
+    return c.json(response, 200);
+});

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

@@ -0,0 +1,244 @@
+import { z } from "@hono/zod-openapi";
+export declare const packageNameQuerySchema: z.ZodObject<{
+    packageName: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    packageName: string;
+}, {
+    packageName: string;
+}>;
+export declare const ToolExecuteSchema: z.ZodObject<{
+    packageName: z.ZodString;
+    toolKey: z.ZodString;
+    inputData: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    envs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    packageName: string;
+    toolKey: string;
+    inputData: Record<string, unknown>;
+    envs?: Record<string, string> | undefined;
+}, {
+    packageName: string;
+    toolKey: string;
+    inputData: Record<string, unknown>;
+    envs?: Record<string, string> | undefined;
+}>;
+export declare const PackageDetailResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    code: z.ZodNumber;
+    message: z.ZodString;
+} & {
+    data: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        packageName: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        category: z.ZodOptional<z.ZodString>;
+        validated: z.ZodOptional<z.ZodBoolean>;
+        runtime: z.ZodOptional<z.ZodEnum<["node", "python", "java", "go"]>>;
+        tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            inputSchema: z.ZodOptional<z.ZodObject<{
+                type: z.ZodString;
+                properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                type: string;
+                properties?: Record<string, unknown> | undefined;
+                required?: string[] | undefined;
+            }, {
+                type: string;
+                properties?: Record<string, unknown> | undefined;
+                required?: string[] | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            description?: string | undefined;
+            inputSchema?: {
+                type: string;
+                properties?: Record<string, unknown> | undefined;
+                required?: string[] | undefined;
+            } | undefined;
+        }, {
+            name: string;
+            description?: string | undefined;
+            inputSchema?: {
+                type: string;
+                properties?: Record<string, unknown> | undefined;
+                required?: string[] | undefined;
+            } | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        packageName: string;
+        description?: string | undefined;
+        name?: string | undefined;
+        runtime?: "node" | "python" | "java" | "go" | undefined;
+        category?: string | undefined;
+        validated?: boolean | undefined;
+        tools?: {
+            name: string;
+            description?: string | undefined;
+            inputSchema?: {
+                type: string;
+                properties?: Record<string, unknown> | undefined;
+                required?: string[] | undefined;
+            } | undefined;
+        }[] | undefined;
+    }, {
+        packageName: string;
+        description?: string | undefined;
+        name?: string | undefined;
+        runtime?: "node" | "python" | "java" | "go" | undefined;
+        category?: string | undefined;
+        validated?: boolean | undefined;
+        tools?: {
+            name: string;
+            description?: string | undefined;
+            inputSchema?: {
+                type: string;
+                properties?: Record<string, unknown> | undefined;
+                required?: string[] | undefined;
+            } | undefined;
+        }[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    code: number;
+    message: string;
+    data?: {
+        packageName: string;
+        description?: string | undefined;
+        name?: string | undefined;
+        runtime?: "node" | "python" | "java" | "go" | undefined;
+        category?: string | undefined;
+        validated?: boolean | undefined;
+        tools?: {
+            name: string;
+            description?: string | undefined;
+            inputSchema?: {
+                type: string;
+                properties?: Record<string, unknown> | undefined;
+                required?: string[] | undefined;
+            } | undefined;
+        }[] | undefined;
+    } | undefined;
+}, {
+    success: boolean;
+    code: number;
+    message: string;
+    data?: {
+        packageName: string;
+        description?: string | undefined;
+        name?: string | undefined;
+        runtime?: "node" | "python" | "java" | "go" | undefined;
+        category?: string | undefined;
+        validated?: boolean | undefined;
+        tools?: {
+            name: string;
+            description?: string | undefined;
+            inputSchema?: {
+                type: string;
+                properties?: Record<string, unknown> | undefined;
+                required?: string[] | undefined;
+            } | undefined;
+        }[] | undefined;
+    } | undefined;
+}>;
+export declare const ToolsResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    code: z.ZodNumber;
+    message: z.ZodString;
+} & {
+    data: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        inputSchema: z.ZodOptional<z.ZodObject<{
+            type: z.ZodString;
+            properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            properties?: Record<string, unknown> | undefined;
+            required?: string[] | undefined;
+        }, {
+            type: string;
+            properties?: Record<string, unknown> | undefined;
+            required?: string[] | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description?: string | undefined;
+        inputSchema?: {
+            type: string;
+            properties?: Record<string, unknown> | undefined;
+            required?: string[] | undefined;
+        } | undefined;
+    }, {
+        name: string;
+        description?: string | undefined;
+        inputSchema?: {
+            type: string;
+            properties?: Record<string, unknown> | undefined;
+            required?: string[] | undefined;
+        } | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    code: number;
+    message: string;
+    data?: {
+        name: string;
+        description?: string | undefined;
+        inputSchema?: {
+            type: string;
+            properties?: Record<string, unknown> | undefined;
+            required?: string[] | undefined;
+        } | undefined;
+    }[] | undefined;
+}, {
+    success: boolean;
+    code: number;
+    message: string;
+    data?: {
+        name: string;
+        description?: string | undefined;
+        inputSchema?: {
+            type: string;
+            properties?: Record<string, unknown> | undefined;
+            required?: string[] | undefined;
+        } | undefined;
+    }[] | undefined;
+}>;
+export declare const ExecuteToolResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    code: z.ZodNumber;
+    message: z.ZodString;
+} & {
+    data: z.ZodOptional<z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    code: number;
+    message: string;
+    data?: unknown;
+}, {
+    success: boolean;
+    code: number;
+    message: string;
+    data?: unknown;
+}>;
+export declare const PackagesListResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    code: z.ZodNumber;
+    message: z.ZodString;
+} & {
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    code: number;
+    message: string;
+    data?: Record<string, unknown> | undefined;
+}, {
+    success: boolean;
+    code: number;
+    message: string;
+    data?: Record<string, unknown> | undefined;
+}>;

package/dist/domains/package/package-schema.js

@@ -0,0 +1,52 @@
+import { z } from "@hono/zod-openapi";
+import { BaseResponseSchema } from "../../shared/schemas/common-schema";
+export const packageNameQuerySchema = z.object({
+    packageName: z
+        .string()
+        .min(1)
+        .openapi({
+        param: { name: "packageName", in: "query" },
+        example: "@modelcontextprotocol/server-filesystem",
+        description: "Package name",
+    }),
+});
+export const ToolExecuteSchema = z
+    .object({
+    packageName: z.string().openapi({ example: "@modelcontextprotocol/server-filesystem" }),
+    toolKey: z.string().openapi({ example: "read_file" }),
+    inputData: z.record(z.unknown()).openapi({ example: { path: "/tmp/test.txt" } }),
+    envs: z.record(z.string()).optional(),
+})
+    .openapi("ToolExecute");
+const ToolDataSchema = z.object({
+    name: z.string(),
+    description: z.string().optional(),
+    inputSchema: z
+        .object({
+        type: z.string(),
+        properties: z.record(z.unknown()).optional(),
+        required: z.array(z.string()).optional(),
+    })
+        .optional(),
+});
+const PackageDetailDataSchema = z.object({
+    name: z.string().optional(),
+    packageName: z.string(),
+    description: z.string().optional(),
+    category: z.string().optional(),
+    validated: z.boolean().optional(),
+    runtime: z.enum(["node", "python", "java", "go"]).optional(),
+    tools: z.array(ToolDataSchema).optional(),
+});
+export const PackageDetailResponseSchema = BaseResponseSchema.extend({
+    data: PackageDetailDataSchema.optional(),
+}).openapi("PackageDetailResponse");
+export const ToolsResponseSchema = BaseResponseSchema.extend({
+    data: z.array(ToolDataSchema).optional(),
+}).openapi("ToolsResponse");
+export const ExecuteToolResponseSchema = BaseResponseSchema.extend({
+    data: z.unknown().optional(),
+}).openapi("ExecuteToolResponse");
+export const PackagesListResponseSchema = BaseResponseSchema.extend({
+    data: z.record(z.unknown()).optional(),
+}).openapi("PackagesListResponse");

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

@@ -0,0 +1,78 @@
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { ToolExecutor } from "../executor/executor-types";
+import type { PackageRepository } from "./package-repository";
+export declare class PackageSO {
+    private readonly _packageName;
+    private readonly _config;
+    private readonly _packageInfo;
+    private readonly _executor;
+    private constructor();
+    get packageName(): string;
+    get name(): string | undefined;
+    get description(): string | undefined;
+    get category(): string | undefined;
+    get validated(): boolean | undefined;
+    get config(): {
+        type: "mcp-server";
+        runtime: "node" | "python" | "java" | "go";
+        packageName: string;
+        description?: string | undefined;
+        name?: string | undefined;
+        key?: string | undefined;
+        packageVersion?: string | undefined;
+        bin?: string | undefined;
+        binArgs?: string[] | undefined;
+        readme?: string | undefined;
+        url?: string | undefined;
+        license?: string | undefined;
+        logo?: string | undefined;
+        author?: string | undefined;
+        env?: Record<string, {
+            description: string;
+            required: boolean;
+        }> | undefined;
+    };
+    static init(packageName: string, repository: PackageRepository, executor: ToolExecutor): Promise<PackageSO>;
+    getTools(): Promise<Tool[]>;
+    executeTool(toolKey: string, inputData: Record<string, unknown>, envs?: Record<string, string>): Promise<unknown>;
+    getDetailWithTools(): Promise<{
+        name: string | undefined;
+        packageName: string;
+        description: string | undefined;
+        category: string | undefined;
+        validated: boolean | undefined;
+        tools: {
+            [x: string]: unknown;
+            name: string;
+            inputSchema: {
+                [x: string]: unknown;
+                type: "object";
+                properties?: {
+                    [x: string]: unknown;
+                } | undefined;
+                required?: string[] | undefined;
+            };
+            description?: string | undefined;
+            title?: string | undefined;
+            outputSchema?: {
+                [x: string]: unknown;
+                type: "object";
+                properties?: {
+                    [x: string]: unknown;
+                } | undefined;
+                required?: string[] | undefined;
+            } | undefined;
+            annotations?: {
+                [x: string]: unknown;
+                title?: string | undefined;
+                readOnlyHint?: boolean | undefined;
+                destructiveHint?: boolean | undefined;
+                idempotentHint?: boolean | undefined;
+                openWorldHint?: boolean | undefined;
+            } | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+        }[] | undefined;
+    }>;
+}

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

@@ -0,0 +1,61 @@
+export class PackageSO {
+    constructor(_packageName, _config, _packageInfo, _repository, _executor) {
+        this._packageName = _packageName;
+        this._config = _config;
+        this._packageInfo = _packageInfo;
+        this._executor = _executor;
+    }
+    get packageName() {
+        return this._packageName;
+    }
+    get name() {
+        return this._config.name;
+    }
+    get description() {
+        return this._config.description;
+    }
+    get category() {
+        return this._packageInfo.category;
+    }
+    get validated() {
+        return this._packageInfo.validated;
+    }
+    get config() {
+        return this._config;
+    }
+    static async init(packageName, repository, executor) {
+        const config = repository.getPackageConfig(packageName);
+        const allPackages = repository.getAllPackages();
+        const packageInfo = allPackages[packageName] || {};
+        return new PackageSO(packageName, config, packageInfo, repository, executor);
+    }
+    async getTools() {
+        return await this._executor.listTools(this.packageName);
+    }
+    async executeTool(toolKey, inputData, envs) {
+        return await this._executor.executeTool({
+            packageName: this.packageName,
+            toolKey,
+            inputData,
+            envs,
+        });
+    }
+    async getDetailWithTools() {
+        let tools;
+        try {
+            tools = await this.getTools();
+        }
+        catch (error) {
+            console.warn(`[PackageSO] Failed to get tools for ${this.packageName}:`, error);
+            tools = undefined;
+        }
+        return {
+            name: this.name,
+            packageName: this.packageName,
+            description: this.description,
+            category: this.category,
+            validated: this.validated,
+            tools,
+        };
+    }
+}