@imenam/mcp-http-gateway 2.0.22 → 2.0.24

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`.
 
@@ -754,3 +765,9 @@ points d'entrée par lesquels un agent atteint le gateway :
 2. Appeler `POST /admin/reload` (voir [Rechargement à chaud](#rechargement-à-chaud)), ou redémarrer le gateway
 
 Aucune modification du MCP n'est nécessaire.
+
+## Publication
+
+Chaque push sur `master`, merge de pull request compris, publie une nouvelle version de `@imenam/mcp-http-gateway` sur npm (`.github/workflows/publish.yml`) : `npm ci`, puis `npm version patch`, dont le commit et le tag sont poussés sur `master`, et `npm publish`. La publication passe par le trusted publishing de npm (OIDC, sans token), avec attestation de provenance.
+
+Sur npmjs.com, le paquet déclare ce workflow comme publieur de confiance (Settings → Trusted publishing → GitHub Actions : `Matthieu-Pesnot-Pin`, `mcp-http-gateway`, `publish.yml`, avec `npm publish` dans les actions autorisées). Le commit de version est poussé avec `GITHUB_TOKEN` : si `master` est protégée, la règle doit autoriser GitHub Actions à y pousser.

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/embeddings/db.js

@@ -1,58 +1,58 @@
-import crypto from 'crypto';
-import fs from 'fs';
-import path from 'path';
-import Database from 'better-sqlite3';
-
-let database;
-
-export function initDb(dbPath) {
-  fs.mkdirSync(path.dirname(dbPath), { recursive: true });
-  database = new Database(dbPath);
-  database.pragma('journal_mode = WAL');
-  database.exec(`
-    CREATE TABLE IF NOT EXISTS tool_embeddings (
-      cache_key   TEXT PRIMARY KEY,
-      desc_hash   TEXT NOT NULL,
-      mcp_name    TEXT NOT NULL,
-      tool_name   TEXT NOT NULL,
-      description TEXT NOT NULL,
-      embedding   BLOB NOT NULL
-    );
-  `);
-}
-
-export async function getOrComputeToolEmbedding(mcpName, tool, getEmbeddingFn) {
-  const cacheKey = `${mcpName}::${tool.name}`;
-  const descHash = crypto.createHash('md5').update(tool.description).digest('hex');
-
-  const existing = database
-    .prepare('SELECT desc_hash FROM tool_embeddings WHERE cache_key = ?')
-    .get(cacheKey);
-
-  if (existing?.desc_hash === descHash) return;
-
-  const embedding = await getEmbeddingFn(tool.description);
-  database.prepare(`
-    INSERT INTO tool_embeddings (cache_key, desc_hash, mcp_name, tool_name, description, embedding)
-    VALUES (?, ?, ?, ?, ?, ?)
-    ON CONFLICT(cache_key) DO UPDATE SET
-      desc_hash = excluded.desc_hash,
-      description = excluded.description,
-      embedding = excluded.embedding
-  `).run(
-    cacheKey, descHash, mcpName, tool.name, tool.description,
-    Buffer.from(new Float32Array(embedding).buffer),
-  );
-}
-
-export function getAllToolEmbeddings() {
-  return database
-    .prepare('SELECT mcp_name, tool_name, description, embedding FROM tool_embeddings')
-    .all()
-    .map(row => ({
-      mcp_name: row.mcp_name,
-      tool_name: row.tool_name,
-      description: row.description,
-      embedding: Array.from(new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.embedding.byteLength / 4)),
-    }));
-}
+import crypto from 'crypto';
+import fs from 'fs';
+import path from 'path';
+import Database from 'better-sqlite3';
+
+let database;
+
+export function initDb(dbPath) {
+  fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+  database = new Database(dbPath);
+  database.pragma('journal_mode = WAL');
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS tool_embeddings (
+      cache_key   TEXT PRIMARY KEY,
+      desc_hash   TEXT NOT NULL,
+      mcp_name    TEXT NOT NULL,
+      tool_name   TEXT NOT NULL,
+      description TEXT NOT NULL,
+      embedding   BLOB NOT NULL
+    );
+  `);
+}
+
+export async function getOrComputeToolEmbedding(mcpName, tool, getEmbeddingFn) {
+  const cacheKey = `${mcpName}::${tool.name}`;
+  const descHash = crypto.createHash('md5').update(tool.description).digest('hex');
+
+  const existing = database
+    .prepare('SELECT desc_hash FROM tool_embeddings WHERE cache_key = ?')
+    .get(cacheKey);
+
+  if (existing?.desc_hash === descHash) return;
+
+  const embedding = await getEmbeddingFn(tool.description);
+  database.prepare(`
+    INSERT INTO tool_embeddings (cache_key, desc_hash, mcp_name, tool_name, description, embedding)
+    VALUES (?, ?, ?, ?, ?, ?)
+    ON CONFLICT(cache_key) DO UPDATE SET
+      desc_hash = excluded.desc_hash,
+      description = excluded.description,
+      embedding = excluded.embedding
+  `).run(
+    cacheKey, descHash, mcpName, tool.name, tool.description,
+    Buffer.from(new Float32Array(embedding).buffer),
+  );
+}
+
+export function getAllToolEmbeddings() {
+  return database
+    .prepare('SELECT mcp_name, tool_name, description, embedding FROM tool_embeddings')
+    .all()
+    .map(row => ({
+      mcp_name: row.mcp_name,
+      tool_name: row.tool_name,
+      description: row.description,
+      embedding: Array.from(new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.embedding.byteLength / 4)),
+    }));
+}

