dynamic-self-register-proxy 1.0.3 → 1.0.5

package/README.md

@@ -75,10 +75,44 @@ app.listen(port);
 http://localhost:3000/myapp/  →  votre application sur le port 4000
 ```
 
+## Page d'accueil
+
+L'URL racine `/` affiche une page listant tous les serveurs enregistrés avec des liens pour y accéder.
+
+- **Navigateurs** (`Accept: text/html`) → Page HTML avec interface moderne
+- **Clients API** (`Accept: application/json`) → Réponse JSON
+
+```bash
+# Accès navigateur : ouvrir http://localhost:3000/
+
+# Accès API
+curl -H "Accept: application/json" http://localhost:3000/
+```
+
+**Réponse JSON :**
+```json
+{
+  "status": "healthy",
+  "uptime": 3600,
+  "count": 2,
+  "routes": [
+    {
+      "path": "/api",
+      "port": 4000,
+      "name": "API Server",
+      "registeredAt": "2026-01-27T10:00:00.000Z",
+      "target": "http://localhost:4000"
+    }
+  ],
+  "availablePorts": 998
+}
+```
+
 ## API du Proxy
 
 | Endpoint | Méthode | Description |
 |----------|---------|-------------|
+| `/` | GET | Page d'accueil (HTML ou JSON selon Accept header) |
 | `/proxy/register` | POST | Enregistre une nouvelle route |
 | `/proxy/unregister` | DELETE | Supprime une route |
 | `/proxy/routes` | GET | Liste toutes les routes |
@@ -332,6 +366,7 @@ proxy.setupHealthRoute(app, {
 
 ### Comportement
 
+- **Période de grâce** : les nouveaux serveurs ont **60 secondes** après l'enregistrement avant d'être vérifiés (laisse le temps au serveur de démarrer)
 - 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é
@@ -388,7 +423,8 @@ Dans votre fichier de configuration Claude Desktop (`claude_desktop_config.json`
       "env": {
         "PROXY_PORT": "8080",
         "HEALTH_CHECK_INTERVAL": "60000",
-        "HEALTH_CHECK_TIMEOUT": "10000"
+        "HEALTH_CHECK_TIMEOUT": "10000",
+        "HEALTH_CHECK_GRACE_PERIOD": "120000"
       }
     }
   }
@@ -402,6 +438,7 @@ Dans votre fichier de configuration Claude Desktop (`claude_desktop_config.json`
 | `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) |
