@imenam/mcp-http-gateway 2.0.9 → 2.0.10

package/README.md

@@ -52,6 +52,7 @@ GATEWAY_CONFIG_DIR=./config
 |---|---|---|
 | `GATEWAY_PORT` | `3500` | Port HTTP du gateway |
 | `GATEWAY_CONFIG_DIR` | `./config` (relatif au cwd) | Dossier contenant `mcp-servers.json` |
+| `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`. |
 
 ### `mcp-servers.json`
 
@@ -188,6 +189,9 @@ GATEWAY_URL=http://host.docker.internal:3500 npx @imenam/mcp-http-gateway --mcp
 |---|---|---|
 | `GATEWAY_URL` | oui | Base HTTP du gateway à relayer, sans barre finale. Le relais compose lui-même ses routes REST (`/startup-exposition`, `/mcp-definitions`, `/{route}/tools`, `/{route}/tools/{outil}`) : **ne pas** y ajouter `/mcp`. |
 | `GATEWAY_TOKEN` | non | Token porteur. S'il est défini, **tous** les appels sortants du relais portent `Authorization: Bearer <token>`. Absent, aucun en-tête n'est ajouté — le comportement est exactement celui des versions antérieures. |
+| `GATEWAY_INLINE_ROOTS` | non | Dossiers depuis lesquels le relais peut lire un fichier et en transmettre le contenu (cf. [Fichiers locaux](#fichiers-locaux--lagent-nomme-le-relais-lit)). **Non renseignée, la fonction est désactivée** et un chemin part tel quel. Séparateur : `;` sous Windows, `:` ailleurs. |
+| `GATEWAY_INLINE_EXTENSIONS` | non | Extensions autorisées, séparées par des virgules. Défaut : `.xlsx,.xls,.ods,.csv`. `*` autorise toutes les extensions. |
+| `GATEWAY_INLINE_MAX_BYTES` | non | Taille maximale d'un fichier transmis, en octets. Défaut : `8388608` (8 Mio). |
 
 > Ces deux variables sont lues dans l'environnement du process. Le relais fait
 > `import 'dotenv/config'` : un fichier `.env` présent dans le **répertoire courant de
@@ -230,6 +234,62 @@ Le mode MCP expose 3 outils qui reflètent directement les routes du gateway :
 
 L'agent découvre d'abord les MCPs disponibles, explore les outils d'un MCP si besoin, puis appelle l'outil voulu.
 
+### Fichiers locaux : l'agent nomme, le relais lit
+
+Le relais tourne sur la machine de l'**agent** ; les MCP, eux, tournent sur la machine du
+**gateway**. Un chemin de fichier transmis tel quel ne veut donc rien dire à l'arrivée : le
+MCP le cherche chez lui et répond « fichier introuvable ».
+
+Le relais sait résoudre ça. Dès qu'un outil distant déclare une paire de paramètres
+`<x>_path` / `<x>_content`, le relais **lit le fichier localement, l'encode en base64 et
+envoie le contenu** dans `<x>_content` (plus le nom dans `<x>_name`, si le schéma le
+prévoit). Le paramètre `file_path` reste la seule chose que l'agent fournit : les
+paramètres que le relais remplit sont **retirés du schéma** publié à l'agent, par
+`tools/list` comme par `list_tools`. L'agent n'a donc aucun arbitrage à faire, et aucune
+occasion d'envoyer un chemin qui ne serait pas lisible à l'arrivée.
+
+Un outil qui ne déclare pas cette paire n'est jamais concerné : un `output_path` seul reste
+un chemin, interprété côté gateway comme avant.
+
+**Le chemin vient de l'agent : il n'est pas digne de confiance.** La fonction est donc
+fermée par défaut et s'ouvre dossier par dossier :
+
+```json
+{
+  "mcpServers": {
+    "gateway": {
+      "command": "npx",
+      "args": ["@imenam/mcp-http-gateway", "--mcp"],
+      "env": {
+        "GATEWAY_URL": "https://my-gateway.fr/jskdlf-jsfklhj",
+        "GATEWAY_TOKEN": "…",
+        "GATEWAY_INLINE_ROOTS": "C:\\Users\\moi\\Documents\\tableurs;C:\\travail\\exports"
+      }
+    }
+  }
+}
+```
+
+- **`GATEWAY_INLINE_ROOTS` est l'interrupteur.** Non renseignée, le relais ne lit aucun
+  fichier et se comporte exactement comme les versions antérieures.
+- Les liens symboliques sont résolus **avant** le contrôle : un lien posé dans un dossier
+  autorisé ne fait pas sortir un fichier situé ailleurs. Une remontée par `..` est refusée
+  pour la même raison.
+- Seules les extensions de `GATEWAY_INLINE_EXTENSIONS` passent (défaut : tableurs).
+- Au-delà de `GATEWAY_INLINE_MAX_BYTES` (8 Mio par défaut), refus explicite. Ce défaut
+  tient sous le plafond de 16 Mio que le hub `mcp-gateway-manager` applique quand il
+  journalise les corps de requête.
+- Tout refus est rapporté à l'agent en clair, et **chaque fichier transmis laisse une ligne
+  sur `stderr`** : ce qui sort de la machine est lisible dans le journal de l'agent.
+
+> Côté MCP, cette fonction suppose que l'outil accepte le contenu en base64. C'est le cas
+> de [`@imenam/xls-reader`](https://www.npmjs.com/package/@imenam/xls-reader) ≥ 2.2. Un MCP
+> qui n'expose que `file_path` ne déclare pas la paire, et rien ne change pour lui.
+
+> **Le mode MCP distant (`/mcp`, Claude.ai) n'a pas de relais local** : rien ne tourne alors
+> sur la machine de l'appelant, donc personne ne peut lire son disque. Par ce chemin, un
+> agent qui veut faire lire un fichier doit en envoyer lui-même le contenu.
+
 ---
 
 ## Mode MCP distant (HTTPS / Claude.ai)

package/mcp-mode.js

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
 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 {
@@ -69,6 +71,196 @@ function gatewayThrowText(status) {
   return isAuthStatus(status) ? authErrorText(status) : `HTTP ${status}`;
 }
 
+// --- Fichiers : le relais lit, l'agent ne fait que nommer ---
+//
+// Le relais tourne sur la machine de l'AGENT ; le MCP, lui, tourne sur la machine du
+// gateway. Un chemin de fichier transmis tel quel ne veut donc rien dire à l'arrivée :
+// le MCP cherche le fichier chez lui et ne le trouve pas.
+//
+// La règle : dès qu'un outil distant déclare une paire `<x>_path` / `<x>_content`, le
+// relais lit le fichier ICI, l'encode en base64 et envoie le CONTENU. Le paramètre
+// `<x>_content` (et `<x>_name`, s'il existe) est retiré du schéma publié à l'agent :
+// l'agent ne fournit qu'un chemin, et n'a aucun arbitrage à faire.
+//
+// Rien ne se déclenche sur un outil qui n'expose pas cette paire : un `output_path`
+// seul reste un chemin, interprété côté gateway comme avant.
+//
+// Le chemin vient de l'agent : il n'est donc PAS digne de confiance. Trois garde-fous,
+// tous configurables dans le bloc « env » de ce serveur MCP :
+//
+//   GATEWAY_INLINE_ROOTS       Dossiers dont un fichier peut sortir. C'est l'interrupteur :
+//                              non renseigné, le relais ne lit aucun fichier et se comporte
+//                              exactement comme avant (le chemin part tel quel).
+//                              Séparateur : « ; » sous Windows, « : » ailleurs.
+//   GATEWAY_INLINE_EXTENSIONS  Extensions autorisées (défaut : tableurs). « * » pour toutes.
+//   GATEWAY_INLINE_MAX_BYTES   Taille maximale d'un fichier transmis (défaut : 8 Mio).
+//
+// Chaque fichier réellement transmis laisse une ligne sur stderr : ce que l'agent fait
+// sortir de la machine doit être lisible dans le journal de l'agent.
+
+/** Les racines autorisées, résolues une fois pour toutes au démarrage. */
+const INLINE_ROOTS = (process.env.GATEWAY_INLINE_ROOTS ?? '')
+  .split(path.delimiter)
+  .map((entry) => entry.trim())
+  .filter(Boolean)
+  .map((entry) => {
+    const resolved = path.resolve(entry);
+    try {
+      return fs.realpathSync(resolved);
+    } catch {
+      console.error(`[mcp-mode] GATEWAY_INLINE_ROOTS : dossier introuvable, ignoré — ${resolved}`);
+      return null;
+    }
+  })
+  .filter(Boolean);
+
+const INLINE_EXTENSIONS = (process.env.GATEWAY_INLINE_EXTENSIONS ?? '.xlsx,.xls,.ods,.csv')
+  .split(',')
+  .map((entry) => entry.trim().toLowerCase())
+  .filter(Boolean);
+
+const INLINE_ANY_EXTENSION = INLINE_EXTENSIONS.includes('*');
+
+// 8 Mio : encodé en base64 le corps pèse ~10,7 Mio, sous le plafond de 16 Mio que le hub
+// applique quand il journalise les corps de requête.
+const INLINE_MAX_BYTES =
+  Number.parseInt(process.env.GATEWAY_INLINE_MAX_BYTES ?? '', 10) || 8 * 1024 * 1024;
+
+const INLINE_FILES = INLINE_ROOTS.length > 0;
+
+if (INLINE_FILES) {
+  console.error(
+    `[mcp-mode] Transmission du contenu des fichiers activée depuis : ${INLINE_ROOTS.join(', ')} ` +
+      `(extensions : ${INLINE_ANY_EXTENSION ? 'toutes' : INLINE_EXTENSIONS.join(' ')})`
+  );
+}
+
+/** Le fichier est-il à l'intérieur d'une racine autorisée ? Liens symboliques résolus. */
+function insideAllowedRoot(realPath) {
+  return INLINE_ROOTS.some((root) => {
+    const rel = path.relative(root, realPath);
+    return rel !== '' && !rel.startsWith('..') && !path.isAbsolute(rel);
+  });
+}
+
+/** Les paires `<x>_path` / `<x>_content` déclarées par le schéma d'un outil. */
+function inlinablePairs(inputSchema) {
+  const props = inputSchema?.properties;
+  if (!INLINE_FILES || !props) return [];
+  return Object.keys(props)
+    .filter((key) => key.endsWith('_content') && `${key.slice(0, -'_content'.length)}_path` in props)
+    .map((contentProp) => {
+      const stem = contentProp.slice(0, -'_content'.length);
+      return {
+        pathProp: `${stem}_path`,
+        contentProp,
+        nameProp: `${stem}_name` in props ? `${stem}_name` : null,
+      };
+    });
+}
+
+/** Le schéma tel que l'agent doit le voir : sans les paramètres que le relais remplit. */
+function schemaForAgent(inputSchema) {
+  const pairs = inlinablePairs(inputSchema);
+  if (pairs.length === 0) return inputSchema;
+
+  const hidden = new Set(pairs.flatMap((p) => [p.contentProp, p.nameProp].filter(Boolean)));
+  const properties = Object.fromEntries(
+    Object.entries(inputSchema.properties).filter(([key]) => !hidden.has(key))
+  );
+
+  // Le chemin devient la seule façon de désigner le fichier : il n'est plus optionnel.
+  const required = [
+    ...new Set([
+      ...(inputSchema.required ?? []).filter((key) => !hidden.has(key)),
+      ...pairs.map((p) => p.pathProp),
+    ]),
+  ];
+
+  return { ...inputSchema, properties, required };
+}
+
+/**
+ * Remplace chaque `<x>_path` par le contenu du fichier lu sur la machine de l'agent.
+ *
+ * Tout refus est explicite : l'agent doit savoir pourquoi son fichier ne part pas,
+ * sans avoir à deviner s'il s'agit d'une absence, d'un type ou d'une interdiction.
+ */
+function inlineFileArgs(inputSchema, args = {}, label = '') {
+  const pairs = inlinablePairs(inputSchema);
+  if (pairs.length === 0) return args;
+
+  const out = { ...args };
+  for (const { pathProp, contentProp, nameProp } of pairs) {
+    const filePath = out[pathProp];
+    if (typeof filePath !== 'string' || filePath === '') continue;
+
+    const resolved = path.resolve(filePath);
+
+    // realpath avant tout contrôle : sans ça, un lien symbolique placé dans une racine
+    // autorisée ferait sortir n'importe quel fichier de la machine.
+    let real;
+    let stat;
+    try {
+      real = fs.realpathSync(resolved);
+      stat = fs.statSync(real);
+    } catch {
+      throw new Error(
+        `Fichier introuvable sur la machine de l'agent : ${resolved} (paramètre ${pathProp}).`
+      );
+    }
+    if (!stat.isFile()) {
+      throw new Error(`${resolved} n'est pas un fichier (paramètre ${pathProp}).`);
+    }
+    if (!insideAllowedRoot(real)) {
+      throw new Error(
+        `Lecture refusée : ${real} est hors des dossiers autorisés (${INLINE_ROOTS.join(', ')}). ` +
+          `Déplacez le fichier dans l'un d'eux, ou ajoutez son dossier à GATEWAY_INLINE_ROOTS ` +
+          `dans la configuration de ce serveur MCP.`
+      );
+    }
+    const ext = path.extname(real).toLowerCase();
+    if (!INLINE_ANY_EXTENSION && !INLINE_EXTENSIONS.includes(ext)) {
+      throw new Error(
+        `Lecture refusée : l'extension « ${ext || '(aucune)'} » n'est pas autorisée ` +
+          `(autorisées : ${INLINE_EXTENSIONS.join(' ')}, via GATEWAY_INLINE_EXTENSIONS).`
+      );
+    }
+    if (stat.size > INLINE_MAX_BYTES) {
+      throw new Error(
+        `Fichier trop volumineux à transmettre : ${real} pèse ${stat.size} octets, ` +
+          `la limite est de ${INLINE_MAX_BYTES} (GATEWAY_INLINE_MAX_BYTES).`
+      );
+    }
+
+    out[contentProp] = fs.readFileSync(real).toString('base64');
+    if (nameProp) out[nameProp] = path.basename(real);
+    delete out[pathProp];
+
+    console.error(
+      `[mcp-mode] Fichier transmis${label ? ` à ${label}` : ''} : ${real} (${stat.size} octets)`
+    );
+  }
+  return out;
+}
+
+/** Schémas des outils d'une route, mis en cache — nécessaires pour `call_tool`. */
+const routeSchemas = new Map();
+
+async function toolSchema(route, toolName) {
+  if (!INLINE_FILES) return null;
+  if (!routeSchemas.has(route)) {
+    try {
+      const res = await gatewayFetch(`${route}/tools`);
+      const list = res.ok ? await res.json() : [];
+      routeSchemas.set(route, new Map(list.map((t) => [t.name, t.inputSchema])));
+    } catch {
+      routeSchemas.set(route, new Map());
+    }
+  }
+  return routeSchemas.get(route).get(toolName) ?? null;
+}
+
 // --- MCP Server ---
 
 // Le gateway (mode serveur HTTP) peut être paramétré (EXPOSE_AT_AGENT_STARTUP) pour
@@ -136,7 +328,14 @@ const tools = [
 ];
 
 const proxyIndex = new Map(proxyTools.map(t => [t.name, t]));
-const allTools = [...tools, ...proxyTools.map(({ name, description, inputSchema }) => ({ name, description, inputSchema }))];
+const allTools = [
+  ...tools,
+  ...proxyTools.map(({ name, description, inputSchema }) => ({
+    name,
+    description,
+    inputSchema: schemaForAgent(inputSchema),
+  })),
+];
 
 server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: allTools }));
 
@@ -149,7 +348,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       const res = await gatewayFetch(`${proxy.route}/tools/${proxy.toolName}`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(args ?? {}),
+        body: JSON.stringify(
+          inlineFileArgs(proxy.inputSchema, args ?? {}, `${proxy.route}/${proxy.toolName}`)
+        ),
       });
       if (!res.ok) {
         const text = await res.text();
@@ -172,15 +373,23 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       const res = await gatewayFetch(`${args.route}/tools`);
       if (!res.ok) throw new Error(gatewayThrowText(res.status));
       const toolsList = await res.json();
-      const text = JSON.stringify(toolsList);
+      routeSchemas.set(args.route, new Map(toolsList.map((t) => [t.name, t.inputSchema])));
+      // Même règle que pour les outils pré-exposés : l'agent ne doit pas découvrir
+      // les paramètres de contenu, c'est le relais qui les remplit.
+      const text = JSON.stringify(
+        toolsList.map((t) => (t.inputSchema ? { ...t, inputSchema: schemaForAgent(t.inputSchema) } : t))
+      );
       return { content: [{ type: 'text', text }] };
     }
 
     if (name === 'call_tool') {
+      const schema = await toolSchema(args.route, args.tool_name);
       const res = await gatewayFetch(`${args.route}/tools/${args.tool_name}`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(args.arguments ?? {}),
+        body: JSON.stringify(
+          inlineFileArgs(schema, args.arguments ?? {}, `${args.route}/${args.tool_name}`)
+        ),
       });
       if (!res.ok) {
         const text = await res.text();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@imenam/mcp-http-gateway",
-  "version": "2.0.9",
+  "version": "2.0.10",
   "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

@@ -114,7 +114,11 @@ async function main() {
     app.set('trust proxy', val === 'true' || val === '1' ? 1 : val);
     console.log(`[gateway] Trust proxy enabled (TRUST_PROXY=${val})`);
   }
-  app.use(express.json({ type: '*/*' }));
+  // 32 Mo, et non les 100 ko par défaut d'express : un appel d'outil peut porter le
+  // contenu d'un fichier encodé en base64 (cf. l'inlining du relais dans mcp-mode.js),
+  // qui repartirait sinon en « 413 Payload Too Large » sans explication.
+  const BODY_LIMIT = process.env.GATEWAY_BODY_LIMIT ?? '32mb';
+  app.use(express.json({ type: '*/*', limit: BODY_LIMIT }));
 
   const globalWindowMin = parseInt(process.env.RATE_LIMIT_GLOBAL_WINDOW_MINUTES ?? '15', 10);
   const globalMax       = parseInt(process.env.RATE_LIMIT_GLOBAL_MAX ?? '300', 10);