@toolsdk.ai/registry 1.0.113 → 1.0.115

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 Awesome MCP Registry](https://img.shields.io/badge/MCP_Servers-4107-blue)
+![How many MCP Servers in Awesome MCP Registry](https://img.shields.io/badge/MCP_Servers-4108-blue)
 ![awesome-mcp-registry License](https://img.shields.io/badge/LICENSE-MIT-ff69b4)
 
-An open, high-quality, well-structured and developer-friendly list of 4107+ MCP servers.
+An open, high-quality, well-structured and developer-friendly list of 4108+ MCP servers.
 
 ---
 
@@ -21,7 +21,7 @@ You can use it to:
 
 - ⚡ Build and host your own MCP projects with ease  
 - 🔒 Deploy a fully **private registry** for your team or organization  
-- 🛠️ Maintain complete control of your MCP tools in a secure environment  
+- 🚀 **Execute MCP tools remotely** in a secure sandbox environment  
 
 This registry leverages structured JSON configs to generate:  
 
@@ -31,10 +31,17 @@ This registry leverages structured JSON configs to generate:
 
 ---
 
-- [Video: How to submit a MCP server in JSON file?](https://www.youtube.com/watch?v=J_oaDtCoVVo)
-- [Quick Start](#quick-start)
-- [Contributing Guide](./docs/guide.md)
-- [Awesome MCP Servers](#mcp-servers)
+## 📚 Table of Contents
+
+- [🎥 Video: How to submit a MCP server in JSON file?](https://www.youtube.com/watch?v=J_oaDtCoVVo)
+- [🚀 Quick Start](#quick-start)
+  - [🐳 Docker Self-Hosting](#-docker-self-hosting)
+  - [📦 Install via Package Manager](#install-via-package-manager)
+  - [📄 Submit New MCP Servers](#submit-new-mcp-servers)
+- [📖 Development Guide](./docs/DEVELOPMENT.md)
+- [🤝 Contributing Guide](./docs/guide.md)
+- [⭐ Awesome MCP Servers](#mcp-servers)
+
   - [Uncategorized](#uncategorized)
   - [Aggregators](#aggregators)
   - [Art & Culture](#art-and-culture)
@@ -71,19 +78,62 @@ This registry leverages structured JSON configs to generate:
 
 ## 🚀 Quick Start
 
-#### Install via package manager:
+### 🐳 Docker Self-Hosting
+
+Deploy your **private MCP Registry** in 5 minutes with Docker! Take full control of your MCP servers with search functionality and secure sandbox execution.
+
+#### Quick Deploy (2 Steps)
+
+**Step 1: Get and Set API Key**
+
+- Get your Sandock API Key from https://sandock.ai
+- Edit `.env` and set: `SANDOCK_API_KEY=your-api-key-here`
+
+**Step 2: Start services**
+
+```bash
+docker compose up -d
+```
+
+#### 🎉 Access Your Private Registry
+
+- 🌐 **Web Interface**: http://localhost:3003
+- 📚 **API Documentation**: http://localhost:3003/swagger  
+- 🔍 **Search & Execute** MCP tools remotely
+
+#### Usage Example
+
+```bash
+# Execute a tool remotely
+curl -X POST http://localhost:3003/api/v1/packages/run \
+  -H "Content-Type: application/json" \
+  -d '{
+    "packageName": "@modelcontextprotocol/server-everything",
+    "toolKey": "echo",
+    "inputData": {
+      "message": "Hello, ToolSDK MCP Registry"
+    },
+    "envs": {}
+  }'
+```
+
+> For more details about Docker Self-Hosting, see the [DEVELOPMENT documentation](./docs/DEVELOPMENT.md#4--quick-start-with-docker).
+
+<a id="install-via-package-manager"></a>
+
+### Install via package manager:
 
 ```bash
 npm install @toolsdk.ai/registry
 ```
 
-#### Use it on your JavaScript / Typescript project:
+### Use it on your JavaScript / Typescript project:
 
 ```ts
 import mcpServerLists from '@toolsdk.ai/registry/indexes/packages-lists.json';
 ```
 
-#### Fetch all MCP Servers lists via cURL:
+### Fetch all MCP Servers lists via cURL:
 
 ```bash
 curl https://toolsdk-ai.github.io/awesome-mcp-registry/indexes/packages-list.json
@@ -94,6 +144,8 @@ curl https://toolsdk-ai.github.io/awesome-mcp-registry/indexes/packages-list.jso
 console.log(await(await fetch('https://toolsdk-ai.github.io/awesome-mcp-registry/indexes/packages-list.json')).json());
 ```
 
+<a id="submit-new-mcp-servers"></a>
+
 ## 📦 Submit new MCP servers:
 
 ```json
@@ -118,11 +170,13 @@ console.log(await(await fetch('https://toolsdk-ai.github.io/awesome-mcp-registry
 
 For more detail please see [the guide](./docs/guide.md).
 
+<a id="mcp-servers"></a>
+
 ## MCP Servers
 
 ✅: Validated and runnable tools (709)
 
-❌: Cannot be run by the MCP client (with mock environments variables (3398))
+❌: Cannot be run by the MCP client (with mock environments variables (3399))
 
 
 
@@ -1786,6 +1840,7 @@ Enhance your development workflow with tools for coding and environment manageme
 - [❌ @fiveohhwon/workflows-mcp](https://github.com/fiveohhwon/workflows-mcp): Provides workflow management and automation through step-by-step execution with branching logic, conditional operations, template variables, and state persistence for complex multi-step processes like code reviews and data pipelines.  (node) 
 - [❌ autodocument](https://github.com/pars-doe/autodocument): Automatically generates documentation, test plans, and code reviews for software repositories through a bottom-up analysis approach that respects .gitignore rules and handles existing file updates.  (node) 
 - [❌ gdb-debugger](https://github.com/yywz1999/gdb-mcp-server): Integrates GDB with AI capabilities to provide interactive debugging assistance for C/C++ applications, enabling breakpoint management, memory examination, and execution flow analysis during debugging sessions.  (python) 
+- [❌ @juspay/neurolink](https://github.com/juspay/neurolink): Universal AI development platform unifying 12+ providers (OpenAI, Anthropic, Google, Bedrock, Azure) with built-in MCP support, multi-provider failover, and production-ready enterprise features  (node) 
 - [❌ clojars-dependency-versions](https://github.com/bigsy/clojars-mcp-server): Retrieves information related to Clojure dependency management.  (node) 
 - [❌ react-analyzer](https://github.com/azer/react-analyzer-mcp): Enables parsing and analysis of React component structures, props, and state management patterns for code review, debugging, and understanding complex React codebases  (node) 
 - [❌ ansible](https://github.com/tarnover/mcp-sysoperator): Integrates with Ansible to enable infrastructure automation through direct execution of playbooks, ad-hoc commands, inventory management, and AWS resource operations for DevOps workflows  (node) 

package/dist/api/index.d.ts

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

package/dist/api/index.js

@@ -1,19 +1,17 @@
-import fs from "node:fs/promises";
-import path from "node:path";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 import { serve } from "@hono/node-server";
 import { swaggerUI } from "@hono/swagger-ui";
 import { OpenAPIHono } from "@hono/zod-openapi";
-import dotenv from "dotenv";
-import { searchRoutes } from "../search/search-route";
-import searchService from "../search/search-service";
-import { getDirname } from "../utils";
-import { packageRoutes } from "./package-route";
-const __dirname = getDirname(import.meta.url);
-dotenv.config({ path: path.resolve(process.cwd(), ".env.local") });
-dotenv.config({ path: path.resolve(process.cwd(), ".env") });
+import { configRoutes } from "../domains/config/config-route";
+import { packageRoutes } from "../domains/package/package-route";
+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";
 const initializeSearchService = async () => {
     try {
-        await searchService.initialize();
+        await SearchSO.getInstance();
         console.log("🔍 Search service initialized");
     }
     catch (error) {
@@ -21,22 +19,20 @@ const initializeSearchService = async () => {
         console.log("💡 Install and start MeiliSearch to enable enhanced search features");
     }
 };
+// Load search.html content
+const __dirname = getDirname(import.meta.url);
+const searchHtmlPath = join(__dirname, "../domains/search/search.html");
+const searchHtmlContent = readFileSync(searchHtmlPath, "utf-8");
 const app = new OpenAPIHono();
+// Domain routes
 app.route("/api/v1", packageRoutes);
-if (process.env.ENABLE_SEARCH === "true") {
+app.route("/api/v1/config", configRoutes);
+if (isSearchEnabled()) {
     initializeSearchService().catch(console.error);
-    app.route("/api/v1", searchRoutes);
+    app.route("/api/v1/search", searchRoutes);
 }
-app.get("/", async (c) => {
-    try {
-        const htmlPath = path.join(__dirname, "..", "search", "search.html");
-        const html = await fs.readFile(htmlPath, "utf8");
-        return c.html(html);
-    }
-    catch (error) {
-        console.error("Failed to load home page:", error);
-        return c.text("MCP Registry API Server is running!");
-    }
+app.get("/", (c) => {
+    return c.html(searchHtmlContent);
 });
 app.get("/api/meta", async (c) => {
     try {
@@ -50,6 +46,7 @@ app.get("/api/meta", async (c) => {
         return c.json({ version: "unknown" });
     }
 });
+// OpenAPI documentation
 app.doc("/api/v1/doc", {
     openapi: "3.0.0",
     info: {
@@ -57,6 +54,7 @@ app.doc("/api/v1/doc", {
         title: "MCP Registry API",
     },
 });
+// Swagger UI
 app.get("/swagger", swaggerUI({ url: "/api/v1/doc" }));
 app.notFound((c) => {
     return c.json({ success: false, code: 404, message: "[Registry API] Route not found" }, 404);
@@ -69,10 +67,10 @@ app.onError((err, c) => {
         message: `[Registry API] Internal server error, errMsg: ${err.message}`,
     }, 500);
 });
-const port = process.env.MCP_SERVER_PORT ? parseInt(process.env.MCP_SERVER_PORT, 10) : 3003;
-console.log(`Server is running on: http://localhost:${port}`);
+const port = getServerPort();
 serve({
     fetch: app.fetch,
     port,
 });
+console.log(`🚀 Server is running on http://localhost:${port}`);
 export default app;

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

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

package/dist/domains/config/config-route.js

@@ -0,0 +1,31 @@
+import path from "node:path";
+import { createRoute, OpenAPIHono } from "@hono/zod-openapi";
+import { getDirname } from "../../shared/utils/file-util";
+import { createResponse, createRouteResponses } from "../../shared/utils/response-util";
+import { configSchemas } from "./config-schema";
+const __dirname = getDirname(import.meta.url);
+export const configRoutes = new OpenAPIHono();
+const featuredRoute = createRoute({
+    method: "get",
+    path: "/featured",
+    responses: createRouteResponses(configSchemas.FeaturedResponseSchema),
+});
+configRoutes.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: "/categories",
+    responses: createRouteResponses(configSchemas.CategoriesResponseSchema),
+});
+configRoutes.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);
+});

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

@@ -0,0 +1,57 @@
+import { z } from "@hono/zod-openapi";
+export declare const configSchemas: {
+    FeaturedResponseSchema: z.ZodObject<{
+        success: z.ZodBoolean;
+        code: z.ZodNumber;
+        message: z.ZodString;
+    } & {
+        data: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        success: boolean;
+        code: number;
+        message: string;
+        data?: string[] | undefined;
+    }, {
+        success: boolean;
+        code: number;
+        message: string;
+        data?: string[] | undefined;
+    }>;
+    CategoriesResponseSchema: z.ZodObject<{
+        success: z.ZodBoolean;
+        code: z.ZodNumber;
+        message: z.ZodString;
+    } & {
+        data: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            key: string;
+            description?: string | undefined;
+        }, {
+            name: string;
+            key: string;
+            description?: string | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        success: boolean;
+        code: number;
+        message: string;
+        data?: {
+            name: string;
+            key: string;
+            description?: string | undefined;
+        }[] | undefined;
+    }, {
+        success: boolean;
+        code: number;
+        message: string;
+        data?: {
+            name: string;
+            key: string;
+            description?: string | undefined;
+        }[] | undefined;
+    }>;
+};

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

@@ -0,0 +1,10 @@
+import { z } from "@hono/zod-openapi";
+import { BaseResponseSchema, CategoryConfigSchema } from "../../shared/schemas/common-schema";
+export const configSchemas = {
+    FeaturedResponseSchema: BaseResponseSchema.extend({
+        data: z.array(z.string()).optional(),
+    }).openapi("FeaturedResponse"),
+    CategoriesResponseSchema: BaseResponseSchema.extend({
+        data: z.array(CategoryConfigSchema).optional(),
+    }).openapi("CategoriesResponse"),
+};

package/dist/domains/config/config-types.d.ts

@@ -0,0 +1,3 @@
+import type { z } from "zod";
+import type { CategoryConfigSchema } from "../../shared/schemas";
+export type CategoryConfig = z.infer<typeof CategoryConfigSchema>;

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

@@ -0,0 +1,9 @@
+import type { MCPSandboxProvider } from "../sandbox/sandbox-types";
+import type { ToolExecutor } from "./executor-types";
+/**
+ * Executor Factory
+ * Creates appropriate executor based on sandbox provider configuration
+ */
+export declare class ExecutorFactory {
+    static create(provider: MCPSandboxProvider): ToolExecutor;
+}

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

@@ -0,0 +1,17 @@
+import { LocalExecutor } from "./local-executor";
+import { SandboxExecutor } from "./sandbox-executor";
+/**
+ * Executor Factory
+ * Creates appropriate executor based on sandbox provider configuration
+ */
+// biome-ignore lint/complexity/noStaticOnlyClass: Factory pattern
+export class ExecutorFactory {
+    static create(provider) {
+        if (provider === "LOCAL") {
+            console.log("[ExecutorFactory] Creating LocalExecutor");
+            return new LocalExecutor();
+        }
+        console.log(`[ExecutorFactory] Creating SandboxExecutor with provider: ${provider}`);
+        return new SandboxExecutor(provider);
+    }
+}

package/dist/domains/executor/executor-types.d.ts

@@ -0,0 +1,15 @@
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+export interface ToolExecuteRequest {
+    packageName: string;
+    toolKey: string;
+    inputData: Record<string, unknown>;
+    envs?: Record<string, string>;
+}
+/**
+ * Tool Executor Interface
+ * Unified abstraction for local and sandbox execution
+ */
+export interface ToolExecutor {
+    executeTool(request: ToolExecuteRequest): Promise<unknown>;
+    listTools(packageName: string): Promise<Tool[]>;
+}

package/dist/domains/executor/local-executor.d.ts

@@ -0,0 +1,12 @@
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { ToolExecuteRequest, ToolExecutor } from "./executor-types";
+/**
+ * Local Executor
+ * Executes MCP tools in local environment
+ */
+export declare class LocalExecutor implements ToolExecutor {
+    private readonly packageRepository;
+    constructor();
+    executeTool(request: ToolExecuteRequest): Promise<unknown>;
+    listTools(packageName: string): Promise<Tool[]>;
+}

package/dist/domains/executor/local-executor.js

@@ -0,0 +1,48 @@
+import path from "node:path";
+import { getDirname } from "../../shared/utils/file-util";
+import { getMcpClient } from "../../shared/utils/mcp-client-util";
+import { PackageRepository } from "../package/package-repository";
+/**
+ * Local Executor
+ * Executes MCP tools in local environment
+ */
+export class LocalExecutor {
+    constructor() {
+        const __dirname = getDirname(import.meta.url);
+        const packagesDir = path.join(__dirname, "../../../packages");
+        this.packageRepository = new PackageRepository(packagesDir);
+    }
+    async executeTool(request) {
+        const mcpServerConfig = this.packageRepository.getPackageConfig(request.packageName);
+        const { client, closeConnection } = await getMcpClient(mcpServerConfig, request.envs || {});
+        try {
+            const result = await client.callTool({
+                name: request.toolKey,
+                arguments: request.inputData,
+            });
+            console.log(`[LocalExecutor] Tool ${request.toolKey} executed successfully`);
+            return result;
+        }
+        finally {
+            await closeConnection();
+        }
+    }
+    async listTools(packageName) {
+        const mcpServerConfig = this.packageRepository.getPackageConfig(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(`[LocalExecutor] Tools list retrieved successfully for package ${packageName}`);
+            return tools;
+        }
+        finally {
+            await closeConnection();
+        }
+    }
+}

package/dist/domains/executor/sandbox-executor.d.ts

@@ -0,0 +1,16 @@
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { MCPSandboxProvider } from "../sandbox/sandbox-types";
+import type { ToolExecuteRequest, ToolExecutor } from "./executor-types";
+/**
+ * Sandbox Executor
+ * Executes MCP tools in sandbox environment
+ */
+export declare class SandboxExecutor implements ToolExecutor {
+    private readonly provider;
+    private readonly sandboxPool;
+    private readonly packageRepository;
+    private readonly localExecutor;
+    constructor(provider: MCPSandboxProvider);
+    executeTool(request: ToolExecuteRequest): Promise<unknown>;
+    listTools(packageName: string): Promise<Tool[]>;
+}

package/dist/domains/executor/sandbox-executor.js

@@ -0,0 +1,83 @@
+import path from "node:path";
+import { getDirname } from "../../shared/utils/file-util";
+import { PackageRepository } from "../package/package-repository";
+import { SandboxPoolSO } from "../sandbox/sandbox-pool-so";
+import { LocalExecutor } from "./local-executor";
+/**
+ * Sandbox Executor
+ * Executes MCP tools in sandbox environment
+ */
+export class SandboxExecutor {
+    constructor(provider) {
+        this.provider = provider;
+        this.sandboxPool = SandboxPoolSO.getInstance();
+        const __dirname = getDirname(import.meta.url);
+        const packagesDir = path.join(__dirname, "../../../packages");
+        this.packageRepository = new PackageRepository(packagesDir);
+        this.localExecutor = new LocalExecutor();
+    }
+    async executeTool(request) {
+        const mcpServerConfig = this.packageRepository.getPackageConfig(request.packageName);
+        const runtime = mcpServerConfig.runtime || "python";
+        // Sandbox only supports node runtime, fallback to LOCAL for other runtimes
+        if (runtime !== "node") {
+            console.log(`[SandboxExecutor] Runtime '${runtime}' is not supported in sandbox, using LOCAL execution`);
+            return await this.localExecutor.executeTool(request);
+        }
+        const sandboxClient = await this.sandboxPool.acquire(runtime, this.provider);
+        try {
+            await sandboxClient.initialize();
+            const result = await sandboxClient.executeTool(request.packageName, request.toolKey, request.inputData || {}, request.envs);
+            console.log(`[SandboxExecutor] Tool ${request.toolKey} executed successfully in sandbox`);
+            return result;
+        }
+        catch (error) {
+            console.warn(`[SandboxExecutor] sandbox execution failed, falling back to LOCAL execution`);
+            console.warn(`[SandboxExecutor] Error: ${error instanceof Error ? error.message : String(error)}`);
+            try {
+                const result = await this.localExecutor.executeTool(request);
+                console.log(`[SandboxExecutor] Tool ${request.toolKey} executed successfully with LOCAL fallback`);
+                return result;
+            }
+            catch (localError) {
+                console.error("[SandboxExecutor] LOCAL fallback execution also failed");
+                throw localError;
+            }
+        }
+        finally {
+            await this.sandboxPool.release(runtime, this.provider);
+        }
+    }
+    async listTools(packageName) {
+        const mcpServerConfig = this.packageRepository.getPackageConfig(packageName);
+        const runtime = mcpServerConfig.runtime || "python";
+        // Sandbox only supports node runtime, fallback to LOCAL for other runtimes
+        if (runtime !== "node") {
+            console.log(`[SandboxExecutor] Runtime '${runtime}' is not supported in sandbox, using LOCAL execution`);
+            return await this.localExecutor.listTools(packageName);
+        }
+        const sandboxClient = await this.sandboxPool.acquire(runtime, this.provider);
+        try {
+            await sandboxClient.initialize();
+            const tools = await sandboxClient.listTools(packageName);
+            console.log(`[SandboxExecutor] Tools list retrieved successfully for package ${packageName}`);
+            return tools;
+        }
+        catch (error) {
+            console.warn(`[SandboxExecutor] sandbox list tools failed, falling back to LOCAL execution`);
+            console.warn(`[SandboxExecutor] Error: ${error instanceof Error ? error.message : String(error)}`);
+            try {
+                const tools = await this.localExecutor.listTools(packageName);
+                console.log(`[SandboxExecutor] Tools list retrieved successfully with LOCAL fallback`);
+                return tools;
+            }
+            catch (localError) {
+                console.error("[SandboxExecutor] LOCAL fallback list tools also failed");
+                throw localError;
+            }
+        }
+        finally {
+            await this.sandboxPool.release(runtime, this.provider);
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+export declare const packageHandler: {
+    getPackageDetail: (packageName: string) => Promise<{
+        success: boolean;
+        code: number;
+        message: string;
+    }>;
+    executeTool: (packageName: string, toolKey: string, inputData: Record<string, unknown>, envs?: Record<string, string>) => Promise<{
+        success: boolean;
+        code: number;
+        message: string;
+    }>;
+    listTools: (packageName: string) => Promise<{
+        success: boolean;
+        code: number;
+        message: string;
+    }>;
+};

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

@@ -0,0 +1,58 @@
+import path from "node:path";
+import { getSandboxProvider } from "../../shared/config/environment";
+import { getDirname } from "../../shared/utils/file-util";
+import { createErrorResponse, createResponse } from "../../shared/utils/response-util";
+import { ExecutorFactory } from "../executor/executor-factory";
+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);
+const executor = ExecutorFactory.create(getSandboxProvider());
+export const packageHandler = {
+    getPackageDetail: async (packageName) => {
+        try {
+            const packageSO = await PackageSO.init(packageName, repository, executor);
+            const result = await packageSO.getDetailWithTools();
+            return createResponse(result);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes("not found")) {
+                return createErrorResponse(`Package '${packageName}' not found`, 404);
+            }
+            throw error;
+        }
+    },
+    executeTool: async (packageName, toolKey, inputData, envs) => {
+        try {
+            const packageSO = await PackageSO.init(packageName, repository, executor);
+            const result = await packageSO.executeTool(toolKey, inputData, envs);
+            return createResponse(result);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                if (error.message.includes("not found")) {
+                    return createErrorResponse(`Package '${packageName}' not found`, 404);
+                }
+                if (error.message.includes("Unknown tool")) {
+                    return createErrorResponse(`Tool '${toolKey}' not found in package '${packageName}'`, 404);
+                }
+                return createErrorResponse(`Error: ${error.message}`, 500);
+            }
+            throw error;
+        }
+    },
+    listTools: async (packageName) => {
+        try {
+            const packageSO = await PackageSO.init(packageName, repository, executor);
+            const tools = await packageSO.getTools();
+            return createResponse(tools);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes("not found")) {
+                return createErrorResponse(`Package '${packageName}' not found`, 404);
+            }
+            throw error;
+        }
+    },
+};

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

@@ -0,0 +1,9 @@
+import type { MCPServerPackageConfig, PackagesList } from "./package-types";
+export declare class PackageRepository {
+    private readonly packagesList;
+    private readonly packagesDir;
+    constructor(packagesDir: string);
+    getPackageConfig(packageName: string): MCPServerPackageConfig;
+    getAllPackages(): PackagesList;
+    exists(packageName: string): boolean;
+}