@imenam/self-register-proxy 1.0.46 → 1.0.48

package/services/portManager.js

@@ -1,137 +1,137 @@
-const net = require('net');
-const { INTERNAL_PORT_START, INTERNAL_PORT_END } = require('../config');
-const { registry } = require('./registry');
-
-/**
- * Vérifie si le target pointe vers la machine locale
- */
-function isLocalTarget(target) {
-  try {
-    const { hostname } = new URL(target);
-    return ['localhost', '127.0.0.1', '::1', '0.0.0.0'].includes(hostname);
-  } catch {
-    return true;
-  }
-}
-
-/** Délai au-delà duquel une tentative de connexion locale est abandonnée. */
-const CONNECT_PROBE_TIMEOUT = 300;
-
-/**
- * Vrai si l'OS nous laisse écouter sur ce port.
- *
- * Attention : ce test **ne suffit pas seul** (voir `isSomeoneListening`).
- */
-function canBind(port, host) {
-  return new Promise((resolve) => {
-    const server = net.createServer();
-    server.once('error', () => resolve(false));
-    server.once('listening', () => {
-      server.close(() => resolve(true));
-    });
-    if (host) server.listen(port, host);
-    else server.listen(port);
-  });
-}
-
-/**
- * Vrai si **quelqu'un accepte déjà** des connexions sur `host:port`.
- *
- * Pourquoi cette seconde sonde : sous Windows, lier `127.0.0.1:<port>` **réussit**
- * alors qu'un process tiers écoute déjà sur `0.0.0.0:<port>` — le bind d'une
- * adresse précise n'entre pas en conflit avec un bind générique d'un autre
- * process. Le test de bind seul déclarait donc libre un port occupé, et le proxy
- * attribuait ce port à une application ; sa sonde de santé interrogeait ensuite
- * le service de l'autre process, qui répondait, et la route ne mourait jamais.
- * Sous Linux le même bind échoue en `EADDRINUSE` : le défaut était invisible
- * hors Windows.
- *
- * Une tentative de connexion, elle, répond la même chose partout. Un timeout est
- * traité comme « occupé » : en local, une connexion sans réponse n'est pas normale.
- */
-function isSomeoneListening(port, host = '127.0.0.1', timeoutMs = CONNECT_PROBE_TIMEOUT) {
-  return new Promise((resolve) => {
-    const socket = new net.Socket();
-    const done = (value) => {
-      socket.removeAllListeners();
-      socket.destroy();
-      resolve(value);
-    };
-    socket.setTimeout(timeoutMs);
-    socket.once('connect', () => done(true));
-    socket.once('timeout', () => done(true));
-    // ECONNREFUSED (personne n'écoute) et les autres erreurs : port utilisable.
-    socket.once('error', () => done(false));
-    socket.connect(port, host);
-  });
-}
-
-/**
- * Vérifie si un port est réellement libre au niveau OS : personne ne peut s'y
- * lier **et** personne n'y répond. Les deux conditions sont nécessaires.
- */
-async function isPortFree(port) {
-  if (!(await canBind(port))) return false;
-  return !(await isSomeoneListening(port));
-}
-
-/**
- * Trouve le prochain port disponible et le réserve atomiquement
- * DOIT être appelé avec le mutex acquis
- */
-async function getNextAvailablePort(checkSystem = true) {
-  while (true) {
-    while (registry.usedPorts.has(registry.nextPort)) {
-      registry.nextPort++;
-      if (registry.nextPort > INTERNAL_PORT_END) {
-        registry.nextPort = INTERNAL_PORT_START;
-        if (registry.usedPorts.size >= (INTERNAL_PORT_END - INTERNAL_PORT_START)) {
-          throw new Error('No available ports');
-        }
-      }
-    }
-
-    const port = registry.nextPort;
-
-    if (!checkSystem || await isPortFree(port)) {
-      registry.usedPorts.add(port);
-      registry.nextPort++;
-      return port;
-    }
-
-    console.log(`[PORT] Port ${port} is in use by another process, skipping...`);
-    registry.usedPorts.add(port);
-    registry.nextPort++;
-  }
-}
-
-/**
- * Libère un port réservé (en cas d'échec d'enregistrement)
- */
-function releasePort(port) {
-  registry.usedPorts.delete(port);
-}
-
-/**
- * Trouve la route correspondant à un chemin de requête
- * Tri par longueur décroissante pour matcher le plus spécifique d'abord
- */
-function findRouteForPath(requestPath) {
-  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;
-}
-
-module.exports = {
-  isLocalTarget,
-  canBind,
-  isSomeoneListening,
-  isPortFree,
-  getNextAvailablePort,
-  releasePort,
-  findRouteForPath,
-};
+const net = require('net');
+const { INTERNAL_PORT_START, INTERNAL_PORT_END } = require('../config');
+const { registry } = require('./registry');
+
+/**
+ * Vérifie si le target pointe vers la machine locale
+ */
+function isLocalTarget(target) {
+  try {
+    const { hostname } = new URL(target);
+    return ['localhost', '127.0.0.1', '::1', '0.0.0.0'].includes(hostname);
+  } catch {
+    return true;
+  }
+}
+
+/** Délai au-delà duquel une tentative de connexion locale est abandonnée. */
+const CONNECT_PROBE_TIMEOUT = 300;
+
+/**
+ * Vrai si l'OS nous laisse écouter sur ce port.
+ *
+ * Attention : ce test **ne suffit pas seul** (voir `isSomeoneListening`).
+ */
+function canBind(port, host) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once('error', () => resolve(false));
+    server.once('listening', () => {
+      server.close(() => resolve(true));
+    });
+    if (host) server.listen(port, host);
+    else server.listen(port);
+  });
+}
+
+/**
+ * Vrai si **quelqu'un accepte déjà** des connexions sur `host:port`.
+ *
+ * Pourquoi cette seconde sonde : sous Windows, lier `127.0.0.1:<port>` **réussit**
+ * alors qu'un process tiers écoute déjà sur `0.0.0.0:<port>` — le bind d'une
+ * adresse précise n'entre pas en conflit avec un bind générique d'un autre
+ * process. Le test de bind seul déclarait donc libre un port occupé, et le proxy
+ * attribuait ce port à une application ; sa sonde de santé interrogeait ensuite
+ * le service de l'autre process, qui répondait, et la route ne mourait jamais.
+ * Sous Linux le même bind échoue en `EADDRINUSE` : le défaut était invisible
+ * hors Windows.
+ *
+ * Une tentative de connexion, elle, répond la même chose partout. Un timeout est
+ * traité comme « occupé » : en local, une connexion sans réponse n'est pas normale.
+ */
+function isSomeoneListening(port, host = '127.0.0.1', timeoutMs = CONNECT_PROBE_TIMEOUT) {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    const done = (value) => {
+      socket.removeAllListeners();
+      socket.destroy();
+      resolve(value);
+    };
+    socket.setTimeout(timeoutMs);
+    socket.once('connect', () => done(true));
+    socket.once('timeout', () => done(true));
+    // ECONNREFUSED (personne n'écoute) et les autres erreurs : port utilisable.
+    socket.once('error', () => done(false));
+    socket.connect(port, host);
+  });
+}
+
+/**
+ * Vérifie si un port est réellement libre au niveau OS : personne ne peut s'y
+ * lier **et** personne n'y répond. Les deux conditions sont nécessaires.
+ */
+async function isPortFree(port) {
+  if (!(await canBind(port))) return false;
+  return !(await isSomeoneListening(port));
+}
+
+/**
+ * Trouve le prochain port disponible et le réserve atomiquement
+ * DOIT être appelé avec le mutex acquis
+ */
+async function getNextAvailablePort(checkSystem = true) {
+  while (true) {
+    while (registry.usedPorts.has(registry.nextPort)) {
+      registry.nextPort++;
+      if (registry.nextPort > INTERNAL_PORT_END) {
+        registry.nextPort = INTERNAL_PORT_START;
+        if (registry.usedPorts.size >= (INTERNAL_PORT_END - INTERNAL_PORT_START)) {
+          throw new Error('No available ports');
+        }
+      }
+    }
+
+    const port = registry.nextPort;
+
+    if (!checkSystem || await isPortFree(port)) {
+      registry.usedPorts.add(port);
+      registry.nextPort++;
+      return port;
+    }
+
+    console.log(`[PORT] Port ${port} is in use by another process, skipping...`);
+    registry.usedPorts.add(port);
+    registry.nextPort++;
+  }
+}
+
+/**
+ * Libère un port réservé (en cas d'échec d'enregistrement)
+ */
+function releasePort(port) {
+  registry.usedPorts.delete(port);
+}
+
+/**
+ * Trouve la route correspondant à un chemin de requête
+ * Tri par longueur décroissante pour matcher le plus spécifique d'abord
+ */
+function findRouteForPath(requestPath) {
+  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;
+}
+
+module.exports = {
+  isLocalTarget,
+  canBind,
+  isSomeoneListening,
+  isPortFree,
+  getNextAvailablePort,
+  releasePort,
+  findRouteForPath,
+};

