@lopatnov/express-reverse-proxy 3.0.0 → 5.0.0

package/server.js

@@ -1,12 +1,21 @@
 #!/usr/bin/env node
-import { spawnSync } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import https from 'node:https';
 import path from 'node:path';
+import readline from 'node:readline/promises';
 import { fileURLToPath } from 'node:url';
+import compression from 'compression';
+import cors from 'cors';
 import express from 'express';
+import basicAuth from 'express-basic-auth';
 import proxy from 'express-http-proxy';
+import rateLimit from 'express-rate-limit';
+import helmet from 'helmet';
 import morgan from 'morgan';
+import multer from 'multer';
+import responseTime from 'response-time';
+import favicon from 'serve-favicon';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -47,6 +56,10 @@ const possibleServerArgs = [
       '--cluster restart --cluster-config /etc/myapp/ecosystem.config.cjs',
     ],
   },
+  {
+    name: '--init',
+    description: 'interactively creates a server-config.json in the current directory',
+  },
 ];
 
 function exitError(msg, code = -1) {
@@ -145,6 +158,30 @@ if (serverArgs['--cluster']) {
   process.exit(result.status ?? 0);
 }
 
+if (serverArgs['--init']) {
+  const configOut = path.resolve(process.cwd(), 'server-config.json');
+  if (fs.existsSync(configOut)) {
+    const rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ans = await rl2.question(`${configOut} already exists. Overwrite? [y/N]: `);
+    rl2.close();
+    if (ans.trim().toLowerCase() !== 'y') process.exit(0);
+  }
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const port = (await rl.question('Port [8000]: ')).trim() || '8000';
+  const folder = (await rl.question('Static folder [.]: ')).trim() || '.';
+  const proxyPath = (await rl.question('Proxy path (e.g. /api) [skip]: ')).trim();
+  let proxyTarget = '';
+  if (proxyPath) proxyTarget = (await rl.question(`Proxy target for ${proxyPath}: `)).trim();
+  const hotReload = (await rl.question('Hot reload? [y/N]: ')).trim().toLowerCase() === 'y';
+  rl.close();
+  const cfg = { port: parseInt(port, 10), folders: folder };
+  if (proxyPath && proxyTarget) cfg.proxy = { [proxyPath]: proxyTarget };
+  if (hotReload) cfg.hotReload = true;
+  fs.writeFileSync(configOut, `${JSON.stringify(cfg, null, 2)}\n`);
+  console.log(`[init] Created ${configOut}`);
+  process.exit(0);
+}
+
 let configFile = './server-config.json';
 if (serverArgs['--config']) {
   [configFile] = serverArgs['--config'].args;
@@ -250,12 +287,26 @@ function addStaticFolder(router, port, rootPath, folder) {
 }
 
 function addRemoteProxy(router, port, urlPath, proxyServer) {
-  if (urlPath) {
-    router.use(urlPath, proxy(proxyServer));
+  if (Array.isArray(proxyServer)) {
+    let i = 0;
+    const targets = proxyServer;
+    const balancedProxy = proxy((_req) => targets[i++ % targets.length]);
+    if (urlPath) {
+      router.use(urlPath, balancedProxy);
+    } else {
+      router.use(balancedProxy);
+    }
+    console.log(
+      `[proxy] http://localhost:${port}${urlPath || ''} <===> [${targets.join(', ')}] (round-robin)`,
+    );
   } else {
-    router.use(proxy(proxyServer));
+    if (urlPath) {
+      router.use(urlPath, proxy(proxyServer));
+    } else {
+      router.use(proxy(proxyServer));
+    }
+    console.log(`[proxy] http://localhost:${port}${urlPath || ''} <===> ${proxyServer}`);
   }
-  console.log(`[proxy] http://localhost:${port}${urlPath || ''} <===> ${proxyServer}`);
 }
 
 function addMappedProxy(router, port, localRootPath, pathPairs) {
@@ -307,11 +358,6 @@ const servers = [];
 
 configsByPort.forEach((portConfigs, p) => {
   const app = express();
-  const loggingEnabled = portConfigs.every((c) => c.logging !== false);
-  if (loggingEnabled) {
-    app.use(morgan('combined'));
-  }
-
   // Hot reload via SSE
   const hotReloadEnabled = portConfigs.some((c) => c.hotReload === true);
   if (hotReloadEnabled) {
@@ -361,6 +407,59 @@ configsByPort.forEach((portConfigs, p) => {
 
     console.log(`[host] ${siteHost} → :${p}`);
 
+    if (siteConfig.logging !== false) {
+      const lc = siteConfig.logging;
+      if (typeof lc === 'object' && lc.file) {
+        const stream = fs.createWriteStream(path.resolve(configDir, lc.file), { flags: 'a' });
+        router.use(morgan(lc.format || 'combined', { stream }));
+      } else {
+        router.use(morgan((typeof lc === 'object' ? lc.format : null) || 'dev'));
+      }
+    }
+
+    if (siteConfig.responseTime) {
+      const opts = typeof siteConfig.responseTime === 'object' ? siteConfig.responseTime : {};
+      router.use(responseTime(opts));
+    }
+
+    if (siteConfig.cors) {
+      const opts = typeof siteConfig.cors === 'object' ? siteConfig.cors : {};
+      router.use(cors(opts));
+    }
+
+    if (siteConfig.compression) {
+      const opts = typeof siteConfig.compression === 'object' ? siteConfig.compression : {};
+      router.use(compression(opts));
+    }
+
+    if (siteConfig.helmet) {
+      const opts = typeof siteConfig.helmet === 'object' ? siteConfig.helmet : {};
+      router.use(helmet(opts));
+    }
+
+    if (siteConfig.favicon) {
+      router.use(favicon(path.resolve(configDir, siteConfig.favicon)));
+    }
+
+    if (siteConfig.healthCheck) {
+      const hcPath =
+        (typeof siteConfig.healthCheck === 'object' && siteConfig.healthCheck.path) ||
+        '/__health__';
+      router.get(hcPath, (_req, res) => {
+        res.json({ status: 'ok', uptime: process.uptime(), timestamp: new Date().toISOString() });
+      });
+    }
+
+    if (siteConfig.rateLimit) {
+      const opts = typeof siteConfig.rateLimit === 'object' ? siteConfig.rateLimit : {};
+      router.use(rateLimit(opts));
+    }
+
+    if (siteConfig.basicAuth) {
+      const opts = typeof siteConfig.basicAuth === 'object' ? siteConfig.basicAuth : {};
+      router.use(basicAuth(opts));
+    }
+
     if (siteConfig.headers) {
       router.use((_req, res, next) => {
         for (const h of Object.keys(siteConfig.headers)) res.setHeader(h, siteConfig.headers[h]);
@@ -368,10 +467,175 @@ configsByPort.forEach((portConfigs, p) => {
       });
     }
 
+    if (siteConfig.redirects) {
+      const redirects = siteConfig.redirects;
+      if (Array.isArray(redirects)) {
+        for (const r of redirects) {
+          router.all(r.from, (_req, res) => res.redirect(r.status || 301, r.to));
+        }
+      } else {
+        for (const [from, to] of Object.entries(redirects)) {
+          const dest = typeof to === 'string' ? to : to.to;
+          const status = typeof to === 'object' ? to.status || 301 : 301;
+          router.all(from, (_req, res) => res.redirect(status, dest));
+        }
+      }
+    }
+
     if (siteConfig.folders) {
       addStaticFolder(router, p, null, siteConfig.folders);
     }
 
+    if (siteConfig.cgi) {
+      const cgiRaw = siteConfig.cgi;
+      const cgiConfigs = Array.isArray(cgiRaw)
+        ? cgiRaw
+        : [typeof cgiRaw === 'string' ? { dir: cgiRaw } : cgiRaw];
+
+      for (const cgiConfig of cgiConfigs) {
+        const cgiUrlPath = cgiConfig.path || '/cgi-bin';
+        const cgiDirResolved = path.resolve(configDir, cgiConfig.dir || './cgi-bin');
+        const cgiExts = new Set(cgiConfig.extensions || ['.cgi', '.pl', '.py', '.sh']);
+        const interps = cgiConfig.interpreters || {};
+
+        router.use(cgiUrlPath, (req, res, next) => {
+          const scriptPath = path.resolve(path.join(cgiDirResolved, req.path));
+          if (!scriptPath.startsWith(cgiDirResolved + path.sep)) return next();
+
+          const ext = path.extname(scriptPath);
+          if (!cgiExts.has(ext) || !fs.existsSync(scriptPath)) return next();
+
+          const url = new URL(req.url, `http://${req.headers.host || 'localhost'}`);
+          const env = {
+            ...process.env,
+            GATEWAY_INTERFACE: 'CGI/1.1',
+            SERVER_PROTOCOL: 'HTTP/1.1',
+            SERVER_SOFTWARE: 'express-reverse-proxy',
+            REQUEST_METHOD: req.method.toUpperCase(),
+            SCRIPT_FILENAME: scriptPath,
+            SCRIPT_NAME: cgiUrlPath + req.path,
+            PATH_INFO: '',
+            QUERY_STRING: url.search ? url.search.slice(1) : '',
+            REMOTE_ADDR: req.ip || '127.0.0.1',
+            CONTENT_TYPE: req.headers['content-type'] || '',
+            CONTENT_LENGTH: req.headers['content-length'] || '0',
+            SERVER_NAME: req.hostname || 'localhost',
+            SERVER_PORT: String(p),
+          };
+          for (const [k, v] of Object.entries(req.headers)) {
+            env[`HTTP_${k.toUpperCase().replace(/-/g, '_')}`] = Array.isArray(v) ? v.join(', ') : v;
+          }
+
+          const interpreter = interps[ext];
+          const command = interpreter || scriptPath;
+          const args = interpreter ? [scriptPath] : [];
+          const child = spawn(command, args, { env, cwd: path.dirname(scriptPath) });
+
+          child.stdin.on('error', (_err) => {});
+          req.pipe(child.stdin);
+
+          let headersParsed = false;
+          let rawBuf = '';
+          child.stdout.on('data', (chunk) => {
+            if (!headersParsed) {
+              rawBuf += chunk.toString('binary');
+              const m = /\r?\n\r?\n/.exec(rawBuf);
+              if (m) {
+                const rawHeaders = rawBuf.substring(0, m.index);
+                const bodyStart = Buffer.from(rawBuf.substring(m.index + m[0].length), 'binary');
+                headersParsed = true;
+                let statusCode = 200;
+                for (const line of rawHeaders.split(/\r?\n/)) {
+                  const colon = line.indexOf(':');
+                  if (colon === -1) continue;
+                  const name = line.substring(0, colon).trim();
+                  const value = line.substring(colon + 1).trim();
+                  if (name.toLowerCase() === 'status') {
+                    statusCode = Number.parseInt(value, 10) || 200;
+                  } else {
+                    res.setHeader(name, value);
+                  }
+                }
+                res.status(statusCode);
+                if (bodyStart.length) res.write(bodyStart);
+              }
+            } else {
+              res.write(chunk);
+            }
+          });
+          child.stdout.on('end', () => {
+            if (!headersParsed) res.status(500).send('CGI script produced no output');
+            else res.end();
+          });
+          child.stderr.on('data', (data) => console.error(`[cgi] ${scriptPath}: ${data}`));
+          child.on('error', (err) => {
+            console.error(`[cgi] spawn error for ${scriptPath}: ${err.message}`);
+            if (!res.headersSent) res.status(500).send(`CGI error: ${err.message}`);
+          });
+          console.log(`[cgi] ${req.method} ${cgiUrlPath}${req.path} → ${scriptPath}`);
+        });
+      }
+    }
+
+    if (siteConfig.upload) {
+      const uploadRaw = siteConfig.upload;
+      const uploadConfigs = Array.isArray(uploadRaw)
+        ? uploadRaw
+        : [typeof uploadRaw === 'string' ? { dir: uploadRaw } : uploadRaw];
+
+      for (const uploadConfig of uploadConfigs) {
+        const uploadUrlPath = uploadConfig.path || '/upload';
+        const uploadDir = path.resolve(configDir, uploadConfig.dir || './uploads');
+        const allowedTypes = uploadConfig.allowedTypes ? new Set(uploadConfig.allowedTypes) : null;
+
+        fs.mkdirSync(uploadDir, { recursive: true });
+
+        const storage = multer.diskStorage({
+          destination: uploadDir,
+          filename: (_req, file, cb) => {
+            const ext = path.extname(file.originalname);
+            const base = path.basename(file.originalname, ext).replace(/[^a-zA-Z0-9_.-]/g, '_');
+            cb(null, `${base}-${Date.now()}-${Math.round(Math.random() * 1e9)}${ext}`);
+          },
+        });
+
+        const fileFilter = allowedTypes
+          ? (_req, file, cb) => {
+              if (allowedTypes.has(file.mimetype)) cb(null, true);
+              else
+                cb(
+                  Object.assign(new Error(`File type not allowed: ${file.mimetype}`), {
+                    status: 400,
+                  }),
+                );
+            }
+          : undefined;
+
+        const limits = {};
+        if (uploadConfig.maxFileSize) limits.fileSize = uploadConfig.maxFileSize;
+        if (uploadConfig.maxFiles) limits.files = uploadConfig.maxFiles;
+
+        const uploader = multer({ storage, limits, fileFilter });
+        const multerMiddleware = uploadConfig.fieldName
+          ? uploader.array(uploadConfig.fieldName)
+          : uploader.any();
+
+        router.post(uploadUrlPath, multerMiddleware, (req, res) => {
+          if (!req.files?.length) return res.status(400).json({ error: 'No files uploaded' });
+          res.json({
+            files: req.files.map((f) => ({
+              file: f.filename,
+              size: f.size,
+              originalName: f.originalname,
+            })),
+          });
+        });
+
+        router.use(uploadUrlPath, express.static(uploadDir));
+        console.log(`[upload] POST ${uploadUrlPath} → ${uploadDir}`);
+      }
+    }
+
     if (siteConfig.proxy) {
       addProxy(router, p, null, siteConfig.proxy);
     }
@@ -417,6 +681,16 @@ configsByPort.forEach((portConfigs, p) => {
       console.log(`[listen] https://localhost:${p}`);
       if (process.send) process.send('ready');
     });
+    if (sslConfig.redirect) {
+      const redirectPort = sslConfig.redirect;
+      const redirectApp = express();
+      redirectApp.use((req, res) => {
+        res.redirect(301, `https://${req.hostname}:${p}${req.url}`);
+      });
+      redirectApp.listen(redirectPort, () => {
+        console.log(`[listen] http redirect :${redirectPort} → https :${p}`);
+      });
+    }
   } else {
     server = app.listen(p, () => {
       console.log(`[listen] http://localhost:${p}`);