package/embeddings/vectorizer.js

@@ -1,25 +1,25 @@
-import OpenAI from 'openai';
-
-let openaiClient;
-
-function getClient() {
-  if (!openaiClient) openaiClient = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
-  return openaiClient;
-}
-
-export async function getEmbedding(text) {
-  const model = process.env.OPENAI_EMBEDDING_MODEL ?? 'text-embedding-3-small';
-  const response = await getClient().embeddings.create({ model, input: text });
-  return response.data[0].embedding;
-}
-
-export function cosineSimilarity(vecA, vecB) {
-  let dot = 0, normA = 0, normB = 0;
-  for (let i = 0; i < vecA.length; i++) {
-    dot += vecA[i] * vecB[i];
-    normA += vecA[i] ** 2;
-    normB += vecB[i] ** 2;
-  }
-  const mag = Math.sqrt(normA) * Math.sqrt(normB);
-  return mag === 0 ? 0 : dot / mag;
-}
+import OpenAI from 'openai';
+
+let openaiClient;
+
+function getClient() {
+  if (!openaiClient) openaiClient = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+  return openaiClient;
+}
+
+export async function getEmbedding(text) {
+  const model = process.env.OPENAI_EMBEDDING_MODEL ?? 'text-embedding-3-small';
+  const response = await getClient().embeddings.create({ model, input: text });
+  return response.data[0].embedding;
+}
+
+export function cosineSimilarity(vecA, vecB) {
+  let dot = 0, normA = 0, normB = 0;
+  for (let i = 0; i < vecA.length; i++) {
+    dot += vecA[i] * vecB[i];
+    normA += vecA[i] ** 2;
+    normB += vecB[i] ** 2;
+  }
+  const mag = Math.sqrt(normA) * Math.sqrt(normB);
+  return mag === 0 ? 0 : dot / mag;
+}

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,250 +1,250 @@
-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 { buildProxyTools, overlongProxyNames, parseExposeFlag } from './startup-exposition.js';
-import { HTTP_RELAY_PORT_KEY, parseRelayPort, relayPrefix } from './http-relay.js';
-
-// --- Registre des MCP hébergés par le gateway ---
-//
-// Le registre est la seule source de vérité sur les MCP en service : les routes REST, le
-// relais HTTP, l'endpoint /mcp et la pré-exposition le consultent à chaque requête.
-//
-// `apply(servers)` aligne le registre sur une configuration `mcpServers` :
-//   - MCP absent de la configuration      → son processus est arrêté ;
-//   - MCP nouveau, ou pas en service      → il est lancé ;
-//   - command, args ou env modifiés       → seul ce MCP est relancé ;
-//   - description ou EXPOSE_AT_AGENT_STARTUP seuls modifiés → mis à jour sans relance.
-// Les autres MCP ne sont pas touchés.
-//
-// Chaque changement effectif incrémente la révision, que le gateway renvoie dans l'en-tête
-// `X-Gateway-Revision` : le relais stdio (mcp-mode.js) s'en sert pour rafraîchir ses outils.
-
-export const REVISION_HEADER = 'X-Gateway-Revision';
-
-// Variables système minimales transmises aux MCPs enfants.
-// On exclut délibérément toutes les variables propres au gateway
-// (OPENAI_API_KEY, OAUTH_*, GATEWAY_*, MCP_*, etc.).
-const CHILD_ENV_WHITELIST = new Set([
-  'PATH', 'HOME', 'USER', 'LOGNAME', 'SHELL',
-  'LANG', 'LC_ALL', 'LC_CTYPE',
-  'TEMP', 'TMP', 'TMPDIR',
-  'USERPROFILE', 'APPDATA', 'LOCALAPPDATA',
-  'SYSTEMROOT', 'SYSTEMDRIVE', 'WINDIR',
-  'COMSPEC', 'PATHEXT', 'USERNAME',
-  'PROGRAMFILES', 'NODE_PATH',
-]);
-
-// Directives lues par le gateway seul : les modifier ne justifie pas de relancer le MCP.
-const GATEWAY_ONLY_KEYS = new Set(['EXPOSE_AT_AGENT_STARTUP']);
-
-function buildChildEnv(cfgEnv = {}) {
-  const safeEnv = Object.fromEntries(
-    Object.entries(process.env).filter(([k]) => CHILD_ENV_WHITELIST.has(k))
-  );
-  return { ...safeEnv, ...cfgEnv };
-}
-
-/** Préfixe des lignes de stderr d'un MCP : `[mcp "<nom>"] `, le nom en chaîne JSON. */
-export function stderrPrefix(name) {
-  return `[mcp ${JSON.stringify(name)}] `;
-}
-
-/** Recopie le stderr d'un MCP sur celui du gateway, ligne par ligne, chacune préfixée par le nom du MCP. */
-function relayStderr(name, stream) {
-  const prefix = stderrPrefix(name);
-  readline.createInterface({ input: stream, crlfDelay: Infinity }).on('line', (line) => {
-    process.stderr.write(`${prefix}${line}\n`);
-  });
-}
-
-async function connectMcp(name, cfg) {
-  const transport = new StdioClientTransport({
-    command: cfg.command,
-    args: cfg.args ?? [],
-    env: buildChildEnv(cfg.env),
-    stderr: 'pipe',
-  });
-  relayStderr(name, transport.stderr);
-  const client = new Client({ name: 'mcp-gateway', version: '1.0.0' }, { capabilities: {} });
-  await client.connect(transport);
-  console.log(`[gateway] Connected: ${name} → ${cfg.env?.MCP_SERVER_ROUTE}`);
-  return client;
-}
-
-/** Empreinte de ce qui définit le processus enfant : la changer impose de le relancer. */
-function processKey(cfg) {
-  const env = Object.entries(cfg.env ?? {})
-    .filter(([key]) => !GATEWAY_ONLY_KEYS.has(key))
-    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
-  return JSON.stringify([cfg.command, cfg.args ?? [], env]);
-}
-
-/**
- * Lit les directives gateway d'un MCP. Lève une erreur si le MCP ne peut pas être servi.
- */
-function readDirectives(name, cfg) {
-  const route = cfg.env?.MCP_SERVER_ROUTE;
-  if (!route) throw new Error('no MCP_SERVER_ROUTE defined');
-
-  const rawExpose = cfg.env?.EXPOSE_AT_AGENT_STARTUP;
-  const { value: exposeAtStartup, valid } = parseExposeFlag(rawExpose);
-  if (!valid) {
-    console.warn(`[gateway] "${name}": invalid EXPOSE_AT_AGENT_STARTUP="${rawExpose}" (expected true | false) — not pre-exposed`);
-  }
-
-  const rawRelayPort = cfg.env?.[HTTP_RELAY_PORT_KEY];
-  const { port: relayPort, valid: relayPortValid } = parseRelayPort(rawRelayPort);
-  if (!relayPortValid) {
-    throw new Error(`invalid ${HTTP_RELAY_PORT_KEY}="${rawRelayPort}" (expected a port 1-65535)`);
-  }
-
-  return { route, exposeAtStartup, relayPort, description: cfg.description ?? null };
-}
-
-export class McpRegistry {
-  /** Entrées en service, dans l'ordre de la configuration. */
-  entries = [];
-  proxyTools = [];
-  /** Préfixes `<route>/http` des MCP qui déclarent un relais HTTP. */
-  relayPrefixes = new Set();
-
-  #bootId = crypto.randomUUID().slice(0, 8);
-  #generation = 0;
-  #queue = Promise.resolve();
-  #onToolsLoaded;
-
-  /**
-   * @param {{ onToolsLoaded?: (name: string, tools: object[]) => void }} options
-   *   `onToolsLoaded` est appelé à chaque lancement d'un MCP, avec ses outils.
-   */
-  constructor({ onToolsLoaded } = {}) {
-    this.#onToolsLoaded = onToolsLoaded ?? (() => {});
-  }
-
-  /** Identifiant de l'état servi : change à chaque démarrage du gateway et à chaque changement effectif. */
-  get revision() {
-    return `${this.#bootId}.${this.#generation}`;
-  }
-
-  byRoute(route) {
-    return this.entries.find((entry) => entry.route === route) ?? null;
-  }
-
-  byName(name) {
-    return this.entries.find((entry) => entry.name === name) ?? null;
-  }
-
-  /**
-   * Aligne le registre sur `servers` (le bloc `mcpServers` de la configuration).
-   * Les appels sont sérialisés. Rend une ligne par MCP concerné :
-   * `{ name, action, ok, error? }`, `action` ∈ started | restarted | stopped | updated | unchanged.
-   */
-  apply(servers) {
-    const run = this.#queue.then(() => this.#apply(servers));
-    this.#queue = run.catch(() => {});
-    return run;
-  }
-
-  async closeAll() {
-    await Promise.allSettled(this.entries.map((entry) => entry.client.close()));
-  }
-
-  async #apply(servers) {
-    const results = [];
-    const wanted = new Map(Object.entries(servers ?? {}));
-    const restarting = new Set();
-    let changed = false;
-
-    // Arrêts d'abord : un MCP relancé ou une route reprise ne doivent pas croiser l'ancien processus.
-    for (const entry of [...this.entries]) {
-      const cfg = wanted.get(entry.name);
-      if (cfg && processKey(cfg) === entry.processKey) continue;
-      await this.#stop(entry);
-      changed = true;
-      if (cfg) restarting.add(entry.name);
-      else results.push({ name: entry.name, action: 'stopped', ok: true });
-    }
-
-    for (const [name, cfg] of wanted) {
-      const current = this.byName(name);
-
-      if (current) {
-        const { description, exposeAtStartup } = readDirectives(name, cfg);
-        const updated = current.description !== description || current.exposeAtStartup !== exposeAtStartup;
-        current.description = description;
-        current.exposeAtStartup = exposeAtStartup;
-        if (updated) changed = true;
-        results.push({ name, action: updated ? 'updated' : 'unchanged', ok: true });
-        continue;
-      }
-
-      const action = restarting.has(name) ? 'restarted' : 'started';
-      try {
-        await this.#start(name, cfg);
-        changed = true;
-        results.push({ name, action, ok: true });
-      } catch (err) {
-        console.error(`[gateway] Failed to start "${name}": ${err.message}`);
-        results.push({ name, action, ok: false, error: err.message });
-      }
-    }
-
-    // Ordre de la configuration, conservé pour list_mcps, /mcps et la pré-exposition.
-    const order = [...wanted.keys()];
-    this.entries.sort((a, b) => order.indexOf(a.name) - order.indexOf(b.name));
-
-    if (changed) {
-      this.#generation += 1;
-      this.#refreshDerived();
-    }
-    return results;
-  }
-
-  async #start(name, cfg) {
-    const directives = readDirectives(name, cfg);
-    if (this.byRoute(directives.route)) {
-      throw new Error(`route ${directives.route} already served by "${this.byRoute(directives.route).name}"`);
-    }
-    const client = await connectMcp(name, cfg);
-    let tools;
-    try {
-      ({ tools } = await client.listTools());
-    } catch (err) {
-      await client.close().catch(() => {});
-      throw err;
-    }
-    this.entries.push({ name, ...directives, tools, client, processKey: processKey(cfg) });
-    if (directives.relayPort) {
-      console.log(`[gateway] HTTP relay: ${relayPrefix(directives.route)}/* → 127.0.0.1:${directives.relayPort} (${name})`);
-    }
-    this.#onToolsLoaded(name, tools);
-  }
-
-  async #stop(entry) {
-    this.entries = this.entries.filter((e) => e !== entry);
-    try {
-      await entry.client.close();
-    } catch (err) {
-      console.error(`[gateway] Error while closing "${entry.name}":`, err.message);
-    }
-    console.log(`[gateway] Stopped: ${entry.name}`);
-  }
-
-  #refreshDerived() {
-    this.relayPrefixes = new Set(
-      this.entries.filter((e) => e.relayPort).map((e) => relayPrefix(e.route))
-    );
-    this.proxyTools = buildProxyTools(this.entries);
-
-    const preExposed = this.entries.filter((e) => e.exposeAtStartup);
-    if (preExposed.length) {
-      console.log(`[gateway] Pre-exposed at agent startup: ${preExposed.map((e) => e.name).join(', ')} — ${this.proxyTools.length} tool(s) published directly in tools/list`);
-    }
-    const overlong = overlongProxyNames(this.proxyTools);
-    if (overlong.length) {
-      console.warn(`[gateway] WARNING: proxy tool name(s) may exceed client limits once prefixed: ${overlong.join(', ')}`);
-    }
-    console.log(`[gateway] Revision ${this.revision} — ${this.entries.length} MCP(s) in service`);
-  }
-}
+import crypto from 'crypto';
+import readline from 'readline';
+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';
+
+// --- Registre des MCP hébergés par le gateway ---
+//
+// Le registre est la seule source de vérité sur les MCP en service : les routes REST, le
+// relais HTTP, l'endpoint /mcp et la pré-exposition le consultent à chaque requête.
+//
+// `apply(servers)` aligne le registre sur une configuration `mcpServers` :
+//   - MCP absent de la configuration      → son processus est arrêté ;
+//   - MCP nouveau, ou pas en service      → il est lancé ;
+//   - command, args ou env modifiés       → seul ce MCP est relancé ;
+//   - description ou EXPOSE_AT_AGENT_STARTUP seuls modifiés → mis à jour sans relance.
+// Les autres MCP ne sont pas touchés.
+//
+// Chaque changement effectif incrémente la révision, que le gateway renvoie dans l'en-tête
+// `X-Gateway-Revision` : le relais stdio (mcp-mode.js) s'en sert pour rafraîchir ses outils.
+
+export const REVISION_HEADER = 'X-Gateway-Revision';
+
+// Variables système minimales transmises aux MCPs enfants.
+// On exclut délibérément toutes les variables propres au gateway
+// (OPENAI_API_KEY, OAUTH_*, GATEWAY_*, MCP_*, etc.).
+const CHILD_ENV_WHITELIST = new Set([
+  'PATH', 'HOME', 'USER', 'LOGNAME', 'SHELL',
+  'LANG', 'LC_ALL', 'LC_CTYPE',
+  'TEMP', 'TMP', 'TMPDIR',
+  'USERPROFILE', 'APPDATA', 'LOCALAPPDATA',
+  'SYSTEMROOT', 'SYSTEMDRIVE', 'WINDIR',
+  'COMSPEC', 'PATHEXT', 'USERNAME',
+  'PROGRAMFILES', 'NODE_PATH',
+]);
+
+// Directives lues par le gateway seul : les modifier ne justifie pas de relancer le MCP.
+const GATEWAY_ONLY_KEYS = new Set(['EXPOSE_AT_AGENT_STARTUP']);
+
+function buildChildEnv(cfgEnv = {}) {
+  const safeEnv = Object.fromEntries(
+    Object.entries(process.env).filter(([k]) => CHILD_ENV_WHITELIST.has(k))
+  );
+  return { ...safeEnv, ...cfgEnv };
+}
+
+/** Préfixe des lignes de stderr d'un MCP : `[mcp "<nom>"] `, le nom en chaîne JSON. */
+export function stderrPrefix(name) {
+  return `[mcp ${JSON.stringify(name)}] `;
+}
+
+/** Recopie le stderr d'un MCP sur celui du gateway, ligne par ligne, chacune préfixée par le nom du MCP. */
+function relayStderr(name, stream) {
+  const prefix = stderrPrefix(name);
+  readline.createInterface({ input: stream, crlfDelay: Infinity }).on('line', (line) => {
+    process.stderr.write(`${prefix}${line}\n`);
+  });
+}
+
+async function connectMcp(name, cfg) {
+  const transport = new StdioClientTransport({
+    command: cfg.command,
+    args: cfg.args ?? [],
+    env: buildChildEnv(cfg.env),
+    stderr: 'pipe',
+  });
+  relayStderr(name, transport.stderr);
+  const client = new Client({ name: 'mcp-gateway', version: '1.0.0' }, { capabilities: {} });
+  await client.connect(transport);
+  console.log(`[gateway] Connected: ${name} → ${cfg.env?.MCP_SERVER_ROUTE}`);
+  return client;
+}
+
+/** Empreinte de ce qui définit le processus enfant : la changer impose de le relancer. */
+function processKey(cfg) {
+  const env = Object.entries(cfg.env ?? {})
+    .filter(([key]) => !GATEWAY_ONLY_KEYS.has(key))
+    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+  return JSON.stringify([cfg.command, cfg.args ?? [], env]);
+}
+
+/**
+ * Lit les directives gateway d'un MCP. Lève une erreur si le MCP ne peut pas être servi.
+ */
+function readDirectives(name, cfg) {
+  const route = cfg.env?.MCP_SERVER_ROUTE;
+  if (!route) throw new Error('no MCP_SERVER_ROUTE defined');
+
+  const rawExpose = cfg.env?.EXPOSE_AT_AGENT_STARTUP;
+  const { value: exposeAtStartup, valid } = parseExposeFlag(rawExpose);
+  if (!valid) {
+    console.warn(`[gateway] "${name}": invalid EXPOSE_AT_AGENT_STARTUP="${rawExpose}" (expected true | false) — not pre-exposed`);
+  }
+
+  const rawRelayPort = cfg.env?.[HTTP_RELAY_PORT_KEY];
+  const { port: relayPort, valid: relayPortValid } = parseRelayPort(rawRelayPort);
+  if (!relayPortValid) {
+    throw new Error(`invalid ${HTTP_RELAY_PORT_KEY}="${rawRelayPort}" (expected a port 1-65535)`);
+  }
+
+  return { route, exposeAtStartup, relayPort, description: cfg.description ?? null };
+}
+
+export class McpRegistry {
+  /** Entrées en service, dans l'ordre de la configuration. */
+  entries = [];
+  proxyTools = [];
+  /** Préfixes `<route>/http` des MCP qui déclarent un relais HTTP. */
+  relayPrefixes = new Set();
+
+  #bootId = crypto.randomUUID().slice(0, 8);
+  #generation = 0;
+  #queue = Promise.resolve();
+  #onToolsLoaded;
+
+  /**
+   * @param {{ onToolsLoaded?: (name: string, tools: object[]) => void }} options
+   *   `onToolsLoaded` est appelé à chaque lancement d'un MCP, avec ses outils.
+   */
+  constructor({ onToolsLoaded } = {}) {
+    this.#onToolsLoaded = onToolsLoaded ?? (() => {});
+  }
+
+  /** Identifiant de l'état servi : change à chaque démarrage du gateway et à chaque changement effectif. */
+  get revision() {
+    return `${this.#bootId}.${this.#generation}`;
+  }
+
+  byRoute(route) {
+    return this.entries.find((entry) => entry.route === route) ?? null;
+  }
+
+  byName(name) {
+    return this.entries.find((entry) => entry.name === name) ?? null;
+  }
+
+  /**
+   * Aligne le registre sur `servers` (le bloc `mcpServers` de la configuration).
+   * Les appels sont sérialisés. Rend une ligne par MCP concerné :
+   * `{ name, action, ok, error? }`, `action` ∈ started | restarted | stopped | updated | unchanged.
+   */
+  apply(servers) {
+    const run = this.#queue.then(() => this.#apply(servers));
+    this.#queue = run.catch(() => {});
+    return run;
+  }
+
+  async closeAll() {
+    await Promise.allSettled(this.entries.map((entry) => entry.client.close()));
+  }
+
+  async #apply(servers) {
+    const results = [];
+    const wanted = new Map(Object.entries(servers ?? {}));
+    const restarting = new Set();
+    let changed = false;
+
+    // Arrêts d'abord : un MCP relancé ou une route reprise ne doivent pas croiser l'ancien processus.
+    for (const entry of [...this.entries]) {
+      const cfg = wanted.get(entry.name);
+      if (cfg && processKey(cfg) === entry.processKey) continue;
+      await this.#stop(entry);
+      changed = true;
+      if (cfg) restarting.add(entry.name);
+      else results.push({ name: entry.name, action: 'stopped', ok: true });
+    }
+
+    for (const [name, cfg] of wanted) {
+      const current = this.byName(name);
+
+      if (current) {
+        const { description, exposeAtStartup } = readDirectives(name, cfg);
+        const updated = current.description !== description || current.exposeAtStartup !== exposeAtStartup;
+        current.description = description;
+        current.exposeAtStartup = exposeAtStartup;
+        if (updated) changed = true;
+        results.push({ name, action: updated ? 'updated' : 'unchanged', ok: true });
+        continue;
+      }
+
+      const action = restarting.has(name) ? 'restarted' : 'started';
+      try {
+        await this.#start(name, cfg);
+        changed = true;
+        results.push({ name, action, ok: true });
+      } catch (err) {
+        console.error(`[gateway] Failed to start "${name}": ${err.message}`);
+        results.push({ name, action, ok: false, error: err.message });
+      }
+    }
+
+    // Ordre de la configuration, conservé pour list_mcps, /mcps et la pré-exposition.
+    const order = [...wanted.keys()];
+    this.entries.sort((a, b) => order.indexOf(a.name) - order.indexOf(b.name));
+
+    if (changed) {
+      this.#generation += 1;
+      this.#refreshDerived();
+    }
+    return results;
+  }
+
+  async #start(name, cfg) {
+    const directives = readDirectives(name, cfg);
+    if (this.byRoute(directives.route)) {
+      throw new Error(`route ${directives.route} already served by "${this.byRoute(directives.route).name}"`);
+    }
+    const client = await connectMcp(name, cfg);
+    let tools;
+    try {
+      ({ tools } = await client.listTools());
+    } catch (err) {
+      await client.close().catch(() => {});
+      throw err;
+    }
+    this.entries.push({ name, ...directives, tools, client, processKey: processKey(cfg) });
+    if (directives.relayPort) {
+      console.log(`[gateway] HTTP relay: ${relayPrefix(directives.route)}/* → 127.0.0.1:${directives.relayPort} (${name})`);
+    }
+    this.#onToolsLoaded(name, tools);
+  }
+
+  async #stop(entry) {
+    this.entries = this.entries.filter((e) => e !== entry);
+    try {
+      await entry.client.close();
+    } catch (err) {
+      console.error(`[gateway] Error while closing "${entry.name}":`, err.message);
+    }
+    console.log(`[gateway] Stopped: ${entry.name}`);
+  }
+
+  #refreshDerived() {
+    this.relayPrefixes = new Set(
+      this.entries.filter((e) => e.relayPort).map((e) => relayPrefix(e.route))
+    );
+    this.proxyTools = buildProxyTools(this.entries);
+
+    const preExposed = this.entries.filter((e) => e.exposeAtStartup);
+    if (preExposed.length) {
+      console.log(`[gateway] Pre-exposed at agent startup: ${preExposed.map((e) => e.name).join(', ')} — ${this.proxyTools.length} tool(s) published directly in tools/list`);
+    }
+    const overlong = overlongProxyNames(this.proxyTools);
+    if (overlong.length) {
+      console.warn(`[gateway] WARNING: proxy tool name(s) may exceed client limits once prefixed: ${overlong.join(', ')}`);
+    }
+    console.log(`[gateway] Revision ${this.revision} — ${this.entries.length} MCP(s) in service`);
+  }
+}

