@imenam/self-register-proxy 1.0.37

package/meta-config.js

@@ -0,0 +1,336 @@
+/**
+ * MetaConfigManager - Gestion des méta-configurations pour le proxy
+ * 
+ * Permet de grouper les configurations de plusieurs MCPs en un seul profil
+ * applicable en un clic depuis le dashboard.
+ * 
+ * Persistence : meta-configs.json dans le répertoire du proxy (__dirname)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Détermine le dossier de configuration
+// Utilise PROXY_CONFIG_DIR si défini, sinon le dossier courant (__dirname)
+const configDir = process.env.PROXY_CONFIG_DIR 
+  ? path.resolve(__dirname, process.env.PROXY_CONFIG_DIR) 
+  : __dirname;
+
+// Création du dossier s'il n'existe pas
+if (!fs.existsSync(configDir)) {
+  try {
+    fs.mkdirSync(configDir, { recursive: true });
+  } catch (err) {
+    console.error(`[META-CONFIG] Erreur lors de la création du dossier ${configDir}:`, err.message);
+  }
+}
+
+const META_CONFIGS_FILE = path.join(configDir, 'meta-configs.json');
+
+const DISCOVERY_TIMEOUT = 3000; // 3s timeout per MCP
+
+/**
+ * Structure du fichier meta-configs.json :
+ * {
+ *   "metaConfigs": {
+ *     "<id>": {
+ *       "name": "string",
+ *       "description": "string",
+ *       "mappings": { "<mcpPath>": "<configId>", ... },
+ *       "createdAt": "ISO8601"
+ *     }
+ *   },
+ *   "activeMetaConfig": "<id>" | null
+ * }
+ */
+
+/**
+ * Charge les méta-configurations depuis le fichier JSON
+ * @returns {{ metaConfigs: Object, activeMetaConfig: string|null }}
+ */
+function loadMetaConfigs() {
+  try {
+    if (fs.existsSync(META_CONFIGS_FILE)) {
+      const raw = fs.readFileSync(META_CONFIGS_FILE, 'utf-8');
+      return JSON.parse(raw);
+    }
+  } catch (err) {
+    console.error('[META-CONFIG] Error loading meta-configs:', err.message);
+  }
+  return { metaConfigs: {}, activeMetaConfig: null };
+}
+
+/**
+ * Sauvegarde les méta-configurations dans le fichier JSON
+ * @param {{ metaConfigs: Object, activeMetaConfig: string|null }} data
+ */
+function saveMetaConfigs(data) {
+  try {
+    fs.writeFileSync(META_CONFIGS_FILE, JSON.stringify(data, null, 2), 'utf-8');
+  } catch (err) {
+    console.error('[META-CONFIG] Error saving meta-configs:', err.message);
+    throw err;
+  }
+}
+
+/**
+ * Retourne toutes les méta-configurations
+ * @returns {{ metaConfigs: Object, activeMetaConfig: string|null }}
+ */
+function getAll() {
+  return loadMetaConfigs();
+}
+
+/**
+ * Retourne une méta-configuration par son ID
+ * @param {string} id
+ * @returns {Object|null}
+ */
+function getById(id) {
+  const data = loadMetaConfigs();
+  return data.metaConfigs[id] || null;
+}
+
+/**
+ * Crée une nouvelle méta-configuration
+ * @param {string} id - Identifiant unique (slug)
+ * @param {string} name - Nom affiché
+ * @param {string} description - Description
+ * @param {Object} mappings - { mcpPath: configId, ... }
+ * @returns {Object} La méta-configuration créée
+ */
+function create(id, name, description, mappings) {
+  const data = loadMetaConfigs();
+
+  if (data.metaConfigs[id]) {
+    throw new Error(`Meta-config "${id}" already exists`);
+  }
+
+  data.metaConfigs[id] = {
+    name,
+    description: description || '',
+    mappings: mappings || {},
+    createdAt: new Date().toISOString()
+  };
+
+  saveMetaConfigs(data);
+  return data.metaConfigs[id];
+}
+
+/**
+ * Met à jour partiellement une méta-configuration
+ * @param {string} id
+ * @param {Object} updates - Champs à mettre à jour (name, description, mappings)
+ * @returns {Object} La méta-configuration mise à jour
+ */
+function update(id, updates) {
+  const data = loadMetaConfigs();
+
+  if (!data.metaConfigs[id]) {
+    throw new Error(`Meta-config "${id}" not found`);
+  }
+
+  const config = data.metaConfigs[id];
+  if (updates.name !== undefined) config.name = updates.name;
+  if (updates.description !== undefined) config.description = updates.description;
+  if (updates.mappings !== undefined) config.mappings = updates.mappings;
+
+  saveMetaConfigs(data);
+  return config;
+}
+
+/**
+ * Supprime une méta-configuration
+ * @param {string} id
+ */
+function remove(id) {
+  const data = loadMetaConfigs();
+
+  if (!data.metaConfigs[id]) {
+    throw new Error(`Meta-config "${id}" not found`);
+  }
+
+  delete data.metaConfigs[id];
+
+  if (data.activeMetaConfig === id) {
+    data.activeMetaConfig = null;
+  }
+
+  saveMetaConfigs(data);
+}
+
+/**
+ * Définit la méta-configuration active
+ * @param {string|null} id
+ */
+function setActive(id) {
+  const data = loadMetaConfigs();
+
+  if (id !== null && !data.metaConfigs[id]) {
+    throw new Error(`Meta-config "${id}" not found`);
+  }
+
+  data.activeMetaConfig = id;
+  saveMetaConfigs(data);
+}
+
+/**
+ * Retourne l'ID de la méta-configuration active
+ * @returns {string|null}
+ */
+function getActive() {
+  const data = loadMetaConfigs();
+  return data.activeMetaConfig;
+}
+
+/**
+ * Découvre les configurations disponibles auprès de tous les MCPs enregistrés
+ * Interroge GET /api/configurations sur chaque MCP via son target direct
+ * 
+ * @param {Map} routes - Le registry.routes du proxy
+ * @returns {Promise<Array<{ path: string, name: string, configurations: Array|null, error: string|null }>>}
+ */
+async function discoverConfigurations(routes) {
+  const results = [];
+
+  const promises = [];
+  for (const [mcpPath, route] of routes.entries()) {
+    const target = route.target || 'http://localhost';
+    const url = `${target}:${route.port}/api/configurations`;
+
+    promises.push(
+      (async () => {
+        try {
+          const controller = new AbortController();
+          const timeoutId = setTimeout(() => controller.abort(), DISCOVERY_TIMEOUT);
+
+          const response = await fetch(url, {
+            method: 'GET',
+            signal: controller.signal
+          });
+
+          clearTimeout(timeoutId);
+
+          if (response.status === 200) {
+            const data = await response.json();
+            return {
+              path: mcpPath,
+              name: route.name,
+              configurations: data.configurations || [],
+              error: null
+            };
+          }
+
+          return {
+            path: mcpPath,
+            name: route.name,
+            configurations: null,
+            error: `HTTP ${response.status}`
+          };
+        } catch (err) {
+          return {
+            path: mcpPath,
+            name: route.name,
+            configurations: null,
+            error: err.name === 'AbortError' ? 'timeout' : err.message
+          };
+        }
+      })()
+    );
+  }
+
+  const settled = await Promise.all(promises);
+  results.push(...settled);
+
+  return results;
+}
+
+/**
+ * Applique une méta-configuration : envoie POST /api/configurations/apply à chaque MCP
+ * 
+ * @param {string} metaConfigId - ID de la méta-configuration à appliquer
+ * @param {Map} routes - Le registry.routes du proxy
+ * @returns {Promise<{ success: boolean, results: Array<{ path: string, success: boolean, error?: string }> }>}
+ */
+async function applyMetaConfig(metaConfigId, routes) {
+  const config = getById(metaConfigId);
+  if (!config) {
+    throw new Error(`Meta-config "${metaConfigId}" not found`);
+  }
+
+  const missingResults = [];
+  const promises = [];
+
+  for (const [mcpPath, configId] of Object.entries(config.mappings)) {
+    const route = routes.get(mcpPath);
+    if (!route) {
+      missingResults.push({
+        path: mcpPath,
+        success: false,
+        error: 'MCP not registered'
+      });
+      continue;
+    }
+
+    const target = route.target || 'http://localhost';
+    const url = `${target}:${route.port}/api/configurations/apply`;
+
+    promises.push(
+      (async () => {
+        try {
+          const controller = new AbortController();
+          const timeoutId = setTimeout(() => controller.abort(), DISCOVERY_TIMEOUT);
+
+          const response = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ configId }),
+            signal: controller.signal
+          });
+
+          clearTimeout(timeoutId);
+
+          if (response.ok) {
+            const data = await response.json();
+            return { path: mcpPath, success: true, appliedConfig: data.appliedConfig || configId };
+          }
+
+          const errorData = await response.json().catch(() => ({}));
+          return { path: mcpPath, success: false, error: errorData.error || `HTTP ${response.status}` };
+        } catch (err) {
+          return {
+            path: mcpPath,
+            success: false,
+            error: err.name === 'AbortError' ? 'timeout' : err.message
+          };
+        }
+      })()
+    );
+  }
+
+  const settled = await Promise.all(promises);
+
+  const allAppliedSuccess = settled.length === 0 || settled.every(r => r.success);
+
+  if (allAppliedSuccess) {
+    setActive(metaConfigId);
+  }
+
+  return {
+    success: allAppliedSuccess,
+    warnings: missingResults,
+    results: [...missingResults, ...settled]
+  };
+}
+
+module.exports = {
+  getAll,
+  getById,
+  create,
+  update,
+  remove,
+  setActive,
+  getActive,
+  discoverConfigurations,
+  applyMetaConfig
+};

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@imenam/self-register-proxy",
+  "version": "1.0.37",
+  "description": "Dynamic reverse proxy with self-registration API - applications can register themselves and receive an automatically assigned port",
+  "main": "proxy-client.js",
+  "bin": {
+    "self-register-proxy": "proxy.js",
+    "dynamic-proxy": "proxy.js"
+  },
+  "exports": {
+    ".": "./proxy-client.js",
+    "./client": "./proxy-client.js",
+    "./server": "./proxy.js"
+  },
+  "files": [
+    "proxy.js",
+    "proxy-client.js",
+    "logger.js",
+    "config.js",
+    "meta-config.js",
+    "terminal-server.js",
+    "services",
+    "routes",
+    "views",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "start": "node proxy.js",
+    "example": "node example-app.js",
+    "release": "npm version patch && npm publish --access public && git push origin main --follow-tags"
+  },
+  "keywords": [
+    "proxy",
+    "reverse-proxy",
+    "dynamic-proxy",
+    "self-register-proxy",
+    "self-register",
+    "auto-register",
+    "microservices",
+    "docker",
+    "gateway",
+    "api-gateway",
+    "load-balancer",
+    "http-proxy",
+    "express"
+  ],
+  "author": "Matthieu Pesnot-Pin",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Matthieu-Pesnot-Pin/dynamic-self-register-proxy.git"
+  },
+  "homepage": "https://github.com/Matthieu-Pesnot-Pin/dynamic-self-register-proxy#readme",
+  "bugs": {
+    "url": "https://github.com/Matthieu-Pesnot-Pin/dynamic-self-register-proxy/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "dotenv": "^17.2.3",
+    "express": "^5.2.1",
+    "express-rate-limit": "^8.2.1",
+    "helmet": "^8.1.0",
+    "http-proxy-middleware": "^3.0.5",
+    "node-pty": "^1.1.0",
+    "ws": "^8.19.0"
+  }
+}

