@imenam/mcp-http-gateway 2.0.21 → 2.0.23

package/README.md

@@ -612,6 +612,15 @@ Chaque `POST /mcp` est traité de façon autonome : aucun `mcp-session-id` n'est
 
 `GET /mcp` et `DELETE /mcp` répondent `405 Method Not Allowed` : sans session, il n'y a ni flux SSE autonome ni terminaison de session à gérer (la spec Streamable HTTP l'autorise explicitement).
 
+L'endpoint sert deux générations du protocole, toujours en réponse JSON :
+
+- **2026-07-28** : le client se présente par `server/discover`, sans `initialize` ;
+- **2025-11-25 et antérieures** : poignée de main par `initialize`.
+
+La génération est reconnue requête par requête : un client 2026-07-28 se connecte directement, sans essuyer de refus.
+
+Les requêtes dont l'en-tête `Host` ou `Origin` n'est pas autorisé sont refusées en `403` (protection anti-DNS-rebinding). Sont autorisés les hôtes `localhost`, celui de `MCP_PUBLIC_URL` et ceux de `GATEWAY_ALLOWED_HOSTS`, ainsi que les origines `https://claude.ai` et celles de `GATEWAY_ALLOWED_ORIGINS`. La comparaison porte sur le nom d'hôte seul, sans le port. Une requête sans en-tête `Origin` est acceptée.
+
 ### Flow
 
 ```
@@ -635,6 +644,8 @@ Le gateway agit uniquement comme **Resource Server** : il valide les JWT via JWK
 | `MCP_PUBLIC_URL` | URL publique canonique du endpoint — ex. `https://gateway.example.com/mcp`. Utilisée comme `resource` (RFC 9728) et `aud` JWT. |
 | `OAUTH_JWKS_URI` | URI du JWKS de l'Authorization Server — ex. `https://your-auth-server/.well-known/jwks.json` |
 | `OAUTH_ISSUER` | Issuer attendu dans les JWT — ex. `https://your-auth-server` |
+| `GATEWAY_ALLOWED_HOSTS` | Hôtes supplémentaires admis sur `/mcp`, séparés par des virgules — ex. `mon-autre-host.example.com` |
+| `GATEWAY_ALLOWED_ORIGINS` | Origines supplémentaires admises sur `/mcp`, séparées par des virgules — ex. `https://mon-client.example.com` |
 
 > Sans `MCP_OAUTH_ENABLED=true`, `/mcp` est ouvert (utile pour les tests locaux). Claude.ai refusera cependant de s'y connecter sans 401 + `WWW-Authenticate`.
 

package/auth.js

@@ -1,5 +1,5 @@
 import { createRemoteJWKSet, jwtVerify } from 'jose';
-import { InvalidTokenError } from '@modelcontextprotocol/sdk/server/auth/errors.js';
+import { OAuthError, OAuthErrorCode } from '@modelcontextprotocol/server';
 
 const OAUTH_ENABLED = process.env.MCP_OAUTH_ENABLED === 'true';
 
