@imenam/self-register-proxy 1.0.37

package/services/proxyRouter.js

@@ -0,0 +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 };

package/services/registry.js

@@ -0,0 +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, registeredAt }
+  usedPorts: new Set(),   // Ports déjà attribués
+  nextPort: INTERNAL_PORT_START
+};
+
+const mutex = new Mutex();
+
+module.exports = { registry, mutex };

package/terminal-server.js

@@ -0,0 +1,154 @@
+const os = require('os');
+const { execSync } = require('child_process');
+const pty = require('node-pty');
+const { WebSocketServer } = require('ws');
+
+const DEFAULT_SHELL = os.platform() === 'win32' ? 'powershell.exe' : 'bash';
+
+class TerminalServer {
+  /**
+   * @param {import('http').Server} httpServer
+   * @param {object} [options]
+   * @param {string} [options.shell] - Shell to spawn (default: auto-detected)
+   * @param {string[]} [options.shellArgs] - Shell arguments (default: [])
+   * @param {object} [options.ptyOptions] - node-pty spawn options overrides
+   * @param {number} [options.ptyOptions.cols] - Initial columns (default: 80)
+   * @param {number} [options.ptyOptions.rows] - Initial rows (default: 24)
+   * @param {string} [options.ptyOptions.cwd] - Working directory (default: user home)
+   * @param {object} [options.ptyOptions.env] - Environment variables (default: process.env)
+   * @param {string} [options.command] - Command to execute automatically after spawn
+   * @param {string} [options.path] - WebSocket endpoint path (default: '/terminal')
+   * @param {object} [options.wsOptions] - WebSocketServer options overrides
+   */
+  constructor(httpServer, options = {}) {
+    this.shell = options.shell || DEFAULT_SHELL;
+    this.shellArgs = options.shellArgs || [];
+    this.command = options.command || '';
+    this.ptyOptions = {
+      name: 'xterm-color',
+      cols: 80,
+      rows: 24,
+      cwd: process.env.HOME || process.env.USERPROFILE,
+      env: process.env,
+      ...options.ptyOptions,
+    };
+
+    this.connections = new Set();
+
+    this.wss = new WebSocketServer({
+      server: httpServer,
+      path: options.path || '/terminal',
+      ...options.wsOptions,
+    });
+    this.wss.on('connection', (ws, req) => this._handleConnection(ws, req));
+  }
+
+  _handleConnection(ws, req) {
+    const cwd = this.ptyOptions.cwd;
+
+    let ptyProcess;
+    try {
+      ptyProcess = pty.spawn(this.shell, this.shellArgs, {
+        ...this.ptyOptions,
+        cwd,
+      });
+    } catch (err) {
+      console.error(`[TERMINAL] Failed to spawn PTY (cwd: ${cwd}):`, err.message);
+      ws.close(1011, 'Failed to spawn terminal');
+      return;
+    }
+
+    const connection = { ws, ptyProcess };
+    this.connections.add(connection);
+
+    ptyProcess.onData((data) => {
+      try {
+        ws.send(data);
+      } catch (e) {
+        // WebSocket already closed
+      }
+    });
+
+    ws.on('message', (data) => {
+      const message = data.toString();
+      try {
+        const msg = JSON.parse(message);
+        if (msg.type === 'resize') {
+          ptyProcess.resize(msg.cols, msg.rows);
+          return;
+        }
+      } catch (e) {
+        // Not JSON, treat as terminal input
+      }
+      ptyProcess.write(message);
+    });
+
+    ws.on('close', () => {
+      this._gracefulKill(ptyProcess);
+      this.connections.delete(connection);
+    });
+
+    // Exécuter automatiquement la commande configurée
+    if (this.command) {
+      // Petit délai pour laisser le shell s'initialiser
+      setTimeout(() => {
+        ptyProcess.write(this.command + '\r');
+        console.log(`[TERMINAL] Auto-executed command: ${this.command}`);
+      }, 500);
+    }
+  }
+
+  /**
+   * Arrêt gracieux : envoie Ctrl+C deux fois pour interrompre proprement
+   * le programme en cours, attend qu'il se termine, puis tue le shell.
+   * @param {import('node-pty').IPty} ptyProcess
+   */
+  _gracefulKill(ptyProcess) {
+    const pid = ptyProcess.pid;
+    console.log(`[TERMINAL] Graceful shutdown (PID: ${pid})...`);
+
+    // 1er Ctrl+C
+    try { ptyProcess.write('\x03'); } catch (_) { /* ignore */ }
+
+    setTimeout(() => {
+      // 2e Ctrl+C
+      try { ptyProcess.write('\x03'); } catch (_) { /* ignore */ }
+
+      setTimeout(() => {
+        // Tuer tout l'arbre de processus
+        this._killProcessTree(pid);
+      }, 1000);
+    }, 500);
+  }
+
+  /**
+   * Tue l'arbre de processus par PID.
+   * Sur Windows : taskkill /F /T /PID
+   * Sur Linux/macOS : kill du groupe de processus
+   * @param {number} pid
+   */
+  _killProcessTree(pid) {
+    try {
+      if (os.platform() === 'win32') {
+        execSync(`taskkill /F /T /PID ${pid}`, { stdio: 'ignore' });
+      } else {
+        process.kill(-pid, 'SIGKILL');
+      }
+      console.log(`[TERMINAL] Killed process tree (PID: ${pid})`);
+    } catch (e) {
+      // Le processus est peut-être déjà terminé
+      console.log(`[TERMINAL] Process tree already exited (PID: ${pid})`);
+    }
+  }
+
+  dispose() {
+    for (const { ws, ptyProcess } of this.connections) {
+      this._gracefulKill(ptyProcess);
+      ws.close();
+    }
+    this.connections.clear();
+    this.wss.close();
+  }
+}
+
+module.exports = { TerminalServer };