dynamic-self-register-proxy 1.0.2 → 1.0.4

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.2",
+  "version": "1.0.4",
   "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

@@ -14,6 +14,7 @@ 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) {
@@ -401,6 +429,7 @@ app.get('/proxy/health', (req, res) => {
 /**
  * GET /
  * Page d'accueil listant tous les serveurs disponibles
+ * Retourne du JSON si le client l'accepte (API), sinon du HTML (navigateur)
  */
 app.get('/', (req, res) => {
   const routes = [];
@@ -409,13 +438,29 @@ app.get('/', (req, res) => {
       path,
       port: value.port,
       name: value.name,
-      registeredAt: value.registeredAt
+      registeredAt: value.registeredAt,
+      target: `http://localhost:${value.port}`
     });
   });
 
   // Tri par nom
   routes.sort((a, b) => a.name.localeCompare(b.name));
 
+  // Si le client accepte JSON (et pas spécifiquement HTML), retourne du JSON
+  const acceptHeader = req.get('Accept') || '';
+  const wantsJson = acceptHeader.includes('application/json') || 
+                    (acceptHeader.includes('*/*') && !acceptHeader.includes('text/html'));
+  
+  if (wantsJson) {
+    return res.json({
+      status: 'healthy',
+      uptime: process.uptime(),
+      count: routes.length,
+      routes,
+      availablePorts: (INTERNAL_PORT_END - INTERNAL_PORT_START) - registry.usedPorts.size
+    });
+  }
+
   const html = `
 <!DOCTYPE html>
 <html lang="fr">
@@ -728,6 +773,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');