@imenam/self-register-proxy 1.0.41 → 1.0.43

package/README.md

@@ -82,7 +82,8 @@ const response = await fetch('http://localhost:3000/proxy/register', {
   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)
+    name: 'My App',      // Nom de l'application (optionnel)
+    group: 'Google'      // Section repliable du dashboard (optionnel)
   })
 });
 
@@ -163,6 +164,7 @@ Enregistre une nouvelle route et attribue un port.
 | `path` | string | ✅ | Chemin URL pour accéder à l'app |
 | `name` | string | ❌ | Nom descriptif |
 | `port` | number | ❌ | Port spécifique (sinon auto-attribué) |
+| `group` | string | ❌ | Section repliable du dashboard (repliée par défaut). Vide/absent ⇒ section « Non groupées » |
 
 **Response (201):**
 ```json

package/package.json

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

package/routes/dashboard.js

@@ -77,6 +77,7 @@ router.get('/', requireAuth, (req, res) => {
       target: value.target || 'http://localhost',
       name: value.name,
       healthCheck: value.healthCheck,
+      group: value.group || null,
       registeredAt: value.registeredAt,
       fullTarget: `${value.target || 'http://localhost'}:${value.port}`
     });

package/routes/metaConfig.js

@@ -3,7 +3,7 @@ const metaConfig = require('../meta-config');
 const { requireAuth } = require('../services/auth');
 const { registry } = require('../services/registry');
 const { renderMetaConfigs } = require('../views/metaConfigs');
-const { PROXY_NAME } = require('../config');
+const { PROXY_NAME, OPENCODE_CLEAN_UP, ADMIN_PASSWORD } = require('../config');
 
 const router = Router();
 
@@ -173,7 +173,7 @@ router.get('/proxy/meta-configs/active/sync', requireAuth, async (req, res) => {
  */
 router.get('/proxy/meta-configs-ui', requireAuth, (req, res) => {
   const data = metaConfig.getAll();
-  const html = renderMetaConfigs(PROXY_NAME, data.metaConfigs, data.activeMetaConfig);
+  const html = renderMetaConfigs(PROXY_NAME, data.metaConfigs, data.activeMetaConfig, OPENCODE_CLEAN_UP, !!ADMIN_PASSWORD);
   res.type('html').send(html);
 });
 

package/routes/registration.js

@@ -10,8 +10,18 @@ const router = Router();
 /**
  * Logique commune d'enregistrement (auto et manuel)
  */
-async function registerRouteInternal({ path, name, port, target, healthCheck, autoAssignPort }) {
+/**
+ * Normalise un nom de groupe : trim, et chaîne vide => undefined (non groupé).
+ */
+function normalizeGroup(group) {
+  if (typeof group !== 'string') return undefined;
+  const trimmed = group.trim();
+  return trimmed === '' ? undefined : trimmed;
+}
+
+async function registerRouteInternal({ path, name, port, target, healthCheck, group, autoAssignPort }) {
   const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+  const normalizedGroup = normalizeGroup(group);
 
   let finalTarget = target || 'http://localhost';
   if (!finalTarget.startsWith('http://') && !finalTarget.startsWith('https://')) {
@@ -63,10 +73,11 @@ async function registerRouteInternal({ path, name, port, target, healthCheck, au
       target: finalTarget,
       name: name || normalizedPath,
       healthCheck: healthCheck !== undefined ? healthCheck === true || healthCheck === 'true' : true,
+      group: normalizedGroup,
       registeredAt: new Date().toISOString()
     });
 
-    console.log(`[REGISTER] ${normalizedPath} -> ${finalTarget}:${assignedPort} (${name || 'unnamed'}) [Health: ${healthCheck !== undefined ? healthCheck : 'default'}]`);
+    console.log(`[REGISTER] ${normalizedPath} -> ${finalTarget}:${assignedPort} (${name || 'unnamed'}) [Health: ${healthCheck !== undefined ? healthCheck : 'default'}]${normalizedGroup ? ` [Group: ${normalizedGroup}]` : ''}`);
 
     return {
       success: true,
@@ -75,6 +86,7 @@ async function registerRouteInternal({ path, name, port, target, healthCheck, au
       target: finalTarget,
       name: name || normalizedPath,
       healthCheck: healthCheck !== undefined ? healthCheck === true || healthCheck === 'true' : true,
+      group: normalizedGroup,
       message: `Route registered. Target: ${finalTarget}:${assignedPort}`
     };
 
@@ -95,12 +107,12 @@ async function registerRouteInternal({ path, name, port, target, healthCheck, au
  * Enregistrement automatique (rétro-compatibilité)
  */
 router.post('/proxy/register', requireLocalOnly, async (req, res) => {
-  const { path, name, target, healthCheck } = req.body;
+  const { path, name, target, healthCheck, group } = req.body;
 
   if (!path) return res.status(400).json({ success: false, error: 'Path is required' });
 
   try {
-    const result = await registerRouteInternal({ path, name, target, healthCheck, autoAssignPort: true });
+    const result = await registerRouteInternal({ path, name, target, healthCheck, group, autoAssignPort: true });
     res.json(result);
   } catch (error) {
     console.error('[REGISTER AUTO ERROR]', error.message);
@@ -114,13 +126,13 @@ router.post('/proxy/register', requireLocalOnly, async (req, res) => {
  * Enregistrement manuel via l'interface graphique (port obligatoire)
  */
 router.post('/proxy/register-manual', requireAuth, async (req, res) => {
-  const { path, name, port, target, healthCheck } = req.body;
+  const { path, name, port, target, healthCheck, group } = req.body;
 
   if (!path) return res.status(400).json({ success: false, error: 'Path is required' });
   if (!port) return res.status(400).json({ success: false, error: 'Port is required for manual registration' });
 
   try {
-    const result = await registerRouteInternal({ path, name, port, target, healthCheck, autoAssignPort: false });
+    const result = await registerRouteInternal({ path, name, port, target, healthCheck, group, autoAssignPort: false });
     res.json(result);
   } catch (error) {
     console.error('[REGISTER MANUAL ERROR]', error.message);
@@ -178,6 +190,7 @@ router.get('/proxy/routes', requireAuth, (req, res) => {
       target: value.target || 'http://localhost',
       name: value.name,
       healthCheck: value.healthCheck,
+      group: value.group || null,
       registeredAt: value.registeredAt,
       fullTarget: `${value.target || 'http://localhost'}:${value.port}`
     });

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

@@ -31,7 +31,7 @@ class Mutex {
 }
 
 const registry = {
-  routes: new Map(),      // path -> { port, target, name, healthCheck, registeredAt }
+  routes: new Map(),      // path -> { port, target, name, healthCheck, group, registeredAt }
   usedPorts: new Set(),   // Ports déjà attribués
   nextPort: INTERNAL_PORT_START
 };