package/services/proxyRouter.js

@@ -1,99 +1,99 @@
-const { createProxyMiddleware } = require('http-proxy-middleware');
-const { registry } = require('./registry');
-const { findRouteForPath } = require('./portManager');
-const { unregisterServer } = require('./healthCheck');
-const { requireAuth } = require('./auth');
-
-/**
- * Échappe les caractères HTML pour éviter les injections XSS
- */
-function escapeHtml(text) {
-  const map = { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#039;' };
-  return String(text).replace(/[&<>"']/g, char => map[char]);
-}
-
-/**
- * Middleware de proxy persistant — créé une seule fois pour éviter les fuites mémoire
- */
-const persistentProxyMiddleware = createProxyMiddleware({
-  target: 'http://localhost',
-  router: (req) => req.proxyTarget,
-  changeOrigin: true,
-  pathRewrite: (path, req) => {
-    const routePath = req.proxyRoutePath;
-    if (routePath && path.startsWith(routePath)) {
-      return path.slice(routePath.length) || '/';
-    }
-    return path;
-  },
-  on: {
-    proxyReq: (proxyReq, req) => {
-      if (req.body && typeof req.body === 'object' && 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} -> ${req.proxyTarget}`);
-    },
-    error: (err, req, res) => {
-      if (res.headersSent) return;
-      console.error(`[PROXY ERROR] ${req.path}:`, err.message);
-
-      if (err.code === 'ECONNREFUSED' || err.code === 'ETIMEDOUT') {
-        const route = findRouteForPath(req.path);
-        if (route) {
-          const routePath = [...registry.routes.entries()].find(([, v]) => v === route)?.[0];
-          if (routePath) {
-            unregisterServer(routePath, `connection error (${err.code})`).catch(() => {});
-            console.log(`[PROXY] Auto-unregistered ${routePath} due to connection error`);
-          }
-        }
-      }
-
-      res.status(502).json({ error: 'Proxy error' });
-    }
-  }
-});
-
-/**
- * Middleware principal de routage vers le proxy
- * Inclut le Smart Routing (Referer Fallback)
- */
-function routingMiddleware(req, res, next) {
-  if (req.path.startsWith('/proxy/')) return next();
-
-  requireAuth(req, res, () => {
-    let route = findRouteForPath(req.path);
-
-    if (!route && req.get('Referer')) {
-      try {
-        const refererUrl = new URL(req.get('Referer'));
-        if (refererUrl.host === req.get('host')) {
-          const refererPath = refererUrl.pathname;
-          route = findRouteForPath(refererPath);
-          if (route) {
-            console.log(`[SMART ROUTE] Inferred ${route.name} from referer: ${refererPath}`);
-          }
-        }
-      } catch {
-        // URL de referer invalide, on ignore
-      }
-    }
-
-    if (!route) {
-      return res.status(404).json({
-        error: 'No route registered for this path',
-        path: req.path,
-        hint: 'Register a route with POST /proxy/register or use the UI'
-      });
-    }
-
-    const target = route.target || 'http://localhost';
-    req.proxyTarget = `${target}:${route.port}`;
-    req.proxyRoutePath = [...registry.routes.entries()].find(([, v]) => v === route)?.[0];
-    persistentProxyMiddleware(req, res, next);
-  });
-}
-
-module.exports = { persistentProxyMiddleware, routingMiddleware, escapeHtml };
+const { createProxyMiddleware } = require('http-proxy-middleware');
+const { registry } = require('./registry');
+const { findRouteForPath } = require('./portManager');
+const { unregisterServer } = require('./healthCheck');
+const { requireAuth } = require('./auth');
+
+/**
+ * Échappe les caractères HTML pour éviter les injections XSS
+ */
+function escapeHtml(text) {
+  const map = { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#039;' };
+  return String(text).replace(/[&<>"']/g, char => map[char]);
+}
+
+/**
+ * Middleware de proxy persistant — créé une seule fois pour éviter les fuites mémoire
+ */
+const persistentProxyMiddleware = createProxyMiddleware({
+  target: 'http://localhost',
+  router: (req) => req.proxyTarget,
+  changeOrigin: true,
+  pathRewrite: (path, req) => {
+    const routePath = req.proxyRoutePath;
+    if (routePath && path.startsWith(routePath)) {
+      return path.slice(routePath.length) || '/';
+    }
+    return path;
+  },
+  on: {
+    proxyReq: (proxyReq, req) => {
+      if (req.body && typeof req.body === 'object' && 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} -> ${req.proxyTarget}`);
+    },
+    error: (err, req, res) => {
+      if (res.headersSent) return;
+      console.error(`[PROXY ERROR] ${req.path}:`, err.message);
+
+      if (err.code === 'ECONNREFUSED' || err.code === 'ETIMEDOUT') {
+        const route = findRouteForPath(req.path);
+        if (route) {
+          const routePath = [...registry.routes.entries()].find(([, v]) => v === route)?.[0];
+          if (routePath) {
+            unregisterServer(routePath, `connection error (${err.code})`).catch(() => {});
+            console.log(`[PROXY] Auto-unregistered ${routePath} due to connection error`);
+          }
+        }
+      }
+
+      res.status(502).json({ error: 'Proxy error' });
+    }
+  }
+});
+
+/**
+ * Middleware principal de routage vers le proxy
+ * Inclut le Smart Routing (Referer Fallback)
+ */
+function routingMiddleware(req, res, next) {
+  if (req.path.startsWith('/proxy/')) return next();
+
+  requireAuth(req, res, () => {
+    let route = findRouteForPath(req.path);
+
+    if (!route && req.get('Referer')) {
+      try {
+        const refererUrl = new URL(req.get('Referer'));
+        if (refererUrl.host === req.get('host')) {
+          const refererPath = refererUrl.pathname;
+          route = findRouteForPath(refererPath);
+          if (route) {
+            console.log(`[SMART ROUTE] Inferred ${route.name} from referer: ${refererPath}`);
+          }
+        }
+      } catch {
+        // URL de referer invalide, on ignore
+      }
+    }
+
+    if (!route) {
+      return res.status(404).json({
+        error: 'No route registered for this path',
+        path: req.path,
+        hint: 'Register a route with POST /proxy/register or use the UI'
+      });
+    }
+
+    const target = route.target || 'http://localhost';
+    req.proxyTarget = `${target}:${route.port}`;
+    req.proxyRoutePath = [...registry.routes.entries()].find(([, v]) => v === route)?.[0];
+    persistentProxyMiddleware(req, res, next);
+  });
+}
+
+module.exports = { persistentProxyMiddleware, routingMiddleware, escapeHtml };

package/services/registry.js

@@ -1,41 +1,41 @@
-const { INTERNAL_PORT_START } = require('../config');
-
-/**
- * Simple mutex pour sérialiser les opérations critiques
- * Évite les race conditions lors d'inscriptions simultanées
- */
-class Mutex {
-  constructor() {
-    this._locked = false;
-    this._queue = [];
-  }
-
-  async acquire() {
-    if (!this._locked) {
-      this._locked = true;
-      return;
-    }
-    return new Promise(resolve => {
-      this._queue.push(resolve);
-    });
-  }
-
-  release() {
-    if (this._queue.length > 0) {
-      const next = this._queue.shift();
-      next();
-    } else {
-      this._locked = false;
-    }
-  }
-}
-
-const registry = {
-  routes: new Map(),      // path -> { port, target, name, healthCheck, group, registeredAt }
-  usedPorts: new Set(),   // Ports déjà attribués
-  nextPort: INTERNAL_PORT_START
-};
-
-const mutex = new Mutex();
-
-module.exports = { registry, mutex };
+const { INTERNAL_PORT_START } = require('../config');
+
+/**
+ * Simple mutex pour sérialiser les opérations critiques
+ * Évite les race conditions lors d'inscriptions simultanées
+ */
+class Mutex {
+  constructor() {
+    this._locked = false;
+    this._queue = [];
+  }
+
+  async acquire() {
+    if (!this._locked) {
+      this._locked = true;
+      return;
+    }
+    return new Promise(resolve => {
+      this._queue.push(resolve);
+    });
+  }
+
+  release() {
+    if (this._queue.length > 0) {
+      const next = this._queue.shift();
+      next();
+    } else {
+      this._locked = false;
+    }
+  }
+}
+
+const registry = {
+  routes: new Map(),      // path -> { port, target, name, healthCheck, group, registeredAt }
+  usedPorts: new Set(),   // Ports déjà attribués
+  nextPort: INTERNAL_PORT_START
+};
+
+const mutex = new Mutex();
+
+module.exports = { registry, mutex };