@imenam/mcp-http-gateway 2.0.14 → 2.0.16

package/mcp-registry.js

@@ -0,0 +1,234 @@
+import crypto from 'crypto';
+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 };
+}
+
+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;
+}
+
+/** 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,54 +1,58 @@
-{
-  "name": "@imenam/mcp-http-gateway",
-  "version": "2.0.14",
-  "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"
-  ],
-  "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.16",
+  "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"
+  ],
+  "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"
+  }
+}