dynamic-self-register-proxy 1.0.0

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2026
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,371 @@
+# Dynamic Self-Register Proxy
+
+[![npm version](https://badge.fury.io/js/dynamic-self-register-proxy.svg)](https://www.npmjs.com/package/dynamic-self-register-proxy)
+[![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](https://opensource.org/licenses/ISC)
+
+Un reverse proxy Node.js avec API d'auto-enregistrement, permettant à vos applications de s'enregistrer dynamiquement et de recevoir un port automatiquement attribué.
+
+## Cas d'usage
+
+- **Conteneur Docker unique** exposant un seul port vers l'extérieur
+- **Microservices dynamiques** qui démarrent/s'arrêtent sans configuration manuelle
+- **Environnement de développement** avec plusieurs applications Node.js
+
+## Installation
+
+```bash
+npm install dynamic-self-register-proxy
+```
+
+Ou pour une installation globale :
+
+```bash
+npm install -g dynamic-self-register-proxy
+```
+
+## Démarrage rapide
+
+### 1. Démarrer le proxy
+
+```bash
+# Via npx (sans installation globale)
+npx dynamic-self-register-proxy
+
+# Ou si installé globalement
+dynamic-proxy
+
+# Ou via npm script (développement local)
+npm start
+```
+
+Le proxy démarre par défaut sur le port `3000`. Pour changer le port :
+
+```bash
+# Windows PowerShell
+$env:PROXY_PORT="3002"; npx dynamic-self-register-proxy
+
+# Linux/Mac
+PROXY_PORT=3002 npx dynamic-self-register-proxy
+```
+
+### 2. Enregistrer une application
+
+Votre application doit s'enregistrer au démarrage :
+
+```javascript
+const response = await fetch('http://localhost:3000/proxy/register', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({
+    path: '/myapp',      // Chemin d'accès via le proxy
+    name: 'My App'       // Nom de l'application (optionnel)
+  })
+});
+
+const { port } = await response.json();
+// port = 4000 (attribué automatiquement)
+
+// Démarrez votre serveur sur ce port
+app.listen(port);
+```
+
+### 3. Accéder à votre application
+
+```
+http://localhost:3000/myapp/  →  votre application sur le port 4000
+```
+
+## API du Proxy
+
+| Endpoint | Méthode | Description |
+|----------|---------|-------------|
+| `/proxy/register` | POST | Enregistre une nouvelle route |
+| `/proxy/unregister` | DELETE | Supprime une route |
+| `/proxy/routes` | GET | Liste toutes les routes |
+| `/proxy/health` | GET | Health check du proxy |
+
+### POST /proxy/register
+
+Enregistre une nouvelle route et attribue un port.
+
+**Request:**
+```json
+{
+  "path": "/myapp",
+  "name": "My Application",
+  "port": 4005
+}
+```
+
+| Champ | Type | Requis | Description |
+|-------|------|--------|-------------|
+| `path` | string | ✅ | Chemin URL pour accéder à l'app |
+| `name` | string | ❌ | Nom descriptif |
+| `port` | number | ❌ | Port spécifique (sinon auto-attribué) |
+
+**Response (201):**
+```json
+{
+  "success": true,
+  "path": "/myapp",
+  "port": 4000,
+  "name": "My Application",
+  "message": "Route registered. Start your server on port 4000"
+}
+```
+
+**Erreurs:**
+- `400` - Path manquant
+- `409` - Path ou port déjà utilisé
+
+### DELETE /proxy/unregister
+
+Supprime une route enregistrée.
+
+**Request:**
+```json
+{
+  "path": "/myapp"
+}
+```
+
+**Response (200):**
+```json
+{
+  "success": true,
+  "path": "/myapp",
+  "freedPort": 4000
+}
+```
+
+### GET /proxy/routes
+
+Liste toutes les routes enregistrées.
+
+**Response:**
+```json
+{
+  "count": 2,
+  "routes": [
+    {
+      "path": "/api",
+      "port": 4000,
+      "name": "API Server",
+      "registeredAt": "2026-01-27T10:00:00.000Z",
+      "target": "http://localhost:4000"
+    },
+    {
+      "path": "/web",
+      "port": 4001,
+      "name": "Web App",
+      "registeredAt": "2026-01-27T10:01:00.000Z",
+      "target": "http://localhost:4001"
+    }
+  ],
+  "availablePorts": 998
+}
+```
+
+### GET /proxy/health
+
+Vérifie l'état du proxy.
+
+**Response:**
+```json
+{
+  "status": "healthy",
+  "uptime": 3600,
+  "registeredRoutes": 2,
+  "usedPorts": 2
+}
+```
+
+## Intégration dans votre application
+
+### Exemple complet avec Express
+
+```javascript
+const express = require('express');
+
+const PROXY_URL = process.env.PROXY_URL || 'http://localhost:3000';
+const APP_PATH = process.env.APP_PATH || '/myapp';
+const APP_NAME = process.env.APP_NAME || 'My App';
+
+async function start() {
+  // 1. S'enregistrer auprès du proxy
+  const res = await fetch(`${PROXY_URL}/proxy/register`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ path: APP_PATH, name: APP_NAME })
+  });
+  
+  const { port } = await res.json();
+  
+  // 2. Créer l'application
+  const app = express();
+  
+  app.get('/', (req, res) => {
+    res.json({ message: 'Hello!' });
+  });
+  
+  // 3. Démarrer sur le port attribué
+  const server = app.listen(port, () => {
+    console.log(`App accessible via ${PROXY_URL}${APP_PATH}`);
+  });
+  
+  // 4. Se désenregistrer à l'arrêt
+  process.on('SIGTERM', async () => {
+    await fetch(`${PROXY_URL}/proxy/unregister`, {
+      method: 'DELETE',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ path: APP_PATH })
+    });
+    server.close();
+  });
+}
+
+start();
+```
+
+### Utilisation du ProxyClient
+
+Le package inclut un client helper pour faciliter l'enregistrement :
+
+```javascript
+const ProxyClient = require('dynamic-self-register-proxy');
+
+const proxy = new ProxyClient('http://localhost:3000');
+const { port } = await proxy.register('/myapp', 'My App');
+
+app.listen(port);
+
+// Arrêt propre automatique
+proxy.setupGracefulShutdown(server);
+```
+
+Méthodes disponibles :
+
+- `register(path, name, port?)` - Enregistre une route
+- `unregister()` - Supprime l'enregistrement
+- `listRoutes()` - Liste toutes les routes
+- `health()` - Vérifie l'état du proxy
+- `setupGracefulShutdown(server)` - Configure l'arrêt propre
+- `setupHealthRoute(app, options?)` - Ajoute la route de health check
+
+## Docker
+
+### Build et lancement
+
+```bash
+# Build
+npm run docker:build
+
+# Démarrer (proxy + 2 apps exemples)
+npm run docker:up
+
+# Arrêter
+npm run docker:down
+```
+
+### Accès
+
+- Proxy : `http://localhost:8081`
+- App 1 : `http://localhost:8081/app1`
+- App 2 : `http://localhost:8081/app2`
+- Routes : `http://localhost:8081/proxy/routes`
+
+### Ajouter votre propre service
+
+Dans `docker-compose.yml` :
+
+```yaml
+services:
+  my-service:
+    build: ./my-service
+    environment:
+      - PROXY_URL=http://proxy:3000
+      - APP_PATH=/my-service
+      - APP_NAME=My Service
+    depends_on:
+      - proxy
+    networks:
+      - proxy-network
+```
+
+## Health Check Polling
+
+Le proxy vérifie périodiquement que les serveurs enregistrés sont toujours actifs. Si un serveur ne répond pas correctement, il est automatiquement désenregistré.
+
+### Implémentation requise
+
+Chaque application enregistrée **doit** implémenter la route `GET /proxy/health` qui retourne un code **200** :
+
+```javascript
+// Avec Express
+app.get('/proxy/health', (req, res) => {
+  res.status(200).json({ status: 'healthy' });
+});
+```
+
+### Avec ProxyClient
+
+Le helper `ProxyClient` fournit une méthode pour ajouter automatiquement cette route :
+
+```javascript
+const ProxyClient = require('dynamic-self-register-proxy');
+
+const proxy = new ProxyClient('http://localhost:3000');
+const app = express();
+
+// Ajoute automatiquement GET /proxy/health
+proxy.setupHealthRoute(app);
+
+// Ou avec un health check personnalisé
+proxy.setupHealthRoute(app, {
+  healthCheck: async () => {
+    // Vérifier la connexion à la DB, etc.
+    const dbOk = await checkDatabase();
+    return dbOk;
+  }
+});
+```
+
+### Comportement
+
+- Le proxy vérifie tous les serveurs toutes les **30 secondes** (par défaut)
+- Timeout de **5 secondes** par requête de health check
+- Si la réponse n'est pas un code **200**, le serveur est automatiquement désenregistré
+- Les erreurs de connexion (serveur arrêté, timeout) entraînent aussi le désenregistrement
+
+## Configuration
+
+| Variable | Défaut | Description |
+|----------|--------|-------------|
+| `PROXY_PORT` | `3000` | Port d'écoute du proxy |
+| `HEALTH_CHECK_INTERVAL` | `30000` | Intervalle du health check polling (ms) |
+| `HEALTH_CHECK_TIMEOUT` | `5000` | Timeout pour chaque health check (ms) |
+| `PROXY_URL` | `http://localhost:3000` | URL du proxy (pour les apps) |
+| `APP_PATH` | `/example` | Chemin de l'application |
+| `APP_NAME` | `Example App` | Nom de l'application |
+
+## Plage de ports
+
+Par défaut, le proxy attribue des ports entre **4000** et **5000** (1000 ports disponibles).
+
+Pour modifier cette plage, éditez `proxy.js` :
+
+```javascript
+const INTERNAL_PORT_START = 4000;
+const INTERNAL_PORT_END = 5000;
+```
+
+## Limitations
+
+- Les routes sont stockées en mémoire (perdues au redémarrage du proxy)
+- Pas de persistance des enregistrements
+- Pas d'authentification sur l'API de registration
+- Les applications doivent implémenter `GET /proxy/health` pour ne pas être désenregistrées automatiquement
+
+## Licence
+
+ISC

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "dynamic-self-register-proxy",
+  "version": "1.0.0",
+  "description": "Dynamic reverse proxy with self-registration API - applications can register themselves and receive an automatically assigned port",
+  "main": "proxy-client.js",
+  "bin": {
+    "dynamic-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",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "start": "node proxy.js",
+    "example": "node example-app.js"
+  },
+  "keywords": [
+    "proxy",
+    "reverse-proxy",
+    "dynamic-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-music/dynamic-self-register-proxy.git"
+  },
+  "homepage": "https://github.com/matthieu-music/dynamic-self-register-proxy#readme",
+  "bugs": {
+    "url": "https://github.com/matthieu-music/dynamic-self-register-proxy/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "express": "^5.2.1",
+    "http-proxy-middleware": "^3.0.5"
+  }
+}

package/proxy-client.js

@@ -0,0 +1,144 @@
+/**
+ * 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);
+ */
+
+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
+   * @param {string} path - Chemin URL (ex: '/myapp')
+   * @param {string} [name] - Nom de l'application
+   * @param {number} [port] - Port spécifique (optionnel, sinon auto-attribué)
+   * @returns {Promise<{success: boolean, path: string, port: number, name: string}>}
+   */
+  async register(path, name, port) {
+    const body = { path, name };
+    if (port) body.port = port;
+
+    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 });
+      }
+    });
+  }
+}
+
+module.exports = ProxyClient;

