@toolsdk.ai/registry 1.0.131 → 1.0.133

package/README.md

@@ -13,7 +13,7 @@
   <a href="https://github.com/toolsdk-ai/toolsdk-mcp-registry/actions/workflows/test.yaml">
     <img src="https://github.com/toolsdk-ai/toolsdk-mcp-registry/actions/workflows/test.yaml/badge.svg" alt="Build Status" />
   </a>
-  <img src="https://img.shields.io/badge/MCP_Servers-4109-blue?style=flat-square" alt="MCP Servers Count" />
+  <img src="https://img.shields.io/badge/MCP_Servers-4110-blue?style=flat-square" alt="MCP Servers Count" />
   <img src="https://img.shields.io/badge/LICENSE-MIT-ff69b4?style=flat-square" alt="License" />
 </p>
 
@@ -24,7 +24,7 @@
 </p>
 
 <p align="center">
-  🚀 <b>Open-source</b>, <b>production-ready</b>, and <b>developer-friendly</b> registry for 4109+ Model Context Protocol (MCP) servers.
+  🚀 <b>Open-source</b>, <b>production-ready</b>, and <b>developer-friendly</b> registry for 4110+ Model Context Protocol (MCP) servers.
   <br />
   <i>Perfect for <b>AI automation</b>, <b>chatbot development</b>, <b>LLM integrations</b>, and <b>enterprise AI deployments</b>.</i>
 </p>
@@ -34,7 +34,7 @@
 </p>
 
 <p align="center">
-  <a href="#mcp-servers">🔍 <b>Browse 4109+ Tools</b></a>
+  <a href="#mcp-servers">🔍 <b>Browse 4110+ Tools</b></a>
   &nbsp;&nbsp;•&nbsp;&nbsp;
   <a href="#quick-start">🐳 <b>Deploy Private Registry</b></a>
   &nbsp;&nbsp;•&nbsp;&nbsp;
@@ -73,7 +73,7 @@ docker compose up -d
 - *See [Configuration Guide](./docs/DEVELOPMENT.md) for full details.*
 
 > 💡 **Tip for Private Deployment**:
-> This registry contains 4109+ public MCP servers. If you only need a specific subset for your private environment, you can prune the `packages/` directory.
+> This registry contains 4110+ public MCP servers. If you only need a specific subset for your private environment, you can prune the `packages/` directory.
 > 📖 See [Package Management Guide](./docs/DEVELOPMENT.md#5--package-management-for-private-deployment) for details.
 
 That's it! Your self-hosted MCP registry is now running with:
@@ -85,7 +85,7 @@ That's it! Your self-hosted MCP registry is now running with:
 
 - 🌐 **Local Web Interface**: http://localhost:3003
 - 📚 **Swagger API Docs**: http://localhost:3003/swagger  
-- 🔍 **Search & Execute** 4109+ MCP Servers remotely
+- 🔍 **Search & Execute** 4110+ MCP Servers remotely
 - 🤖 **Integrate** with your AI agents, chatbots, and LLM applications
 
 #### 💻 Remote Tool Execution Example
@@ -169,7 +169,7 @@ mcp_servers = requests.get(
 ### 🎯 Key Features
 
 - 🔐 **Private & Self-Hosted** - Deploy your own secure MCP registry with Docker in minutes
-- 🤖 **4109+ MCP Servers** - Largest curated collection of MCP servers
+- 🤖 **4110+ MCP Servers** - Largest curated collection of MCP servers
 - ⚡ **Remote Execution** - Run MCP tools in isolated sandbox environments via REST API
 - 🔍 **Powerful Search** - Fast, full-text search powered by Meilisearch
 - 📦 **NPM Integration** - Use as a TypeScript/Node.js SDK in your projects
@@ -225,7 +225,7 @@ graph TD
 
 This open-source registry provides:
 
-- 📚 **Structured Registry** - 4109+ validated MCP servers with metadata
+- 📚 **Structured Registry** - 4110+ validated MCP servers with metadata
 - 🔗 **Multiple Formats** - JSON, npm package, and generated documentation
 - 🌐 **REST API** - Query and execute tools remotely
 - 📖 **Auto-Generated Docs** - Always up-to-date README and API documentation
@@ -313,7 +313,7 @@ Help grow the world's largest open-source MCP registry! Share your AI tools, plu
 
 - [Fork this repository](https://github.com/toolsdk-ai/toolsdk-mcp-registry/fork)
 - Create `your-mcp-server.json` in [packages/uncategorized](./packages/uncategorized)
-- Submit a PR and join 4109+ MCP servers!
+- Submit a PR and join 4110+ MCP servers!
 
 **3. Get Discovered**
 
@@ -331,9 +331,9 @@ Your MCP server will be:
 
 ## 📋 MCP Servers Directory
 
-**4109+ AI Agent Tools, LLM Integrations & Automation Servers**
+**4110+ AI Agent Tools, LLM Integrations & Automation Servers**
 
-- ✅ **Validated & Tested** (710) - Production-ready MCP servers
+- ✅ **Validated & Tested** (711) - Production-ready MCP servers
 - ⚙️ **Community Contributed** (3399) - Requires configuration
 
 Browse by category: Developer Tools, AI Agents, Databases, Cloud Platforms, APIs, and more!
@@ -1908,6 +1908,7 @@ Enhance your development workflow with tools for coding and environment manageme
 - [✅ deepsource-mcp-server](https://github.com/sapientpants/deepsource-mcp-server): Integrates with DeepSource's code quality platform to provide access to project metrics, issues, and analysis results for monitoring and troubleshooting code quality directly in conversations.  (10 tools) (node) 
 - [✅ freecad-mcp](https://github.com/neka-nat/freecad-mcp): Enables AI-driven CAD modeling by providing a remote procedure call (RPC) server that allows programmatic control of FreeCAD, supporting operations like creating documents, inserting parts, editing objects, and executing Python code for generative design workflows.  (10 tools) (python) 
 - [✅ gistpad-mcp](https://github.com/lostintangent/gistpad-mcp): Transforms GitHub Gists into a personal knowledge management system with specialized handling for daily notes, reusable prompts with frontmatter support, and comprehensive gist operations including creation, updating, archiving, and commenting for version-controlled knowledge storage.  (28 tools) (node) 
+- [✅ github-mcp](https://github.com/Seey215/github-mcp): A powerful GitHub automation tool that seamlessly connects AI assistants to your GitHub repositories  (2 tools) (node) 
 - [✅ ios-simulator-mcp](https://github.com/joshuayoes/ios-simulator-mcp): Enables Claude to control iOS simulators for testing and debugging applications by providing tools for UI interaction, element inspection, and device information retrieval through Facebook's IDB tool.  (10 tools) (node) 
 - [✅ it-tools-mcp](https://github.com/wrenchpilot/it-tools-mcp): Provides 50+ developer utilities including cryptographic operations, text processing, data format conversion, network calculations, and encoding functions through a containerized TypeScript server with security features and rate limiting.  (119 tools) (node) 
 - [✅ jnews-mcp-server](https://github.com/juhemcp/jnews-mcp-server): Lightweight Python FastAPI server implementation for streamlined server-side interactions, using modern tooling like uv for dependency management and GitHub Actions for automated testing and deployment.  (2 tools) (python) 

package/dist/api/index.js

@@ -4,6 +4,7 @@ import { serve } from "@hono/node-server";
 import { swaggerUI } from "@hono/swagger-ui";
 import { OpenAPIHono } from "@hono/zod-openapi";
 import { configRoutes } from "../domains/config/config-route";
+import { oauthDemoRoutes, oauthRoutes } from "../domains/oauth/oauth-route";
 import { repository } from "../domains/package/package-handler";
 import { packageRoutes } from "../domains/package/package-route";
 import { initRegistryFactory } from "../domains/registry/registry-factory";
@@ -31,6 +32,9 @@ const app = new OpenAPIHono();
 // Domain routes
 app.route("/api/v1", packageRoutes);
 app.route("/api/v1/config", configRoutes);
+app.route("/api/v1/oauth", oauthRoutes);
+// Demo routes (serves demo-oauth.html and handles callbacks)
+app.route("/demo", oauthDemoRoutes);
 if (isSearchEnabled()) {
     initializeSearchService().catch(console.error);
     app.route("/api/v1/search", searchRoutes);

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

@@ -6,6 +6,8 @@ export interface ToolExecuteRequest {
     inputData: Record<string, unknown>;
     envs?: Record<string, string>;
     sandboxProvider?: MCPSandboxProvider;
+    /** OAuth access token for MCP servers that require OAuth authentication */
+    accessToken?: string;
 }
 /**
  * Tool Executor Interface
@@ -13,5 +15,5 @@ export interface ToolExecuteRequest {
  */
 export interface ToolExecutor {
     executeTool(request: ToolExecuteRequest): Promise<unknown>;
-    listTools(packageName: string, sandboxProvider?: MCPSandboxProvider): Promise<Tool[]>;
+    listTools(packageName: string, accessToken?: string): Promise<Tool[]>;
 }

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

@@ -8,5 +8,5 @@ export declare class LocalExecutor implements ToolExecutor {
     private readonly packageRepository;
     constructor();
     executeTool(request: ToolExecuteRequest): Promise<unknown>;
-    listTools(packageName: string): Promise<Tool[]>;
+    listTools(packageName: string, accessToken?: string): Promise<Tool[]>;
 }

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

@@ -14,7 +14,7 @@ export class LocalExecutor {
     }
     async executeTool(request) {
         const mcpServerConfig = this.packageRepository.getPackageConfig(request.packageName);
-        const { client, closeConnection } = await getMcpClient(mcpServerConfig, request.envs || {});
+        const { client, closeConnection } = await getMcpClient(mcpServerConfig, request.envs || {}, request.accessToken);
         try {
             const result = await client.callTool({
                 name: request.toolKey,
@@ -27,7 +27,7 @@ export class LocalExecutor {
             await closeConnection();
         }
     }
-    async listTools(packageName) {
+    async listTools(packageName, accessToken) {
         const mcpServerConfig = this.packageRepository.getPackageConfig(packageName);
         const mockEnvs = {};
         if (mcpServerConfig.env) {
@@ -35,7 +35,7 @@ export class LocalExecutor {
                 mockEnvs[key] = "mock_value";
             });
         }
-        const { client, closeConnection } = await getMcpClient(mcpServerConfig, mockEnvs);
+        const { client, closeConnection } = await getMcpClient(mcpServerConfig, mockEnvs, accessToken);
         try {
             const { tools } = await client.listTools();
             console.log(`[LocalExecutor] Tools list retrieved successfully for package ${packageName}`);

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

@@ -12,5 +12,5 @@ export declare class SandboxExecutor implements ToolExecutor {
     private readonly localExecutor;
     constructor(provider: MCPSandboxProvider);
     executeTool(request: ToolExecuteRequest): Promise<unknown>;
-    listTools(packageName: string): Promise<Tool[]>;
+    listTools(packageName: string, accessToken?: string): Promise<Tool[]>;
 }

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

@@ -48,13 +48,13 @@ export class SandboxExecutor {
             await this.sandboxPool.release(runtime, this.provider);
         }
     }
-    async listTools(packageName) {
+    async listTools(packageName, accessToken) {
         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);
+            return await this.localExecutor.listTools(packageName, accessToken);
         }
         const sandboxClient = await this.sandboxPool.acquire(runtime, this.provider);
         try {
@@ -67,7 +67,7 @@ export class SandboxExecutor {
             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);
+                const tools = await this.localExecutor.listTools(packageName, accessToken);
                 console.log(`[SandboxExecutor] Tools list retrieved successfully with LOCAL fallback`);
                 return tools;
             }

package/dist/domains/oauth/__tests__/oauth-session.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/domains/oauth/__tests__/oauth-session.test.js

@@ -0,0 +1,272 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { OAuthSessionStore } from "../oauth-session";
+// Create a new instance for testing (not the singleton)
+function createTestStore() {
+    const store = new OAuthSessionStore();
+    // Stop the cleanup timer to avoid interference with tests
+    store.stopCleanup();
+    return store;
+}
+function createMockSession(overrides = {}) {
+    return Object.assign({ sessionId: "test-session-id", state: "test-state", codeVerifier: "test-code-verifier", codeChallenge: "test-code-challenge", clientInfo: {
+            client_id: "test-client-id",
+        }, callbackBaseUrl: "http://localhost:3003/callback", mcpServerUrl: "http://localhost:3001/mcp", packageName: "github-mcp", oauthMetadata: {
+            issuer: "http://localhost:3001",
+            authorization_endpoint: "http://localhost:3001/authorize",
+            token_endpoint: "http://localhost:3001/token",
+        }, createdAt: Date.now() }, overrides);
+}
+describe("OAuthSessionStore", () => {
+    let store;
+    beforeEach(() => {
+        store = createTestStore();
+    });
+    afterEach(() => {
+        store.stopCleanup();
+        store.clear();
+    });
+    describe("set", () => {
+        it("should store a session", () => {
+            // Arrange
+            const session = createMockSession();
+            // Act
+            store.set(session);
+            // Assert
+            expect(store.has(session.sessionId)).toBe(true);
+            expect(store.size()).toBe(1);
+        });
+        it("should allow retrieval by sessionId after set", () => {
+            // Arrange
+            const session = createMockSession();
+            // Act
+            store.set(session);
+            const retrieved = store.get(session.sessionId);
+            // Assert
+            expect(retrieved).toEqual(session);
+        });
+        it("should allow retrieval by state after set", () => {
+            // Arrange
+            const session = createMockSession();
+            // Act
+            store.set(session);
+            const retrieved = store.getByState(session.state);
+            // Assert
+            expect(retrieved).toEqual(session);
+        });
+        it("should overwrite session with same sessionId", () => {
+            // Arrange
+            const session1 = createMockSession({ packageName: "package1" });
+            const session2 = createMockSession({ packageName: "package2" });
+            // Act
+            store.set(session1);
+            store.set(session2);
+            // Assert
+            const retrieved = store.get(session1.sessionId);
+            expect(retrieved === null || retrieved === void 0 ? void 0 : retrieved.packageName).toBe("package2");
+            expect(store.size()).toBe(1);
+        });
+    });
+    describe("get", () => {
+        it("should return undefined for non-existent session", () => {
+            // Act
+            const result = store.get("non-existent-id");
+            // Assert
+            expect(result).toBeUndefined();
+        });
+        it("should return session when exists", () => {
+            // Arrange
+            const session = createMockSession();
+            store.set(session);
+            // Act
+            const result = store.get(session.sessionId);
+            // Assert
+            expect(result).toEqual(session);
+        });
+        it("should return undefined for expired session", () => {
+            // Arrange - create session that expired 11 minutes ago
+            const expiredSession = createMockSession({
+                sessionId: "expired-session",
+                createdAt: Date.now() - 11 * 60 * 1000,
+            });
+            store.set(expiredSession);
+            // Act
+            const result = store.get("expired-session");
+            // Assert
+            expect(result).toBeUndefined();
+            expect(store.has("expired-session")).toBe(false);
+        });
+        it("should return session that is still valid (9 minutes old)", () => {
+            // Arrange
+            const validSession = createMockSession({
+                sessionId: "valid-session",
+                createdAt: Date.now() - 9 * 60 * 1000,
+            });
+            store.set(validSession);
+            // Act
+            const result = store.get("valid-session");
+            // Assert
+            expect(result).toBeDefined();
+            expect(result === null || result === void 0 ? void 0 : result.sessionId).toBe("valid-session");
+        });
+    });
+    describe("getByState", () => {
+        it("should return undefined for non-existent state", () => {
+            // Act
+            const result = store.getByState("non-existent-state");
+            // Assert
+            expect(result).toBeUndefined();
+        });
+        it("should return session when state exists", () => {
+            // Arrange
+            const session = createMockSession({ state: "unique-state" });
+            store.set(session);
+            // Act
+            const result = store.getByState("unique-state");
+            // Assert
+            expect(result).toEqual(session);
+        });
+        it("should return undefined for expired session by state", () => {
+            // Arrange
+            const expiredSession = createMockSession({
+                state: "expired-state",
+                createdAt: Date.now() - 11 * 60 * 1000,
+            });
+            store.set(expiredSession);
+            // Act
+            const result = store.getByState("expired-state");
+            // Assert
+            expect(result).toBeUndefined();
+        });
+    });
+    describe("delete", () => {
+        it("should return false for non-existent session", () => {
+            // Act
+            const result = store.delete("non-existent-id");
+            // Assert
+            expect(result).toBe(false);
+        });
+        it("should delete existing session and return true", () => {
+            // Arrange
+            const session = createMockSession();
+            store.set(session);
+            // Act
+            const result = store.delete(session.sessionId);
+            // Assert
+            expect(result).toBe(true);
+            expect(store.has(session.sessionId)).toBe(false);
+            expect(store.size()).toBe(0);
+        });
+        it("should also remove state mapping when session is deleted", () => {
+            // Arrange
+            const session = createMockSession({ state: "state-to-delete" });
+            store.set(session);
+            // Act
+            store.delete(session.sessionId);
+            const byState = store.getByState("state-to-delete");
+            // Assert
+            expect(byState).toBeUndefined();
+        });
+    });
+    describe("has", () => {
+        it("should return false for non-existent session", () => {
+            // Act
+            const result = store.has("non-existent-id");
+            // Assert
+            expect(result).toBe(false);
+        });
+        it("should return true for existing session", () => {
+            // Arrange
+            const session = createMockSession();
+            store.set(session);
+            // Act
+            const result = store.has(session.sessionId);
+            // Assert
+            expect(result).toBe(true);
+        });
+    });
+    describe("size", () => {
+        it("should return 0 for empty store", () => {
+            // Act
+            const result = store.size();
+            // Assert
+            expect(result).toBe(0);
+        });
+        it("should return correct count after adding sessions", () => {
+            // Arrange
+            store.set(createMockSession({ sessionId: "session-1", state: "state-1" }));
+            store.set(createMockSession({ sessionId: "session-2", state: "state-2" }));
+            store.set(createMockSession({ sessionId: "session-3", state: "state-3" }));
+            // Act
+            const result = store.size();
+            // Assert
+            expect(result).toBe(3);
+        });
+        it("should return correct count after deleting sessions", () => {
+            // Arrange
+            store.set(createMockSession({ sessionId: "session-1", state: "state-1" }));
+            store.set(createMockSession({ sessionId: "session-2", state: "state-2" }));
+            store.delete("session-1");
+            // Act
+            const result = store.size();
+            // Assert
+            expect(result).toBe(1);
+        });
+    });
+    describe("clear", () => {
+        it("should remove all sessions", () => {
+            // Arrange
+            store.set(createMockSession({ sessionId: "session-1", state: "state-1" }));
+            store.set(createMockSession({ sessionId: "session-2", state: "state-2" }));
+            // Act
+            store.clear();
+            // Assert
+            expect(store.size()).toBe(0);
+            expect(store.has("session-1")).toBe(false);
+            expect(store.has("session-2")).toBe(false);
+        });
+        it("should also clear state mappings", () => {
+            // Arrange
+            store.set(createMockSession({ sessionId: "session-1", state: "state-1" }));
+            // Act
+            store.clear();
+            const byState = store.getByState("state-1");
+            // Assert
+            expect(byState).toBeUndefined();
+        });
+    });
+    describe("multiple sessions", () => {
+        it("should handle multiple sessions with different states", () => {
+            var _a, _b, _c, _d;
+            // Arrange
+            const session1 = createMockSession({
+                sessionId: "session-1",
+                state: "state-1",
+                packageName: "package-1",
+            });
+            const session2 = createMockSession({
+                sessionId: "session-2",
+                state: "state-2",
+                packageName: "package-2",
+            });
+            // Act
+            store.set(session1);
+            store.set(session2);
+            // Assert
+            expect((_a = store.get("session-1")) === null || _a === void 0 ? void 0 : _a.packageName).toBe("package-1");
+            expect((_b = store.get("session-2")) === null || _b === void 0 ? void 0 : _b.packageName).toBe("package-2");
+            expect((_c = store.getByState("state-1")) === null || _c === void 0 ? void 0 : _c.packageName).toBe("package-1");
+            expect((_d = store.getByState("state-2")) === null || _d === void 0 ? void 0 : _d.packageName).toBe("package-2");
+        });
+        it("should not affect other sessions when deleting one", () => {
+            // Arrange
+            store.set(createMockSession({ sessionId: "session-1", state: "state-1" }));
+            store.set(createMockSession({ sessionId: "session-2", state: "state-2" }));
+            // Act
+            store.delete("session-1");
+            // Assert
+            expect(store.has("session-1")).toBe(false);
+            expect(store.has("session-2")).toBe(true);
+            expect(store.getByState("state-2")).toBeDefined();
+        });
+    });
+});

package/dist/domains/oauth/__tests__/oauth-utils.test.d.ts

@@ -0,0 +1 @@
+export {};