@imenam/mcp-http-gateway 2.0.19 → 2.0.21

package/README.md

@@ -55,6 +55,10 @@ GATEWAY_CONFIG_DIR=./config
 | `GATEWAY_ADMIN_TOKEN` | — | Active `POST /admin/reload` et en est le jeton. Absent, la route n'existe pas. Voir [Rechargement à chaud](#rechargement-à-chaud). |
 | `GATEWAY_SCOPE_SECRET` | — | Impose un périmètre d'accès signé sur chaque requête. Absent, toute requête voit tous les MCP et tous les outils. Voir [Périmètre d'accès](#périmètre-daccès). |
 | `GATEWAY_BODY_LIMIT` | `32mb` | Taille maximale du corps d'une requête. Le défaut d'express (100 ko) ne suffit pas dès qu'un appel d'outil porte le contenu d'un fichier en base64 ; au-delà de cette limite, la réponse est un `413`. Ne s'applique pas aux routes de [relais HTTP](#relais-http-mcp_http_relay_port). |
+| `RATE_LIMIT_GLOBAL_MAX` / `RATE_LIMIT_GLOBAL_WINDOW_MINUTES` | `1000` / `1` | Requêtes acceptées par IP sur la fenêtre, toutes routes confondues ; au-delà, la réponse est un `429`. `0` désactive la limite. |
+| `RATE_LIMIT_SEARCH_MAX` / `RATE_LIMIT_SEARCH_WINDOW_MINUTES` | `30` / `1` | Même principe pour `/tools/search`, en plus de la limite globale. `0` désactive la limite. |
+
+Derrière un frontal qui authentifie déjà les appelants et borne leur fréquence, comme mcp-gateway-manager, les deux limites se mettent à `0`.
 
 ### `mcp-servers.json`
 
@@ -107,6 +111,14 @@ npm start
 
 Le gateway connecte chaque MCP configuré et démarre le serveur HTTP. Les MCPs en échec au démarrage sont ignorés sans bloquer les autres.
 
+Le `stderr` de chaque MCP est recopié sur celui du gateway, ligne par ligne, préfixé par le nom du MCP sous forme de chaîne JSON :
+
+```
+[mcp "Ticket PXP"] [ProxyClient] Mount path resolved to /jf5gh9dqct/ticket-manager (requested: /ticket-manager)
+```
+
+Un superviseur qui lit le journal du gateway sait ainsi quel MCP a écrit chaque ligne.
+
 ## Rechargement à chaud
 
 Avec `GATEWAY_ADMIN_TOKEN` défini, le gateway relit `mcp-servers.json` sur demande, sans redémarrer :
@@ -552,11 +564,13 @@ La convention, côté MCP :
    jeton du gateway, route, outil, arguments, point de reprise. Il rend à l'agent, à la place
    de la réponse du MCP, l'appel `Monitor` à faire :
    ```text
-   command:     "<node>" "<…>/mcp-http-gateway/server.js" --watch "<…>/watch/<id>.json"
+   command:     npx -y @imenam/mcp-http-gateway@<version du relais> --watch "<…>/watch/<id>.json"
    timeout_ms:  1800000
    ```
-   Le jeton ne figure jamais dans la commande, donc jamais dans la conversation.
-4. Le veilleur (`server.js --watch <fichier>`) appelle l'outil d'attente avec ses arguments,
+   Le jeton ne figure jamais dans la commande, donc jamais dans la conversation. La commande
+   lance le veilleur par npx, dans la version exacte du relais : elle ne dépend d'aucun chemin
+   du cache de npx.
+4. Le veilleur (`mcp-http-gateway --watch <fichier>`) appelle l'outil d'attente avec ses arguments,
    plus `cursor` et `timeout_seconds: 50`. L'outil répond, dans `_meta["gateway/events"]` :
    ```json
    { "cursor": "58", "lines": ["[telegram] new post 42: … — read it with get_post"] }

package/gateway-watch.js

@@ -51,7 +51,8 @@ const BACKOFF_MAX_MS = 30_000;
 /** Échecs consécutifs au-delà desquels l'agent est prévenu que la veille est interrompue. */
 const FAILURES_BEFORE_NOTICE = 3;
 
-const SERVER_SCRIPT = path.join(path.dirname(fileURLToPath(import.meta.url)), 'server.js');
+/** Nom et version de ce paquet, qui fixent la commande du veilleur. */
+const PACKAGE = JSON.parse(fs.readFileSync(path.join(path.dirname(fileURLToPath(import.meta.url)), 'package.json'), 'utf8'));
 
 export function watchDir() {
   const override = process.env.GATEWAY_WATCH_DIR?.trim();
@@ -123,10 +124,10 @@ function activeWatcher(file) {
   return presence && typeof presence.pid === 'number' && processExists(presence.pid) ? presence : null;
 }
 
-/** Commande du veilleur : le même Node et le même paquet que ce relais. */
+/** Commande du veilleur : ce paquet, lancé par npx dans la version exacte de ce relais. */
 export function watchCommand(file) {
   const quote = (value) => `"${value.replace(/\\/g, '/')}"`;
-  return `${quote(process.execPath)} ${quote(SERVER_SCRIPT)} --watch ${quote(file)}`;
+  return `npx -y ${PACKAGE.name}@${PACKAGE.version} --watch ${quote(file)}`;
 }
 
 /** Fichiers de veille écrits par ce relais, retirés à son arrêt. */

package/mcp-registry.js

@@ -1,4 +1,5 @@
 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';
@@ -44,12 +45,27 @@ function buildChildEnv(cfgEnv = {}) {
   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}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@imenam/mcp-http-gateway",
-  "version": "2.0.19",
+  "version": "2.0.21",
   "type": "module",
   "description": "HTTP gateway that exposes MCP servers as REST routes — bridge between MCP and any HTTP-capable agent",
   "main": "server.js",

package/server.js

@@ -198,28 +198,33 @@ async function main() {
     isRelayPath(registry.relayPrefixes, req.path) ? next() : jsonParser(req, res, next)
   );
 
-  const globalWindowMin = parseInt(process.env.RATE_LIMIT_GLOBAL_WINDOW_MINUTES ?? '15', 10);
-  const globalMax       = parseInt(process.env.RATE_LIMIT_GLOBAL_MAX ?? '300', 10);
+  // Une limite à 0 désactive le compteur correspondant.
+  const globalWindowMin = parseInt(process.env.RATE_LIMIT_GLOBAL_WINDOW_MINUTES ?? '1', 10);
+  const globalMax       = parseInt(process.env.RATE_LIMIT_GLOBAL_MAX ?? '1000', 10);
   const searchWindowMin = parseInt(process.env.RATE_LIMIT_SEARCH_WINDOW_MINUTES ?? '1', 10);
   const searchMax       = parseInt(process.env.RATE_LIMIT_SEARCH_MAX ?? '30', 10);
 
-  app.use(rateLimit({
-    windowMs: globalWindowMin * 60_000,
-    max: globalMax,
-    standardHeaders: 'draft-8',
-    legacyHeaders: false,
-    message: { error: 'Too Many Requests' },
-  }));
-  console.log(`[gateway] Rate limit — global: ${globalMax} req/${globalWindowMin} min/IP`);
-
-  const searchLimiter = rateLimit({
-    windowMs: searchWindowMin * 60_000,
-    max: searchMax,
+  const limiter = (windowMin, max) => rateLimit({
+    windowMs: windowMin * 60_000,
+    limit: max,
     standardHeaders: 'draft-8',
     legacyHeaders: false,
     message: { error: 'Too Many Requests' },
   });
-  console.log(`[gateway] Rate limit — /tools/search: ${searchMax} req/${searchWindowMin} min/IP`);
+
+  if (globalMax > 0) {
+    app.use(limiter(globalWindowMin, globalMax));
+    console.log(`[gateway] Rate limit — global: ${globalMax} req/${globalWindowMin} min/IP`);
+  } else {
+    console.log('[gateway] Rate limit — global: disabled');
+  }
+
+  const searchLimiter = searchMax > 0
+    ? limiter(searchWindowMin, searchMax)
+    : (req, res, next) => next();
+  console.log(searchMax > 0
+    ? `[gateway] Rate limit — /tools/search: ${searchMax} req/${searchWindowMin} min/IP`
+    : '[gateway] Rate limit — /tools/search: disabled');
 
   const verifier = createMcpTokenVerifier();
   if (verifier) {