@rexaray008/nodeproxy 1.0.1

package/README.md

@@ -0,0 +1,100 @@
+# nodeproxy
+
+A tiny, zero-dependency reverse proxy / web server for Node.js — think "a mini nginx" you can read in one sitting. No native code, no config-language DSL, just JSON.
+
+## Features
+- Host-based virtual routing (`api.example.com` → one backend, `app.example.com` → another)
+- Round-robin load balancing across multiple upstream targets per host
+- Wildcard `*` catch-all host for local dev
+- Static file fallback (serve a folder directly, no backend needed)
+- HTTPS support (bring your own cert/key)
+- Zero npm dependencies — pure Node.js `http`/`https` core modules
+
+## One-command quick start
+
+```bash
+npx nodeproxy start
+```
+
+That's it. On first run this:
+1. Creates `nodeproxy.config.json` in the current directory with sensible defaults
+2. Starts listening on port `8080`, forwarding everything to `http://localhost:3000`
+
+Edit `nodeproxy.config.json` and restart to change routing, or use the CLI helper below.
+
+### Install globally instead
+```bash
+npm install -g nodeproxy
+nodeproxy start
+```
+(publish this folder to npm first, or just `npm link` it locally — see below)
+
+### Run without installing (from this folder)
+```bash
+node bin/cli.js start
+```
+
+## Configuring routes
+
+```bash
+# Route traffic for a host to a backend
+nodeproxy add example.com http://localhost:4000
+
+# Add a second target on the same host for load balancing
+# (just edit the "targets" array in nodeproxy.config.json directly)
+```
+
+Example `nodeproxy.config.json`:
+
+```json
+{
+  "port": 8080,
+  "https": { "enabled": false, "port": 8443, "key": "", "cert": "" },
+  "logging": true,
+  "routes": [
+    { "host": "app.example.com", "targets": ["http://localhost:4000", "http://localhost:4001"], "staticDir": null },
+    { "host": "static.example.com", "targets": [], "staticDir": "./public" },
+    { "host": "*", "targets": ["http://localhost:3000"], "staticDir": null }
+  ]
+}
+```
+
+- `targets` with 2+ entries = automatic round-robin load balancing
+- `staticDir` set + empty `targets` = pure static file server for that host
+- `host: "*"` = catch-all, used when no other host matches (handy for local dev where you don't care about the `Host` header)
+
+## HTTPS
+
+```json
+"https": {
+  "enabled": true,
+  "port": 8443,
+  "key": "/path/to/privkey.pem",
+  "cert": "/path/to/fullchain.pem"
+}
+```
+
+Get free certs from Let's Encrypt (e.g. via `certbot`) and point `key`/`cert` at the files. HTTP and HTTPS run side-by-side.
+
+## Local install / publish
+
+```bash
+npm link          # makes the `nodeproxy` command available globally on this machine
+# or
+npm publish        # to publish it as a real npm package
+```
+
+## Project layout
+```
+bin/cli.js      CLI entrypoint (start / init / add / help)
+lib/server.js   Core proxy engine (routing, load balancing, static serving)
+lib/config.js   Config file loading/creation
+```
+
+## Limitations (intentional — this is a learning-scale project, not production nginx)
+- No automatic Let's Encrypt / ACME renewal — bring your own certs
+- No SNI-based multi-cert HTTPS (one cert for all HTTPS hosts)
+- No rate limiting, caching, or WAF features
+- Round-robin only (no least-connections/weighted balancing)
+
+These are all reasonable next steps if you want to extend it.

package/bin/cli.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+'use strict';
+
+const { loadConfig, saveConfig, ensureConfig, DEFAULT_CONFIG_NAME } = require('../lib/config');
+const { startServer } = require('../lib/server');
+
+function usage() {
+  console.log(`
+nodeproxy - a tiny reverse proxy / web server (like a mini nginx)
+
+Usage:
+  nodeproxy start [--config <file>]        Start the proxy (auto-creates a
+                                            default config on first run)
+  nodeproxy init  [--config <file>]        Just create the config file
+  nodeproxy add <host> <target> [--config <file>]
+                                            Add/update a route, e.g.
+                                            nodeproxy add example.com http://localhost:4000
+  nodeproxy help                           Show this message
+
+One-command quick start:
+  npx nodeproxy start
+`);
+}
+
+function getFlag(args, name) {
+  const i = args.indexOf(name);
+  if (i === -1) return undefined;
+  return args[i + 1];
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const cmd = args[0] || 'start';
+  const configPath = getFlag(args, '--config');
+
+  if (cmd === 'help' || cmd === '-h' || cmd === '--help') {
+    return usage();
+  }
+
+  if (cmd === 'init') {
+    const file = ensureConfig(configPath);
+    console.log(`[nodeproxy] Config ready at ${file}`);
+    return;
+  }
+
+  if (cmd === 'add') {
+    const host = args[1];
+    const target = args[2];
+    if (!host || !target) {
+      console.error('Usage: nodeproxy add <host> <target>');
+      process.exit(1);
+    }
+    const { config, file } = loadConfig(configPath);
+    const existing = config.routes.find(r => r.host === host);
+    if (existing) {
+      existing.targets = [target];
+    } else {
+      config.routes.push({ host, targets: [target], staticDir: null });
+    }
+    saveConfig(config, configPath);
+    console.log(`[nodeproxy] Route added: ${host} -> ${target} (${file})`);
+    return;
+  }
+
+  if (cmd === 'start') {
+    const { config, file } = loadConfig(configPath);
+    console.log(`[nodeproxy] Using config: ${file}`);
+    if (file.endsWith(DEFAULT_CONFIG_NAME)) {
+      console.log('[nodeproxy] (edit this file, or use "nodeproxy add <host> <target>", to change routing)');
+    }
+    startServer(config);
+    return;
+  }
+
+  console.error(`Unknown command: ${cmd}`);
+  usage();
+  process.exit(1);
+}
+
+main();

package/lib/config.js

@@ -0,0 +1,73 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_CONFIG_NAME = 'nodeproxy.config.json';
+
+function defaultConfig() {
+  return {
+    // Port the proxy itself listens on
+    port: 8080,
+
+    // Optional HTTPS. Leave "enabled": false until you have real certs.
+    https: {
+      enabled: false,
+      port: 8443,
+      key: '',   // path to privkey.pem
+      cert: ''   // path to fullchain.pem
+    },
+
+    // Request logging to stdout
+    logging: true,
+
+    // Gzip/deflate pass-through is automatic (we just forward headers),
+    // nothing to configure there.
+
+    // Virtual hosts / routes.
+    // "host" supports "*" as a catch-all for local testing.
+    // "targets" is a list -> automatic round-robin load balancing.
+    routes: [
+      {
+        host: '*',
+        targets: ['http://localhost:3000'],
+        // If set, static files are served from this directory when
+        // no upstream target responds (or as the sole behavior if
+        // targets is empty).
+        staticDir: null
+      }
+    ]
+  };
+}
+
+function configPath(customPath) {
+  return customPath
+    ? path.resolve(process.cwd(), customPath)
+    : path.resolve(process.cwd(), DEFAULT_CONFIG_NAME);
+}
+
+function ensureConfig(customPath) {
+  const file = configPath(customPath);
+  if (!fs.existsSync(file)) {
+    fs.writeFileSync(file, JSON.stringify(defaultConfig(), null, 2) + '\n');
+  }
+  return file;
+}
+
+function loadConfig(customPath) {
+  const file = ensureConfig(customPath);
+  const raw = fs.readFileSync(file, 'utf8');
+  try {
+    return { config: JSON.parse(raw), file };
+  } catch (err) {
+    throw new Error(`Failed to parse ${file}: ${err.message}`);
+  }
+}
+
+function saveConfig(config, customPath) {
+  const file = configPath(customPath);
+  fs.writeFileSync(file, JSON.stringify(config, null, 2) + '\n');
+  return file;
+}
+
+module.exports = { defaultConfig, configPath, ensureConfig, loadConfig, saveConfig, DEFAULT_CONFIG_NAME };

package/lib/server.js

@@ -0,0 +1,168 @@
+'use strict';
+
+const http = require('http');
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const { URL } = require('url');
+
+const MIME = {
+  '.html': 'text/html; charset=utf-8',
+  '.htm': 'text/html; charset=utf-8',
+  '.css': 'text/css; charset=utf-8',
+  '.js': 'application/javascript; charset=utf-8',
+  '.json': 'application/json; charset=utf-8',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.svg': 'image/svg+xml',
+  '.ico': 'image/x-icon',
+  '.txt': 'text/plain; charset=utf-8',
+  '.woff': 'font/woff',
+  '.woff2': 'font/woff2'
+};
+
+// --- round-robin state, one counter per route ---
+const counters = new WeakMap();
+
+function pickTarget(route) {
+  if (!route.targets || route.targets.length === 0) return null;
+  let i = counters.get(route) || 0;
+  const target = route.targets[i % route.targets.length];
+  counters.set(route, i + 1);
+  return target;
+}
+
+function matchRoute(routes, hostHeader) {
+  const host = (hostHeader || '').split(':')[0].toLowerCase();
+  let exact = null;
+  let wildcard = null;
+  for (const r of routes) {
+    if (r.host === host) exact = r;
+    if (r.host === '*') wildcard = r;
+  }
+  return exact || wildcard || null;
+}
+
+function log(config, ...args) {
+  if (config.logging) {
+    console.log(new Date().toISOString(), ...args);
+  }
+}
+
+function serveStatic(dir, reqUrl, res) {
+  const safePath = path.normalize(path.join(dir, decodeURIComponent(reqUrl.split('?')[0])));
+  if (!safePath.startsWith(path.resolve(dir))) {
+    res.writeHead(403);
+    return res.end('Forbidden');
+  }
+  let filePath = safePath;
+  fs.stat(filePath, (err, stat) => {
+    if (err) {
+      res.writeHead(404, { 'Content-Type': 'text/plain' });
+      return res.end('404 Not Found');
+    }
+    if (stat.isDirectory()) {
+      filePath = path.join(filePath, 'index.html');
+    }
+    const ext = path.extname(filePath);
+    fs.readFile(filePath, (err2, data) => {
+      if (err2) {
+        res.writeHead(404, { 'Content-Type': 'text/plain' });
+        return res.end('404 Not Found');
+      }
+      res.writeHead(200, { 'Content-Type': MIME[ext] || 'application/octet-stream' });
+      res.end(data);
+    });
+  });
+}
+
+function proxyRequest(target, req, res, config) {
+  const targetUrl = new URL(target);
+  const options = {
+    hostname: targetUrl.hostname,
+    port: targetUrl.port || (targetUrl.protocol === 'https:' ? 443 : 80),
+    path: req.url,
+    method: req.method,
+    headers: Object.assign({}, req.headers, {
+      'x-forwarded-for': req.socket.remoteAddress,
+      'x-forwarded-proto': req.socket.encrypted ? 'https' : 'http',
+      host: targetUrl.host
+    })
+  };
+
+  const client = targetUrl.protocol === 'https:' ? https : http;
+
+  const proxyReq = client.request(options, (proxyRes) => {
+    res.writeHead(proxyRes.statusCode, proxyRes.headers);
+    proxyRes.pipe(res, { end: true });
+  });
+
+  proxyReq.on('error', (err) => {
+    log(config, 'upstream error:', err.message);
+    if (!res.headersSent) {
+      res.writeHead(502, { 'Content-Type': 'text/plain' });
+    }
+    res.end('502 Bad Gateway');
+  });
+
+  req.pipe(proxyReq, { end: true });
+}
+
+function makeRequestHandler(config) {
+  return function requestHandler(req, res) {
+    const route = matchRoute(config.routes, req.headers.host);
+
+    log(config, req.method, req.headers.host || '-', req.url, '->', route ? route.host : 'no-match');
+
+    if (!route) {
+      res.writeHead(404, { 'Content-Type': 'text/plain' });
+      return res.end('404 Not Found (no matching route for this host)');
+    }
+
+    const target = pickTarget(route);
+
+    if (target) {
+      return proxyRequest(target, req, res, config);
+    }
+
+    if (route.staticDir) {
+      return serveStatic(route.staticDir, req.url, res);
+    }
+
+    res.writeHead(502, { 'Content-Type': 'text/plain' });
+    res.end('502 Bad Gateway (no target configured for this host)');
+  };
+}
+
+function startServer(config) {
+  const handler = makeRequestHandler(config);
+  const servers = [];
+
+  const httpServer = http.createServer(handler);
+  httpServer.listen(config.port, () => {
+    console.log(`[nodeproxy] HTTP listening on port ${config.port}`);
+  });
+  servers.push(httpServer);
+
+  if (config.https && config.https.enabled) {
+    if (!config.https.key || !config.https.cert) {
+      console.warn('[nodeproxy] https.enabled is true but key/cert paths are missing — skipping HTTPS.');
+    } else {
+      const httpsOptions = {
+        key: fs.readFileSync(config.https.key),
+        cert: fs.readFileSync(config.https.cert)
+      };
+      const httpsServer = https.createServer(httpsOptions, handler);
+      httpsServer.listen(config.https.port, () => {
+        console.log(`[nodeproxy] HTTPS listening on port ${config.https.port}`);
+      });
+      servers.push(httpsServer);
+    }
+  }
+
+  return servers;
+}
+
+module.exports = { startServer, matchRoute, pickTarget };

package/nodeproxy.config.json

@@ -0,0 +1,26 @@
+{
+  "port": 8080,
+  "https": {
+    "enabled": false,
+    "port": 8443,
+    "key": "",
+    "cert": ""
+  },
+  "logging": true,
+  "routes": [
+    {
+      "host": "*",
+      "targets": [
+        "http://localhost:3000"
+      ],
+      "staticDir": null
+    },
+    {
+      "host": "https://hirenray.rest",
+      "targets": [
+        "http://localhost:3000"
+      ],
+      "staticDir": null
+    }
+  ]
+}

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@rexaray008/nodeproxy",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "1.0.1",
+  "description": "A lightweight, zero-dependency reverse proxy / web server (like a mini nginx) for Node.js. One command to install, configure and run.",
+  "main": "lib/server.js",
+  "bin": {
+    "nodeproxy": "bin/cli.js"
+  },
+  "scripts": {
+    "start": "node bin/cli.js start"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "license": "MIT",
+  "dependencies": {}
+}