@@ -22,7 +22,8 @@ export function createMcpTokenVerifier() {
       } catch (err) {
         const ts = new Date().toISOString();
         console.error(`[auth] ${ts} jwtVerify FAILED:`, err.code ?? err.constructor.name, err.message);
-        throw new InvalidTokenError(
+        throw new OAuthError(
+          OAuthErrorCode.InvalidToken,
           err.code === 'ERR_JWT_EXPIRED' ? 'Token has expired' : 'Invalid token'
         );
       }

package/mcp-endpoint.js

@@ -1,9 +1,6 @@
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import {
-  ListToolsRequestSchema,
-  CallToolRequestSchema,
-} from '@modelcontextprotocol/sdk/types.js';
+import { Server, createMcpHandler, isLegacyRequest } from '@modelcontextprotocol/server';
+import { NodeStreamableHTTPServerTransport, toNodeHandler, toWebRequest } from '@modelcontextprotocol/node';
+import { hostHeaderValidation, originValidation } from '@modelcontextprotocol/express';
 import { getProtectedResourceMetadata } from './auth.js';
 import { toolDefinition } from './startup-exposition.js';
 import { allowsMcp, allowsTool, filterTools } from './scope.js';
@@ -61,9 +58,9 @@ function buildMcpServer(registry, scope) {
     return entry && allowsMcp(scope, entry.name) ? entry : null;
   };
 
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: allTools }));
+  server.setRequestHandler('tools/list', async () => ({ tools: allTools }));
 
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  server.setRequestHandler('tools/call', async (request) => {
     const { name, arguments: args = {} } = request.params;
 
     try {
@@ -117,24 +114,29 @@ function buildMcpServer(registry, scope) {
   return server;
 }
 
+/** Nom d'hôte, sans port, d'un hôte (`exemple.com:8443`) ou d'une origine (`https://exemple.com`). */
+function hostnameOf(value) {
+  try {
+    return new URL(value.includes('://') ? value : `http://${value}`).hostname;
+  } catch {
+    return null;
+  }
+}
+
+const envList = (name) => (process.env[name] ?? '').split(',').map(s => s.trim()).filter(Boolean);
+
+/**
+ * Noms d'hôte acceptés pour la protection DNS rebinding : la vérification du SDK ignore le port.
+ */
 function buildDnsRebindingConfig() {
-  const port = process.env.GATEWAY_PORT ?? '3500';
-  const extraHosts = process.env.GATEWAY_ALLOWED_HOSTS
-    ? process.env.GATEWAY_ALLOWED_HOSTS.split(',').map(s => s.trim()).filter(Boolean)
-    : [];
-  const publicHost = process.env.MCP_PUBLIC_URL
-    ? (() => { try { return new URL(process.env.MCP_PUBLIC_URL).host; } catch { return null; } })()
-    : null;
   const allowedHosts = [
-    `localhost:${port}`,
-    ...(publicHost ? [publicHost] : []),
-    ...extraHosts,
-  ];
+    'localhost',
+    ...(process.env.MCP_PUBLIC_URL ? [process.env.MCP_PUBLIC_URL] : []),
+    ...envList('GATEWAY_ALLOWED_HOSTS'),
+  ].map(hostnameOf).filter(Boolean);
 
-  const extraOrigins = process.env.GATEWAY_ALLOWED_ORIGINS
-    ? process.env.GATEWAY_ALLOWED_ORIGINS.split(',').map(s => s.trim()).filter(Boolean)
-    : [];
-  const allowedOrigins = ['https://claude.ai', ...extraOrigins];
+  const allowedOrigins = ['https://claude.ai', ...envList('GATEWAY_ALLOWED_ORIGINS')]
+    .map(hostnameOf).filter(Boolean);
 
   return { allowedHosts, allowedOrigins };
 }
@@ -148,31 +150,40 @@ export function registerMcpEndpoint(app, registry) {
   console.log('[gateway] DNS rebinding protection — allowedHosts:', allowedHosts);
   console.log('[gateway] DNS rebinding protection — allowedOrigins:', allowedOrigins);
 
-  // Mode stateless : un Server + un transport éphémères par requête, aucun état inter-requêtes.
+  const logError = (err) => console.error('[mcp-endpoint] handleMcpRequest error:', err);
+
+  // Mode stateless : un Server éphémère par requête, aucun état inter-requêtes.
   // Les trois outils exposés sont du pur requête/réponse (aucune notification serveur→client,
   // ni sampling, ni subscription), donc aucune session n'est nécessaire.
-  // Conséquence : plus de 404 "session inconnue" après une période d'inactivité ou un redémarrage,
+  // Conséquence : pas de 404 "session inconnue" après une période d'inactivité ou un redémarrage,
   // et l'endpoint supporte le scale-out multi-instances.
-  app.post('/mcp', async (req, res) => {
-    const server = buildMcpServer(registry, req.scope);
-    const transport = new StreamableHTTPServerTransport({
-      sessionIdGenerator: undefined,
-      enableJsonResponse: true,
-      enableDnsRebindingProtection: true,
-      allowedHosts,
-      allowedOrigins,
-    });
-
-    res.on('close', () => {
-      transport.close().catch(() => {});
-      server.close().catch(() => {});
-    });
+  // Deux générations du protocole sur le même endpoint, toutes deux en réponse JSON :
+  // - révisions 2025 (qui commencent par `initialize`) : transport Streamable HTTP sans session ;
+  // - révision 2026-07-28 (dont `server/discover`) : handler par requête du SDK.
+  app.post('/mcp', hostHeaderValidation(allowedHosts), originValidation(allowedOrigins), async (req, res) => {
+    const factory = () => buildMcpServer(registry, req.scope);
 
     try {
-      await server.connect(transport);
-      await transport.handleRequest(req, res, req.body);
+      if (await isLegacyRequest(await toWebRequest(req, req.body), req.body)) {
+        const server = factory();
+        const transport = new NodeStreamableHTTPServerTransport({
+          sessionIdGenerator: undefined,
+          enableJsonResponse: true,
+        });
+        res.on('close', () => {
+          transport.close().catch(() => {});
+          server.close().catch(() => {});
+        });
+        await server.connect(transport);
+        await transport.handleRequest(req, res, req.body);
+        return;
+      }
+
+      const handler = createMcpHandler(factory, { legacy: 'reject', responseMode: 'json', onerror: logError });
+      res.on('close', () => { handler.close().catch(() => {}); });
+      await toNodeHandler(handler, { onerror: logError })(req, res, req.body);
     } catch (err) {
-      console.error('[mcp-endpoint] handleMcpRequest error:', err);
+      logError(err);
       if (!res.headersSent) {
         res.status(500).json({
           jsonrpc: '2.0',

package/mcp-mode.js

@@ -2,12 +2,8 @@
 import 'dotenv/config';
 import fs from 'fs';
 import path from 'path';
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import {
-  ListToolsRequestSchema,
-  CallToolRequestSchema,
-} from '@modelcontextprotocol/sdk/types.js';
+import { Server } from '@modelcontextprotocol/server';
+import { StdioServerTransport } from '@modelcontextprotocol/server/stdio';
 import {
   EXEC_ARG, MAX_EXEC_ROUNDS, parseExecRoutes, normalizeRoute, execAnnouncement, execRequestOf, runExecRequest,
 } from './gateway-exec.js';
@@ -705,9 +701,9 @@ if (initialProxyTools.length) {
   console.error(`[mcp-mode] ${initialProxyTools.length} proxy tool(s) exposed directly from gateway`);
 }
 
-server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: allTools }));
+server.setRequestHandler('tools/list', async () => ({ tools: allTools }));
 
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
+server.setRequestHandler('tools/call', async (request) => {
   const { name, arguments: args = {} } = request.params;
 
   try {

package/mcp-registry.js

@@ -1,7 +1,7 @@
 import crypto from 'crypto';
 import readline from 'readline';
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { Client } from '@modelcontextprotocol/client';
+import { StdioClientTransport } from '@modelcontextprotocol/client/stdio';
 import { buildProxyTools, overlongProxyNames, parseExposeFlag } from './startup-exposition.js';
 import { HTTP_RELAY_PORT_KEY, parseRelayPort, relayPrefix } from './http-relay.js';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@imenam/mcp-http-gateway",
-  "version": "2.0.21",
+  "version": "2.0.23",
   "type": "module",
   "description": "HTTP gateway that exposes MCP servers as REST routes — bridge between MCP and any HTTP-capable agent",
   "main": "server.js",
@@ -46,13 +46,17 @@
   "homepage": "https://github.com/Matthieu-Pesnot-Pin/mcp-http-gateway#readme",
   "license": "ISC",
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.27.1",
+    "@modelcontextprotocol/client": "^2.4.0",
+    "@modelcontextprotocol/express": "^2.0.2",
+    "@modelcontextprotocol/node": "^2.1.2",
+    "@modelcontextprotocol/server": "^2.4.0",
     "better-sqlite3": "^12.8.0",
     "dotenv": "^17.3.1",
     "express": "^5.2.1",
+    "express-rate-limit": "^8.7.1",
     "jose": "^6.2.3",
     "openai": "^6.31.0"
   }

package/server.js

@@ -26,7 +26,7 @@ import { McpRegistry, REVISION_HEADER } from './mcp-registry.js';
 import {
   FULL_SCOPE, SCOPE_HEADER, allowsMcp, allowsTool, filterTools, readScope, scopedRevision,
 } from './scope.js';
-import { requireBearerAuth } from '@modelcontextprotocol/sdk/server/auth/middleware/bearerAuth.js';
+import { requireBearerAuth } from '@modelcontextprotocol/express';
 import { rateLimit } from 'express-rate-limit';
 
 // Normalise les différents formats de config rencontrés dans la nature :