package/proxy.js

@@ -0,0 +1,415 @@
+#!/usr/bin/env node
+
+const express = require('express');
+const { createProxyMiddleware } = require('http-proxy-middleware');
+
+const app = express();
+app.use(express.json());
+
+// ============================================
+// CONFIGURATION
+// ============================================
+const PROXY_PORT = process.env.PROXY_PORT || 3005;
+const INTERNAL_PORT_START = 4000;
+const INTERNAL_PORT_END = 5000;
+const HEALTH_CHECK_INTERVAL = process.env.HEALTH_CHECK_INTERVAL || 30000; // 30 secondes par défaut
+const HEALTH_CHECK_TIMEOUT = process.env.HEALTH_CHECK_TIMEOUT || 5000; // 5 secondes timeout
+
+// ============================================
+// REGISTRY - Stockage des routes en mémoire
+// ============================================
+const registry = {
+  routes: new Map(),      // path -> { port, name, registeredAt }
+  usedPorts: new Set(),   // Ports déjà attribués
+  nextPort: INTERNAL_PORT_START
+};
+
+/**
+ * Trouve le prochain port disponible
+ */
+function getNextAvailablePort() {
+  while (registry.usedPorts.has(registry.nextPort)) {
+    registry.nextPort++;
+    if (registry.nextPort > INTERNAL_PORT_END) {
+      registry.nextPort = INTERNAL_PORT_START;
+      // Vérifie si tous les ports sont utilisés
+      if (registry.usedPorts.size >= (INTERNAL_PORT_END - INTERNAL_PORT_START)) {
+        throw new Error('No available ports');
+      }
+    }
+  }
+  const port = registry.nextPort;
+  registry.nextPort++;
+  return port;
+}
+
+/**
+ * Trouve la route correspondant à un chemin de requête
+ */
+function findRouteForPath(requestPath) {
+  // Tri des routes par longueur décroissante pour matcher le plus spécifique d'abord
+  const sortedPaths = [...registry.routes.keys()].sort((a, b) => b.length - a.length);
+  
+  for (const routePath of sortedPaths) {
+    if (requestPath.startsWith(routePath)) {
+      return registry.routes.get(routePath);
+    }
+  }
+  return null;
+}
+
+// ============================================
+// HEALTH CHECK POLLING
+// ============================================
+
+/**
+ * Vérifie la santé d'un serveur enregistré
+ * @param {string} path - Le chemin enregistré
+ * @param {object} route - Les informations de la route
+ * @returns {Promise<boolean>} - true si le serveur est en bonne santé
+ */
+async function checkServerHealth(path, route) {
+  const healthUrl = `http://localhost:${route.port}/proxy/health`;
+  
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), HEALTH_CHECK_TIMEOUT);
+    
+    const response = await fetch(healthUrl, {
+      method: 'GET',
+      signal: controller.signal
+    });
+    
+    clearTimeout(timeoutId);
+    
+    return response.status === 200;
+  } catch (error) {
+    // Timeout, connexion refusée, ou autre erreur
+    return false;
+  }
+}
+
+/**
+ * Désenregistre un serveur (utilisé par le health check)
+ * @param {string} path - Le chemin à désenregistrer
+ */
+function unregisterServer(path) {
+  const route = registry.routes.get(path);
+  if (route) {
+    registry.routes.delete(path);
+    registry.usedPorts.delete(route.port);
+    console.log(`[HEALTH CHECK] Unregistered ${path} (was on port ${route.port}) - server unhealthy`);
+  }
+}
+
+/**
+ * Effectue un health check sur tous les serveurs enregistrés
+ */
+async function performHealthChecks() {
+  if (registry.routes.size === 0) {
+    return;
+  }
+  
+  console.log(`[HEALTH CHECK] Checking ${registry.routes.size} registered server(s)...`);
+  
+  const checks = [];
+  
+  for (const [path, route] of registry.routes.entries()) {
+    checks.push(
+      checkServerHealth(path, route).then(isHealthy => ({
+        path,
+        route,
+        isHealthy
+      }))
+    );
+  }
+  
+  const results = await Promise.all(checks);
+  
+  for (const { path, isHealthy } of results) {
+    if (!isHealthy) {
+      unregisterServer(path);
+    }
+  }
+  
+  const healthyCount = results.filter(r => r.isHealthy).length;
+  const unhealthyCount = results.length - healthyCount;
+  
+  if (unhealthyCount > 0) {
+    console.log(`[HEALTH CHECK] Complete: ${healthyCount} healthy, ${unhealthyCount} removed`);
+  }
+}
+
+/**
+ * Démarre le polling de health check
+ */
+function startHealthCheckPolling() {
+  console.log(`[HEALTH CHECK] Starting polling every ${HEALTH_CHECK_INTERVAL}ms`);
+  setInterval(performHealthChecks, HEALTH_CHECK_INTERVAL);
+}
+
+// ============================================
+// API D'ENREGISTREMENT
+// ============================================
+
+/**
+ * POST /proxy/register
+ * Enregistre une nouvelle route
+ * Body: { path: "/myapp", name: "My Application", port?: 4001 }
+ * Response: { success: true, path: "/myapp", port: 4001 }
+ */
+app.post('/proxy/register', (req, res) => {
+  try {
+    const { path, name, port: requestedPort } = req.body;
+
+    if (!path) {
+      return res.status(400).json({ 
+        success: false, 
+        error: 'Path is required' 
+      });
+    }
+
+    // Normalise le path (doit commencer par /)
+    const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+
+    // Vérifie si le path existe déjà
+    if (registry.routes.has(normalizedPath)) {
+      const existing = registry.routes.get(normalizedPath);
+      return res.status(409).json({ 
+        success: false, 
+        error: 'Path already registered',
+        existing: {
+          path: normalizedPath,
+          port: existing.port,
+          name: existing.name
+        }
+      });
+    }
+
+    // Attribution du port
+    let port;
+    if (requestedPort) {
+      // Port spécifique demandé
+      if (registry.usedPorts.has(requestedPort)) {
+        return res.status(409).json({ 
+          success: false, 
+          error: `Port ${requestedPort} already in use` 
+        });
+      }
+      port = requestedPort;
+    } else {
+      // Attribution automatique
+      port = getNextAvailablePort();
+    }
+
+    // Enregistrement
+    registry.routes.set(normalizedPath, {
+      port,
+      name: name || normalizedPath,
+      registeredAt: new Date().toISOString()
+    });
+    registry.usedPorts.add(port);
+
+    console.log(`[REGISTER] ${normalizedPath} -> localhost:${port} (${name || 'unnamed'})`);
+
+    res.json({
+      success: true,
+      path: normalizedPath,
+      port,
+      name: name || normalizedPath,
+      message: `Route registered. Start your server on port ${port}`
+    });
+
+  } catch (error) {
+    console.error('[REGISTER ERROR]', error.message);
+    res.status(500).json({ 
+      success: false, 
+      error: error.message 
+    });
+  }
+});
+
+/**
+ * DELETE /proxy/unregister
+ * Supprime une route
+ * Body: { path: "/myapp" }
+ */
+app.delete('/proxy/unregister', (req, res) => {
+  try {
+    const { path } = req.body;
+
+    if (!path) {
+      return res.status(400).json({ 
+        success: false, 
+        error: 'Path is required' 
+      });
+    }
+
+    const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+
+    if (!registry.routes.has(normalizedPath)) {
+      return res.status(404).json({ 
+        success: false, 
+        error: 'Path not found' 
+      });
+    }
+
+    const route = registry.routes.get(normalizedPath);
+    registry.routes.delete(normalizedPath);
+    registry.usedPorts.delete(route.port);
+
+    console.log(`[UNREGISTER] ${normalizedPath} (was on port ${route.port})`);
+
+    res.json({
+      success: true,
+      path: normalizedPath,
+      freedPort: route.port
+    });
+
+  } catch (error) {
+    console.error('[UNREGISTER ERROR]', error.message);
+    res.status(500).json({ 
+      success: false, 
+      error: error.message 
+    });
+  }
+});
+
+/**
+ * GET /proxy/routes
+ * Liste toutes les routes enregistrées
+ */
+app.get('/proxy/routes', (req, res) => {
+  const routes = [];
+  registry.routes.forEach((value, path) => {
+    routes.push({
+      path,
+      port: value.port,
+      name: value.name,
+      registeredAt: value.registeredAt,
+      target: `http://localhost:${value.port}`
+    });
+  });
+
+  res.json({
+    count: routes.length,
+    routes,
+    availablePorts: (INTERNAL_PORT_END - INTERNAL_PORT_START) - registry.usedPorts.size
+  });
+});
+
+/**
+ * GET /proxy/health
+ * Health check du proxy
+ */
+app.get('/proxy/health', (req, res) => {
+  res.json({
+    status: 'healthy',
+    uptime: process.uptime(),
+    registeredRoutes: registry.routes.size,
+    usedPorts: registry.usedPorts.size
+  });
+});
+
+// ============================================
+// PROXY MIDDLEWARE
+// ============================================
+
+/**
+ * Router dynamique - détermine la cible en fonction de la requête
+ */
+const dynamicRouter = (req) => {
+  const route = findRouteForPath(req.path);
+  if (route) {
+    return `http://localhost:${route.port}`;
+  }
+  return null;
+};
+
+/**
+ * Middleware de proxy pour toutes les autres requêtes
+ */
+app.use((req, res, next) => {
+  // Ignore les routes de l'API proxy
+  if (req.path.startsWith('/proxy/')) {
+    return next();
+  }
+
+  const target = dynamicRouter(req);
+  
+  if (!target) {
+    return res.status(404).json({
+      error: 'No route registered for this path',
+      path: req.path,
+      hint: 'Register a route with POST /proxy/register'
+    });
+  }
+
+  // Trouve le path de la route pour le pathRewrite
+  const route = findRouteForPath(req.path);
+  const routePath = [...registry.routes.entries()]
+    .find(([, v]) => v === route)?.[0];
+
+  const proxyMiddleware = createProxyMiddleware({
+    target,
+    changeOrigin: true,
+    pathRewrite: (path) => {
+      // Retire le préfixe de la route du path
+      if (routePath && path.startsWith(routePath)) {
+        const newPath = path.slice(routePath.length) || '/';
+        return newPath;
+      }
+      return path;
+    },
+    on: {
+      proxyReq: (proxyReq, req) => {
+        // Ré-écriture du body si présent (nécessaire car express.json() a consommé le stream)
+        if (req.body && Object.keys(req.body).length > 0) {
+          const bodyData = JSON.stringify(req.body);
+          proxyReq.setHeader('Content-Type', 'application/json');
+          proxyReq.setHeader('Content-Length', Buffer.byteLength(bodyData));
+          proxyReq.write(bodyData);
+        }
+        console.log(`[PROXY] ${req.method} ${req.path} -> ${target}`);
+      },
+      error: (err, req, res) => {
+        console.error(`[PROXY ERROR] ${req.path}:`, err.message);
+        res.status(502).json({
+          error: 'Proxy error',
+          message: err.message,
+          target
+        });
+      }
+    }
+  });
+
+  proxyMiddleware(req, res, next);
+});
+
+// ============================================
+// DÉMARRAGE DU SERVEUR
+// ============================================
+
+app.listen(PROXY_PORT, () => {
+  console.log('='.repeat(50));
+  console.log('🚀 Dynamic Proxy Server');
+  console.log('='.repeat(50));
+  console.log(`Listening on port ${PROXY_PORT}`);
+  console.log(`Internal ports range: ${INTERNAL_PORT_START}-${INTERNAL_PORT_END}`);
+  console.log(`Health check interval: ${HEALTH_CHECK_INTERVAL}ms`);
+  console.log('');
+  console.log('API Endpoints:');
+  console.log('  POST   /proxy/register   - Register a new route');
+  console.log('  DELETE /proxy/unregister - Remove a route');
+  console.log('  GET    /proxy/routes     - List all routes');
+  console.log('  GET    /proxy/health     - Health check');
+  console.log('');
+  console.log('Note: Registered servers must implement GET /proxy/health');
+  console.log('      returning status 200 to stay registered.');
+  console.log('='.repeat(50));
+  
+  // Démarre le polling de health check
+  startHealthCheckPolling();
+});
+
+module.exports = { app, registry };