+| `HEALTH_CHECK_GRACE_PERIOD` | `60000` | Période de grâce pour les nouveaux serveurs (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 |
@@ -417,6 +454,13 @@ const INTERNAL_PORT_START = 4000;
 const INTERNAL_PORT_END = 5000;
 ```
 
+## Fonctionnalités
+
+- **Attribution sécurisée des ports** : utilisation d'un mutex pour éviter les conflits lors d'enregistrements simultanés
+- **Période de grâce** : les nouveaux serveurs ne sont pas vérifiés immédiatement, leur laissant le temps de démarrer
+- **Négociation de contenu** : l'URL racine `/` retourne HTML pour les navigateurs, JSON pour les API
+- **Health check automatique** : désenregistrement automatique des serveurs non répondants
+
 ## Limitations
 
 - Les routes sont stockées en mémoire (perdues au redémarrage du proxy)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dynamic-self-register-proxy",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Dynamic reverse proxy with self-registration API - applications can register themselves and receive an automatically assigned port",
   "main": "proxy-client.js",
   "bin": {

package/proxy.js

@@ -9,11 +9,12 @@ app.use(express.json());
 // ============================================
 // CONFIGURATION
 // ============================================
-const PROXY_PORT = process.env.PROXY_PORT || 3005;
+const PROXY_PORT = process.env.PROXY_PORT || 3000;
 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
+const HEALTH_CHECK_GRACE_PERIOD = process.env.HEALTH_CHECK_GRACE_PERIOD || 60000; // 60 secondes de grâce pour les nouveaux serveurs
 
 // ============================================
 // REGISTRY - Stockage des routes en mémoire
@@ -166,19 +167,36 @@ async function unregisterServer(path) {
   }
 }
 
+/**
+ * Vérifie si un serveur est encore dans sa période de grâce
+ * @param {object} route - Les informations de la route
+ * @returns {boolean} - true si le serveur est encore en période de grâce
+ */
+function isInGracePeriod(route) {
+  const registeredAt = new Date(route.registeredAt).getTime();
+  const now = Date.now();
+  return (now - registeredAt) < HEALTH_CHECK_GRACE_PERIOD;
+}
+
 /**
  * Effectue un health check sur tous les serveurs enregistrés
+ * Les serveurs récemment enregistrés (dans la période de grâce) sont ignorés
  */
 async function performHealthChecks() {
   if (registry.routes.size === 0) {
     return;
   }
   
-  console.log(`[HEALTH CHECK] Checking ${registry.routes.size} registered server(s)...`);
-  
   const checks = [];
+  let skippedCount = 0;
   
   for (const [path, route] of registry.routes.entries()) {
+    // Ignore les serveurs en période de grâce
+    if (isInGracePeriod(route)) {
+      skippedCount++;
+      continue;
+    }
+    
     checks.push(
       checkServerHealth(path, route).then(isHealthy => ({
         path,
@@ -188,6 +206,16 @@ async function performHealthChecks() {
     );
   }
   
+  // Si tous les serveurs sont en période de grâce, pas de log
+  if (checks.length === 0) {
+    if (skippedCount > 0) {
+      console.log(`[HEALTH CHECK] ${skippedCount} server(s) in grace period, skipping checks`);
+    }
+    return;
+  }
+  
+  console.log(`[HEALTH CHECK] Checking ${checks.length} server(s)...${skippedCount > 0 ? ` (${skippedCount} in grace period)` : ''}`);
+  
   const results = await Promise.all(checks);
   
   for (const { path, isHealthy } of results) {
@@ -385,6 +413,52 @@ app.get('/proxy/routes', (req, res) => {
   });
 });
 
+/**
+ * POST /proxy/check
+ * Déclenche manuellement un health check pour une route spécifique
+ * Body: { path: "/myapp" }
+ */
+app.post('/proxy/check', async (req, res) => {
+  const { path } = req.body;
+
+  if (!path) {
+    return res.status(400).json({ 
+      success: false, 
+      error: 'Path is required' 
+    });
+  }
+
+  const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+  const route = registry.routes.get(normalizedPath);
+
+  if (!route) {
+    return res.status(404).json({ 
+      success: false, 
+      error: 'Path not found' 
+    });
+  }
+
+  console.log(`[MANUAL HEALTH CHECK] Checking ${normalizedPath}...`);
+  const isHealthy = await checkServerHealth(normalizedPath, route);
+
+  if (!isHealthy) {
+    await unregisterServer(normalizedPath);
+    return res.json({
+      success: true,
+      path: normalizedPath,
+      healthy: false,
+      message: 'Server was unhealthy and has been removed'
+    });
+  }
+
+  res.json({
+    success: true,
+    path: normalizedPath,
+    healthy: true,
+    message: 'Server is healthy'
+  });
+});
+
 /**
  * GET /proxy/health
  * Health check du proxy
@@ -553,6 +627,40 @@ app.get('/', (req, res) => {
     .service-link:hover {
       opacity: 0.9;
     }
+    .service-actions {
+      display: flex;
+      gap: 1rem;
+      align-items: center;
+    }
+    .check-btn {
+      background: rgba(255, 255, 255, 0.1);
+      color: #e4e4e7;
+      border: 1px solid rgba(255, 255, 255, 0.2);
+      padding: 0.5rem 1rem;
+      border-radius: 8px;
+      cursor: pointer;
+      font-size: 0.85rem;
+      font-weight: 500;
+      transition: all 0.2s;
+    }
+    .check-btn:hover {
+      background: rgba(255, 255, 255, 0.15);
+      border-color: rgba(255, 255, 255, 0.3);
+    }
+    .check-btn.loading {
+      opacity: 0.5;
+      cursor: not-allowed;
+    }
+    .check-btn.healthy {
+      background: rgba(16, 185, 129, 0.2);
+      border-color: rgba(16, 185, 129, 0.4);
+      color: #10b981;
+    }
+    .check-btn.unhealthy {
+      background: rgba(239, 68, 68, 0.2);
+      border-color: rgba(239, 68, 68, 0.4);
+      color: #ef4444;
+    }
     .empty-state {
       text-align: center;
       padding: 4rem 2rem;
@@ -620,9 +728,14 @@ app.get('/', (req, res) => {
             <span>Port interne: ${route.port}</span>
             <span>Enregistré: ${new Date(route.registeredAt).toLocaleString('fr-FR')}</span>
           </div>
-          <a href="${escapeHtml(route.path)}" class="service-link">
-            Accéder au service →
-          </a>
+          <div class="service-actions">
+            <a href="${escapeHtml(route.path)}" class="service-link">
+              Accéder au service →
+            </a>
+            <button onclick="checkHealth('${escapeHtml(route.path)}', this)" class="check-btn">
+              Vérifier la santé
+            </button>
+          </div>
         </div>
       `).join('')}
     </div>
@@ -638,6 +751,51 @@ app.get('/', (req, res) => {
       <p>API: <a href="/proxy/routes">/proxy/routes</a> | <a href="/proxy/health">/proxy/health</a></p>
     </footer>
   </div>
+
+  <script>
+    async function checkHealth(path, btn) {
+      if (btn.classList.contains('loading')) return;
+      
+      const originalText = btn.innerText;
+      btn.innerText = 'Vérification...';
+      btn.classList.add('loading');
+      
+      try {
+        const response = await fetch('/proxy/check', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ path })
+        });
+        
+        const data = await response.json();
+        
+        if (data.healthy) {
+          btn.innerText = '✅ Sain';
+          btn.classList.remove('loading');
+          btn.classList.add('healthy');
+          setTimeout(() => {
+            btn.innerText = originalText;
+            btn.classList.remove('healthy');
+          }, 3000);
+        } else {
+          btn.innerText = '❌ Hors ligne';
+          btn.classList.remove('loading');
+          btn.classList.add('unhealthy');
+          
+          // Si le serveur a été supprimé, on rafraîchit la liste après un court délai
+          setTimeout(() => {
+            window.location.reload();
+          }, 2000);
+        }
+      } catch (error) {
+        btn.innerText = '⚠️ Erreur';
+        btn.classList.remove('loading');
+        setTimeout(() => {
+          btn.innerText = originalText;
+        }, 3000);
+      }
+    }
+  </script>
 </body>
 </html>
   `.trim();
@@ -745,6 +903,7 @@ app.listen(PROXY_PORT, () => {
   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(`Health check grace period: ${HEALTH_CHECK_GRACE_PERIOD}ms`);
   console.log('');
   console.log('API Endpoints:');
   console.log('  POST   /proxy/register   - Register a new route');