package/package.json

@@ -1,59 +1,62 @@
-{
-  "name": "@imenam/mcp-http-gateway",
-  "version": "2.0.22",
-  "type": "module",
-  "description": "HTTP gateway that exposes MCP servers as REST routes — bridge between MCP and any HTTP-capable agent",
-  "main": "server.js",
-  "bin": {
-    "mcp-http-gateway": "server.js"
-  },
-  "files": [
-    "server.js",
-    "mcp-mode.js",
-    "mcp-endpoint.js",
-    "auth.js",
-    "README.md",
-    "embeddings/",
-    "startup-exposition.js",
-    "http-relay.js",
-    "gateway-exec.js",
-    "gateway-watch.js",
-    "mcp-registry.js",
-    "scope.js"
-  ],
-  "scripts": {
-    "start": "node server.js",
-    "release": "npm version patch && npm publish --access public && git push origin master --follow-tags"
-  },
-  "keywords": [
-    "mcp",
-    "model-context-protocol",
-    "gateway",
-    "http",
-    "ai",
-    "agent",
-    "llm",
-    "bridge"
-  ],
-  "author": "Matthieu Pesnot-Pin <matthieupin@gmail.com>",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/Matthieu-Pesnot-Pin/mcp-http-gateway.git"
-  },
-  "bugs": {
-    "url": "https://github.com/Matthieu-Pesnot-Pin/mcp-http-gateway/issues"
-  },
-  "homepage": "https://github.com/Matthieu-Pesnot-Pin/mcp-http-gateway#readme",
-  "license": "ISC",
-  "engines": {
-    "node": ">=18"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.27.1",
-    "better-sqlite3": "^12.8.0",
-    "dotenv": "^17.3.1",
-    "express": "^5.2.1",
-    "jose": "^6.2.3",
-    "openai": "^6.31.0"
-  }
-}
+{
+  "name": "@imenam/mcp-http-gateway",
+  "version": "2.0.24",
+  "type": "module",
+  "description": "HTTP gateway that exposes MCP servers as REST routes — bridge between MCP and any HTTP-capable agent",
+  "main": "server.js",
+  "bin": {
+    "mcp-http-gateway": "server.js"
+  },
+  "files": [
+    "server.js",
+    "mcp-mode.js",
+    "mcp-endpoint.js",
+    "auth.js",
+    "README.md",
+    "embeddings/",
+    "startup-exposition.js",
+    "http-relay.js",
+    "gateway-exec.js",
+    "gateway-watch.js",
+    "mcp-registry.js",
+    "scope.js"
+  ],
+  "scripts": {
+    "start": "node server.js"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "gateway",
+    "http",
+    "ai",
+    "agent",
+    "llm",
+    "bridge"
+  ],
+  "author": "Matthieu Pesnot-Pin <matthieupin@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Matthieu-Pesnot-Pin/mcp-http-gateway.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Matthieu-Pesnot-Pin/mcp-http-gateway/issues"
+  },
+  "homepage": "https://github.com/Matthieu-Pesnot-Pin/mcp-http-gateway#readme",
+  "license": "ISC",
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@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 :