package/proxy-client.js

@@ -0,0 +1,203 @@
+/**
+ * ProxyClient - Helper pour s'enregistrer auprès du Dynamic Proxy
+ * 
+ * Usage:
+ *   const ProxyClient = require('./proxy-client');
+ *   const proxy = new ProxyClient('http://localhost:3000');
+ *   const { port } = await proxy.register('/myapp', 'My App');
+ *   app.listen(port);
+ */
+
+// New comment to test the freshness
+
+class ProxyClient {
+  /**
+   * @param {string} proxyUrl - URL du proxy (ex: 'http://localhost:3000')
+   */
+  constructor(proxyUrl = 'http://localhost:3000') {
+    this.proxyUrl = proxyUrl;
+    this.registeredPath = null;
+    this.assignedPort = null;
+  }
+
+  /**
+   * Enregistre une route auprès du proxy (attribution automatique du port)
+   * @param {string} path - Chemin URL (ex: '/myapp')
+   * @param {string} [name] - Nom de l'application
+   * @returns {Promise<{success: boolean, path: string, port: number, name: string}>}
+   */
+  async register(path, name) {
+    const body = { path, name };
+    // Port is automatically assigned by the proxy
+
+    const response = await fetch(`${this.proxyUrl}/proxy/register`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body)
+    });
+
+    const data = await response.json();
+
+    if (!response.ok) {
+      throw new Error(data.error || 'Registration failed');
+    }
+
+    this.registeredPath = data.path;
+    this.assignedPort = data.port;
+
+    return data;
+  }
+
+  /**
+   * Supprime l'enregistrement de cette application
+   * @returns {Promise<{success: boolean, path: string, freedPort: number}>}
+   */
+  async unregister() {
+    if (!this.registeredPath) {
+      return { success: false, error: 'Not registered' };
+    }
+
+    try {
+      const response = await fetch(`${this.proxyUrl}/proxy/unregister`, {
+        method: 'DELETE',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ path: this.registeredPath })
+      });
+
+      const data = await response.json();
+      
+      if (response.ok) {
+        this.registeredPath = null;
+        this.assignedPort = null;
+      }
+
+      return data;
+    } catch (error) {
+      console.error('Unregister error:', error.message);
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Liste toutes les routes enregistrées
+   * @returns {Promise<{count: number, routes: Array, availablePorts: number}>}
+   */
+  async listRoutes() {
+    const response = await fetch(`${this.proxyUrl}/proxy/routes`);
+    return response.json();
+  }
+
+  /**
+   * Vérifie l'état du proxy
+   * @returns {Promise<{status: string, uptime: number, registeredRoutes: number}>}
+   */
+  async health() {
+    const response = await fetch(`${this.proxyUrl}/proxy/health`);
+    return response.json();
+  }
+
+  /**
+   * Configure les handlers pour un arrêt propre
+   * @param {http.Server} server - Instance du serveur HTTP/Express
+   */
+  setupGracefulShutdown(server) {
+    const shutdown = async () => {
+      console.log('Shutting down...');
+      await this.unregister();
+      server.close(() => {
+        console.log('Server closed.');
+        process.exit(0);
+      });
+    };
+
+    process.on('SIGTERM', shutdown);
+    process.on('SIGINT', shutdown);
+  }
+
+  /**
+   * Ajoute la route /proxy/health requise par le proxy pour le health check polling
+   * @param {express.Application} app - Instance de l'application Express
+   * @param {object} [options] - Options de configuration
+   * @param {function} [options.healthCheck] - Fonction personnalisée pour vérifier la santé (doit retourner true/false)
+   */
+  setupHealthRoute(app, options = {}) {
+    app.get('/proxy/health', async (req, res) => {
+      try {
+        // Si une fonction de health check personnalisée est fournie
+        if (options.healthCheck) {
+          const isHealthy = await options.healthCheck();
+          if (isHealthy) {
+            return res.status(200).json({ status: 'healthy' });
+          } else {
+            return res.status(503).json({ status: 'unhealthy' });
+          }
+        }
+        
+        // Par défaut, retourne 200 si le serveur répond
+        res.status(200).json({ status: 'healthy' });
+      } catch (error) {
+        res.status(503).json({ status: 'unhealthy', error: error.message });
+      }
+    });
+  }
+
+  /**
+   * Ajoute les routes de configuration requises pour la fonctionnalité Meta-Config du proxy.
+   * 
+   * Expose deux endpoints sur l'application Express du MCP :
+   *   - GET  /api/configurations       → liste les profils de configuration disponibles
+   *   - POST /api/configurations/apply  → applique un profil par son ID
+   * 
+   * @param {express.Application} app - Instance de l'application Express du MCP
+   * @param {object} provider - Fournisseur de configurations
+   * @param {function} provider.getConfigurations - Async function retournant un tableau de configurations
+   *   Chaque configuration doit avoir : { id: string, name: string, description?: string, active?: boolean }
+   * @param {function} provider.applyConfiguration - Async function(configId) qui applique la configuration
+   *   Doit throw en cas d'erreur, ou retourner normalement en cas de succès
+   * 
+   * @example
+   *   proxy.setupConfigurationsRoute(app, {
+   *     getConfigurations: async () => [
+   *       { id: 'default', name: 'Default', description: 'Standard settings', active: true },
+   *       { id: 'production', name: 'Production', description: 'Optimized for prod' }
+   *     ],
+   *     applyConfiguration: async (configId) => {
+   *       // Appliquer la configuration identifiée par configId
+   *       await switchToConfig(configId);
+   *     }
+   *   });
+   */
+  setupConfigurationsRoute(app, provider) {
+    if (!provider || typeof provider.getConfigurations !== 'function' || typeof provider.applyConfiguration !== 'function') {
+      throw new Error('setupConfigurationsRoute requires a provider with getConfigurations() and applyConfiguration(configId) methods');
+    }
+
+    app.get('/api/configurations', async (req, res) => {
+      try {
+        const configurations = await provider.getConfigurations();
+        res.json({ configurations });
+      } catch (error) {
+        console.error('[CONFIGURATIONS] Error listing configurations:', error.message);
+        res.status(500).json({ error: error.message });
+      }
+    });
+
+    app.post('/api/configurations/apply', async (req, res) => {
+      const { configId } = req.body;
+
+      if (!configId) {
+        return res.status(400).json({ success: false, error: 'configId is required' });
+      }
+
+      try {
+        await provider.applyConfiguration(configId);
+        res.json({ success: true, appliedConfig: configId });
+      } catch (error) {
+        console.error('[CONFIGURATIONS] Error applying configuration:', error.message);
+        res.status(500).json({ success: false, error: error.message });
+      }
+    });
+  }
+}
+
+module.exports = ProxyClient;