@imenam/mcp-http-gateway 2.0.14 → 2.0.16

package/server.js

@@ -1,21 +1,28 @@
 #!/usr/bin/env node
 import 'dotenv/config';
 
-if (process.argv.includes('--mcp')) {
+if (process.argv.includes('--watch')) {
+  // Veilleur lancé par l'agent via Monitor (voir gateway-watch.js) : il n'ouvre ni serveur ni relais.
+  const { runWatchMode } = await import('./gateway-watch.js');
+  await runWatchMode(process.argv[process.argv.indexOf('--watch') + 1]).catch((err) => {
+    console.error(`[gateway-watch] ${err.message}`);
+    process.exit(1);
+  });
+} else if (process.argv.includes('--mcp')) {
   await import('./mcp-mode.js');
   // Process stays alive: the MCP transport keeps stdin open until the client disconnects
 }
 
+import crypto from 'crypto';
 import { readFileSync } from 'fs';
 import path from 'path';
 import express from 'express';
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { initDb, getOrComputeToolEmbedding, getAllToolEmbeddings } from './embeddings/db.js';
 import { getEmbedding, cosineSimilarity } from './embeddings/vectorizer.js';
 import { registerMcpEndpoint } from './mcp-endpoint.js';
-import { buildProxyTools, overlongProxyNames, parseExposeFlag } from './startup-exposition.js';
 import { createMcpTokenVerifier } from './auth.js';
+import { relayPrefix, isRelayPath, createHttpRelay } from './http-relay.js';
+import { McpRegistry, REVISION_HEADER } from './mcp-registry.js';
 import { requireBearerAuth } from '@modelcontextprotocol/sdk/server/auth/middleware/bearerAuth.js';
 import { rateLimit } from 'express-rate-limit';
 
@@ -30,65 +37,61 @@ function normalizeCfg(cfg) {
   return { ...cfg, command, args, env };
 }
 
-// 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',
-]);
-
-function buildChildEnv(cfgEnv = {}) {
-  const safeEnv = Object.fromEntries(
-    Object.entries(process.env).filter(([k]) => CHILD_ENV_WHITELIST.has(k))
-  );
-  return { ...safeEnv, ...cfgEnv };
-}
+// --- Routes des MCP ---
+
+/**
+ * Routes `<route>/tools`, `<route>/tools/:toolName` et `<route>/http/*` de chaque MCP,
+ * résolues sur le registre à chaque requête.
+ */
+function mcpRoutes(registry) {
+  return async (req, res, next) => {
+    for (const entry of registry.entries) {
+      const { route, name, client } = entry;
+      if (req.path !== route && !req.path.startsWith(`${route}/`)) continue;
+      const rest = req.path.slice(route.length);
+
+      if (entry.relayPort && (rest === '/http' || rest.startsWith('/http/'))) {
+        req.url = req.url.slice(relayPrefix(route).length) || '/';
+        return createHttpRelay({ name, port: entry.relayPort })(req, res);
+      }
 
-// --- MCP client ---
+      if (req.method === 'GET' && rest === '/tools') {
+        try {
+          const { tools } = await client.listTools();
+          return res.json(tools);
+        } catch (err) {
+          console.error(`[${name}] listTools error:`, err.message);
+          return res.status(500).json({ error: err.message });
+        }
+      }
 
-async function connectMcp(name, cfg) {
-  const transport = new StdioClientTransport({
-    command: cfg.command,
-    args: cfg.args ?? [],
-    env: buildChildEnv(cfg.env),
-  });
-  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;
+      const toolMatch = /^\/tools\/([^/]+)$/.exec(rest);
+      if (req.method === 'POST' && toolMatch) {
+        const toolName = decodeURIComponent(toolMatch[1]);
+        try {
+          const result = await client.callTool({ name: toolName, arguments: req.body ?? {} });
+          return res.json(result);
+        } catch (err) {
+          console.error(`[${name}] callTool(${toolName}) error:`, err.message);
+          return res.status(500).json({ error: err.message });
+        }
+      }
+    }
+    return next();
+  };
 }
 
-// --- Routes ---
-
-function registerMcpRoutes(app, route, client, name) {
-  app.get(`${route}/tools`, async (req, res) => {
-    try {
-      const { tools } = await client.listTools();
-      res.json(tools);
-    } catch (err) {
-      console.error(`[${name}] listTools error:`, err.message);
-      res.status(500).json({ error: err.message });
-    }
-  });
+function readServers(configPath) {
+  const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+  return config.mcpServers ?? {};
+}
 
-  app.post(`${route}/tools/:toolName`, async (req, res) => {
-    try {
-      const result = await client.callTool({
-        name: req.params.toolName,
-        arguments: req.body ?? {},
-      });
-      res.json(result);
-    } catch (err) {
-      console.error(`[${name}] callTool(${req.params.toolName}) error:`, err.message);
-      res.status(500).json({ error: err.message });
-    }
-  });
+/** Comparaison à temps constant du jeton d'administration présenté. */
+function adminTokenMatches(presented, expected) {
+  if (typeof presented !== 'string') return false;
+  const a = crypto.createHash('sha256').update(presented).digest();
+  const b = crypto.createHash('sha256').update(expected).digest();
+  return crypto.timingSafeEqual(a, b);
 }
 
 // --- Bootstrap ---
@@ -105,8 +108,18 @@ async function main() {
     ? path.resolve(process.env.GATEWAY_CONFIG_DIR)
     : path.join(process.cwd(), 'config');
   const configPath = path.join(configDir, 'mcp-servers.json');
-  const config = JSON.parse(readFileSync(configPath, 'utf-8'));
-  const servers = config.mcpServers ?? {};
+  const servers = readServers(configPath);
+
+  const registry = new McpRegistry({
+    onToolsLoaded: (name, tools) => {
+      for (const tool of tools) {
+        if (!tool.description) continue;
+        getOrComputeToolEmbedding(name, tool, getEmbedding).catch(err =>
+          console.error(`[gateway] Embedding error for ${name}::${tool.name}:`, err.message)
+        );
+      }
+    },
+  });
 
   const app = express();
   if (process.env.TRUST_PROXY) {
@@ -118,7 +131,41 @@ async function main() {
   // 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 jsonParser = express.json({ type: '*/*', limit: BODY_LIMIT });
+  app.use((req, res, next) => {
+    res.setHeader(REVISION_HEADER, registry.revision);
+    next();
+  });
+
+  // Rechargement de la configuration, réservé au détenteur de GATEWAY_ADMIN_TOKEN.
+  // Seuls les MCP dont la configuration a changé sont arrêtés, lancés ou relancés.
+  const ADMIN_TOKEN = process.env.GATEWAY_ADMIN_TOKEN?.trim() || null;
+  if (ADMIN_TOKEN) {
+    app.post('/admin/reload', async (req, res) => {
+      if (!adminTokenMatches(req.get('X-Gateway-Admin-Token'), ADMIN_TOKEN)) {
+        return res.status(401).json({ error: 'Unauthorized' });
+      }
+      let nextServers;
+      try {
+        nextServers = readServers(configPath);
+      } catch (err) {
+        console.error('[gateway] Reload refused, unreadable configuration:', err.message);
+        return res.status(400).json({ error: `Unreadable configuration ${configPath}: ${err.message}` });
+      }
+      const results = await registry.apply(nextServers);
+      const summary = results
+        .filter(r => r.action !== 'unchanged')
+        .map(r => `${r.name}: ${r.action}${r.ok ? '' : ' (failed)'}`);
+      console.log(`[gateway] Reload — ${summary.length ? summary.join(', ') : 'no change'}`);
+      return res.json({ revision: registry.revision, results });
+    });
+    console.log('[gateway] Admin endpoint enabled: POST /admin/reload');
+  }
+
+  // Les routes de relais HTTP transmettent leur corps en flux, sans le lire ni le borner.
+  app.use((req, res, next) =>
+    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);
@@ -183,40 +230,8 @@ async function main() {
   const dbPath = path.join(dataDir, 'embeddings', 'embeddings.db');
   initDb(dbPath);
 
-  const clients = [];
-  const registry = []; // { name, route, description, tools, exposeAtStartup }
-
-  for (const [name, cfg] of Object.entries(servers)) {
-    const route = cfg.env?.MCP_SERVER_ROUTE;
-    if (!route) {
-      console.warn(`[gateway] Skipping "${name}": no MCP_SERVER_ROUTE defined`);
-      continue;
-    }
-
-    // Directive gateway déclarée par MCP dans son bloc `env` (comme MCP_SERVER_ROUTE) :
-    // pré-expose ou non ses outils à l'agent. Absente → MCP non pré-exposé.
-    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`);
-    }
-
-    try {
-      const client = await connectMcp(name, cfg);
-      const { tools } = await client.listTools();
-      clients.push(client);
-      registry.push({ name, route, description: cfg.description ?? null, tools, client, exposeAtStartup });
-      registerMcpRoutes(app, route, client, name);
-      for (const tool of tools) {
-        if (!tool.description) continue;
-        getOrComputeToolEmbedding(name, tool, getEmbedding).catch(err =>
-          console.error(`[gateway] Embedding error for ${name}::${tool.name}:`, err.message)
-        );
-      }
-    } catch (err) {
-      console.error(`[gateway] Failed to connect "${name}":`, err.message);
-    }
-  }
+  await registry.apply(servers);
+  app.use(mcpRoutes(registry));
 
   app.get('/tools/search', searchLimiter, async (req, res) => {
     const q = req.query.q?.trim();
@@ -225,12 +240,13 @@ async function main() {
     try {
       const queryEmbedding = await getEmbedding(q);
       const results = getAllToolEmbeddings()
+        .filter(row => registry.byName(row.mcp_name)?.tools.some(t => t.name === row.tool_name))
         .map(row => ({ ...row, score: cosineSimilarity(queryEmbedding, row.embedding) }))
         .sort((a, b) => b.score - a.score)
         .slice(0, limit)
         .map(({ mcp_name, tool_name, description, score }) => ({
           mcp_name,
-          mcp_description: registry.find(r => r.name === mcp_name)?.description ?? null,
+          mcp_description: registry.byName(mcp_name)?.description ?? null,
           tool_name,
           description,
           score,
@@ -244,7 +260,7 @@ async function main() {
 
   app.get('/mcp-definitions', (req, res) => {
     res.json(
-      registry.map(({ name, route, description, tools }) => ({
+      registry.entries.map(({ name, route, description, tools }) => ({
         id: name,
         route,
         description,
@@ -257,19 +273,8 @@ async function main() {
   // `tools/list`. Exposés en HTTP pour que le bridge stdio (server.js --mcp /
   // mcp-mode.js) puisse les récupérer et les relayer à l'agent de façon transparente —
   // la config vit uniquement côté serveur, le bridge se contente de transmettre.
-  const proxyTools = buildProxyTools(registry);
-
-  const preExposed = registry.filter(r => r.exposeAtStartup);
-  if (preExposed.length) {
-    console.log(`[gateway] Pre-exposed at agent startup: ${preExposed.map(r => r.name).join(', ')} — ${proxyTools.length} tool(s) published directly in tools/list`);
-  }
-  const overlong = overlongProxyNames(proxyTools);
-  if (overlong.length) {
-    console.warn(`[gateway] WARNING: proxy tool name(s) may exceed client limits once prefixed: ${overlong.join(', ')}`);
-  }
-
   app.get('/startup-exposition', (req, res) => {
-    res.json({ proxyTools });
+    res.json({ proxyTools: registry.proxyTools, revision: registry.revision });
   });
 
   app.get('/mcps', (req, res) => {
@@ -281,14 +286,15 @@ async function main() {
       '',
       '## Serveurs',
       '',
-      ...registry.map(({ name, route, description }) =>
-        `### ${name}\n- **Route** : \`${route}\`\n- **Description** : ${description ?? 'Non renseignée'}`
+      ...registry.entries.map(({ name, route, description, relayPort }) =>
+        `### ${name}\n- **Route** : \`${route}\`\n- **Description** : ${description ?? 'Non renseignée'}` +
+        (relayPort ? `\n- **Relais HTTP** : \`${relayPrefix(route)}/*\`` : '')
       ),
     ];
     res.type('text/plain').send(lines.join('\n'));
   });
 
-  registerMcpEndpoint(app, { clients, registry, proxyTools });
+  registerMcpEndpoint(app, registry);
 
   const httpServer = app.listen(GATEWAY_PORT, GATEWAY_HOST, () => {
     console.log(`[gateway] Listening on http://${GATEWAY_HOST}:${GATEWAY_PORT}`);
@@ -301,7 +307,7 @@ async function main() {
 
   const shutdown = async () => {
     console.log('[gateway] Shutting down...');
-    await Promise.allSettled(clients.map(c => c.close()));
+    await registry.closeAll();
     process.exit(0);
   };
 
@@ -309,7 +315,7 @@ async function main() {
   process.on('SIGINT', shutdown);
 }
 
-if (!process.argv.includes('--mcp')) {
+if (!process.argv.includes('--mcp') && !process.argv.includes('--watch')) {
   main().catch(err => {
     console.error('[gateway] Fatal error:', err.message);
     process.exit(1);