@toolsdk.ai/registry 1.0.132 → 1.0.133

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 {};

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

@@ -0,0 +1,284 @@
+import { describe, expect, it } from "vitest";
+import { buildAuthorizationUrl, generatePKCE, generateSessionId, generateState, getCanonicalResourceUri, parseWWWAuthenticate, verifyPKCESupport, } from "../oauth-utils";
+describe("oauth-utils", () => {
+    describe("generatePKCE", () => {
+        it("should generate valid PKCE parameters", () => {
+            // Act
+            const pkce = generatePKCE();
+            // Assert
+            expect(pkce).toHaveProperty("codeVerifier");
+            expect(pkce).toHaveProperty("codeChallenge");
+            expect(pkce).toHaveProperty("codeChallengeMethod");
+            expect(pkce.codeChallengeMethod).toBe("S256");
+        });
+        it("should generate code verifier with correct length (43 chars base64url)", () => {
+            // Act
+            const pkce = generatePKCE();
+            // Assert - 32 bytes base64url encoded = 43 characters
+            expect(pkce.codeVerifier.length).toBe(43);
+        });
+        it("should generate code challenge with correct length", () => {
+            // Act
+            const pkce = generatePKCE();
+            // Assert - SHA256 hash (32 bytes) base64url encoded = 43 characters
+            expect(pkce.codeChallenge.length).toBe(43);
+        });
+        it("should generate different values each time", () => {
+            // Act
+            const pkce1 = generatePKCE();
+            const pkce2 = generatePKCE();
+            // Assert
+            expect(pkce1.codeVerifier).not.toBe(pkce2.codeVerifier);
+            expect(pkce1.codeChallenge).not.toBe(pkce2.codeChallenge);
+        });
+        it("should generate base64url encoded values (no +, /, =)", () => {
+            // Act
+            const pkce = generatePKCE();
+            // Assert - base64url should not contain +, /, or =
+            expect(pkce.codeVerifier).not.toMatch(/[+/=]/);
+            expect(pkce.codeChallenge).not.toMatch(/[+/=]/);
+        });
+    });
+    describe("generateState", () => {
+        it("should generate a valid UUID", () => {
+            // Act
+            const state = generateState();
+            // Assert - UUID format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+            expect(state).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i);
+        });
+        it("should generate different values each time", () => {
+            // Act
+            const state1 = generateState();
+            const state2 = generateState();
+            // Assert
+            expect(state1).not.toBe(state2);
+        });
+    });
+    describe("generateSessionId", () => {
+        it("should generate a valid UUID", () => {
+            // Act
+            const sessionId = generateSessionId();
+            // Assert
+            expect(sessionId).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i);
+        });
+        it("should generate different values each time", () => {
+            // Act
+            const id1 = generateSessionId();
+            const id2 = generateSessionId();
+            // Assert
+            expect(id1).not.toBe(id2);
+        });
+    });
+    describe("parseWWWAuthenticate", () => {
+        it("should parse complete WWW-Authenticate header", () => {
+            // Arrange
+            const header = 'Bearer realm="mcp", resource_metadata="http://localhost:3001/.well-known/oauth-protected-resource", scope="read write"';
+            // Act
+            const result = parseWWWAuthenticate(header);
+            // Assert
+            expect(result).toEqual({
+                realm: "mcp",
+                resourceMetadataUrl: "http://localhost:3001/.well-known/oauth-protected-resource",
+                scope: "read write",
+            });
+        });
+        it("should parse header with only realm", () => {
+            // Arrange
+            const header = 'Bearer realm="example"';
+            // Act
+            const result = parseWWWAuthenticate(header);
+            // Assert
+            expect(result).toEqual({
+                realm: "example",
+            });
+        });
+        it("should parse header with only resource_metadata", () => {
+            // Arrange
+            const header = 'Bearer resource_metadata="http://example.com/.well-known/oauth-protected-resource"';
+            // Act
+            const result = parseWWWAuthenticate(header);
+            // Assert
+            expect(result).toEqual({
+                resourceMetadataUrl: "http://example.com/.well-known/oauth-protected-resource",
+            });
+        });
+        it("should return empty object for empty header", () => {
+            // Arrange
+            const header = "Bearer";
+            // Act
+            const result = parseWWWAuthenticate(header);
+            // Assert
+            expect(result).toEqual({});
+        });
+    });
+    describe("verifyPKCESupport", () => {
+        it("should return supported=true when S256 is in supported methods", () => {
+            // Arrange
+            const metadata = {
+                issuer: "http://localhost:3001",
+                authorization_endpoint: "http://localhost:3001/authorize",
+                token_endpoint: "http://localhost:3001/token",
+                code_challenge_methods_supported: ["S256", "plain"],
+            };
+            // Act
+            const result = verifyPKCESupport(metadata);
+            // Assert
+            expect(result).toEqual({ supported: true, advertised: true });
+        });
+        it("should return supported=false when S256 is not in supported methods", () => {
+            // Arrange
+            const metadata = {
+                issuer: "http://localhost:3001",
+                authorization_endpoint: "http://localhost:3001/authorize",
+                token_endpoint: "http://localhost:3001/token",
+                code_challenge_methods_supported: ["plain"],
+            };
+            // Act
+            const result = verifyPKCESupport(metadata);
+            // Assert
+            expect(result).toEqual({ supported: false, advertised: true });
+        });
+        it("should return supported=true, advertised=false when code_challenge_methods_supported is missing", () => {
+            // Arrange
+            const metadata = {
+                issuer: "http://localhost:3001",
+                authorization_endpoint: "http://localhost:3001/authorize",
+                token_endpoint: "http://localhost:3001/token",
+            };
+            // Act
+            const result = verifyPKCESupport(metadata);
+            // Assert
+            expect(result).toEqual({ supported: true, advertised: false });
+        });
+        it("should return supported=true, advertised=false when code_challenge_methods_supported is empty", () => {
+            // Arrange
+            const metadata = {
+                issuer: "http://localhost:3001",
+                authorization_endpoint: "http://localhost:3001/authorize",
+                token_endpoint: "http://localhost:3001/token",
+                code_challenge_methods_supported: [],
+            };
+            // Act
+            const result = verifyPKCESupport(metadata);
+            // Assert
+            expect(result).toEqual({ supported: true, advertised: false });
+        });
+    });
+    describe("buildAuthorizationUrl", () => {
+        it("should build URL with all required parameters", () => {
+            // Arrange
+            const params = {
+                authorizationEndpoint: "http://localhost:3001/authorize",
+                clientId: "test-client",
+                redirectUri: "http://localhost:3003/callback",
+                state: "random-state",
+                codeChallenge: "test-challenge",
+                codeChallengeMethod: "S256",
+            };
+            // Act
+            const result = buildAuthorizationUrl(params);
+            // Assert
+            const url = new URL(result);
+            expect(url.origin).toBe("http://localhost:3001");
+            expect(url.pathname).toBe("/authorize");
+            expect(url.searchParams.get("response_type")).toBe("code");
+            expect(url.searchParams.get("client_id")).toBe("test-client");
+            expect(url.searchParams.get("redirect_uri")).toBe("http://localhost:3003/callback");
+            expect(url.searchParams.get("state")).toBe("random-state");
+            expect(url.searchParams.get("code_challenge")).toBe("test-challenge");
+            expect(url.searchParams.get("code_challenge_method")).toBe("S256");
+        });
+        it("should include scope when provided", () => {
+            // Arrange
+            const params = {
+                authorizationEndpoint: "http://localhost:3001/authorize",
+                clientId: "test-client",
+                redirectUri: "http://localhost:3003/callback",
+                state: "random-state",
+                codeChallenge: "test-challenge",
+                codeChallengeMethod: "S256",
+                scope: "read write",
+            };
+            // Act
+            const result = buildAuthorizationUrl(params);
+            // Assert
+            const url = new URL(result);
+            expect(url.searchParams.get("scope")).toBe("read write");
+        });
+        it("should include resource when provided", () => {
+            // Arrange
+            const params = {
+                authorizationEndpoint: "http://localhost:3001/authorize",
+                clientId: "test-client",
+                redirectUri: "http://localhost:3003/callback",
+                state: "random-state",
+                codeChallenge: "test-challenge",
+                codeChallengeMethod: "S256",
+                resource: "http://localhost:3001/mcp",
+            };
+            // Act
+            const result = buildAuthorizationUrl(params);
+            // Assert
+            const url = new URL(result);
+            expect(url.searchParams.get("resource")).toBe("http://localhost:3001/mcp");
+        });
+        it("should not include scope when not provided", () => {
+            // Arrange
+            const params = {
+                authorizationEndpoint: "http://localhost:3001/authorize",
+                clientId: "test-client",
+                redirectUri: "http://localhost:3003/callback",
+                state: "random-state",
+                codeChallenge: "test-challenge",
+                codeChallengeMethod: "S256",
+            };
+            // Act
+            const result = buildAuthorizationUrl(params);
+            // Assert
+            const url = new URL(result);
+            expect(url.searchParams.has("scope")).toBe(false);
+        });
+    });
+    describe("getCanonicalResourceUri", () => {
+        it("should return URL without trailing slash", () => {
+            // Arrange
+            const mcpServerUrl = "http://localhost:3001/mcp/";
+            // Act
+            const result = getCanonicalResourceUri(mcpServerUrl);
+            // Assert
+            expect(result).toBe("http://localhost:3001/mcp");
+        });
+        it("should keep URL without trailing slash unchanged", () => {
+            // Arrange
+            const mcpServerUrl = "http://localhost:3001/mcp";
+            // Act
+            const result = getCanonicalResourceUri(mcpServerUrl);
+            // Assert
+            expect(result).toBe("http://localhost:3001/mcp");
+        });
+        it("should handle root URL correctly", () => {
+            // Arrange
+            const mcpServerUrl = "http://localhost:3001/";
+            // Act
+            const result = getCanonicalResourceUri(mcpServerUrl);
+            // Assert
+            expect(result).toBe("http://localhost:3001/");
+        });
+        it("should strip query parameters", () => {
+            // Arrange
+            const mcpServerUrl = "http://localhost:3001/mcp?param=value";
+            // Act
+            const result = getCanonicalResourceUri(mcpServerUrl);
+            // Assert
+            expect(result).toBe("http://localhost:3001/mcp");
+        });
+        it("should strip fragment", () => {
+            // Arrange
+            const mcpServerUrl = "http://localhost:3001/mcp#section";
+            // Act
+            const result = getCanonicalResourceUri(mcpServerUrl);
+            // Assert
+            expect(result).toBe("http://localhost:3001/mcp");
+        });
+    });
+});