roster-server 1.1.8

package/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

package/README.md

@@ -0,0 +1,128 @@
+# 👾 RosterServer
+
+**Because hosting multiple HTTPS sites has never been easier!**
+
+Welcome to **RosterServer**, the ultimate domain host router with automatic HTTPS and virtual hosting. Why juggle multiple servers when you can have one server to rule them all? 😉
+
+## ✨ Features
+
+- **Automatic HTTPS** with Let's Encrypt via Greenlock.
+- **Dynamic Site Loading**: Just drop your Node.js apps in the `www` folder.
+- **Virtual Hosting**: Serve multiple domains from a single server.
+- **Automatic Redirects**: Redirect `www` subdomains to the root domain.
+- **Zero Configuration**: Well, almost zero. Just a tiny bit of setup.
+
+## 📦 Installation
+
+```bash
+npm install roster-server
+```
+
+## 🛠️ Usage
+
+### Directory Structure
+
+Your project should look something like this:
+
+```
+/srv/
+├── roster/server.js
+└── www/
+    ├── example.com/
+    │   └── index.js
+    └── anotherdomain.com/
+        └── index.js
+```
+
+### Setting Up Your Server
+
+```javascript
+// /srv/roster/server.js
+const Roster = require('roster-express');
+
+const options = {
+    maintainerEmail: 'admin@example.com',
+    wwwPath: '/srv/www', // Path to your 'www' directory (default: '../www')
+    staging: false // Set to true for Let's Encrypt staging environment
+};
+
+const server = new Roster(options);
+server.start();
+```
+
+### Your Site Handlers
+
+Each domain should have its own folder under `www`, containing an `index.js` that exports a request handler function.
+
+For example, `www/example.com/index.js`:
+
+```javascript
+module.exports = (req, res) => {
+    res.writeHead(200, { 'Content-Type': 'text/plain' });
+    res.end('Hello from example.com!');
+};
+```
+
+### Running the Server
+
+```bash
+# /srv/roster/server.js
+node server.js
+```
+
+And that's it! Your server is now hosting multiple HTTPS-enabled sites. 🎉
+
+## 🤯 But Wait, There's More!
+
+### Automatic SSL Certificate Management
+
+RosterExpress uses [greenlock-express](https://www.npmjs.com/package/greenlock-express) to automatically obtain and renew SSL certificates from Let's Encrypt. No need to manually manage certificates ever again. Unless you enjoy that sort of thing. 🧐
+
+### Redirects from `www`
+
+All requests to `www.yourdomain.com` are automatically redirected to `yourdomain.com`. Because who needs the extra three characters? 😏
+
+### Dynamic Site Loading
+
+Add a new site? Just drop it into the `www` folder with an `index.js` file, and RosterExpress will handle the rest. No need to restart the server. Well, you might need to restart the server. But that's what `nodemon` is for, right? 😅
+
+## ⚙️ Configuration Options 
+
+When creating a new `RosterExpress` instance, you can pass the following options:
+
+- `maintainerEmail` (string): Your email for Let's Encrypt notifications.
+- `wwwPath` (string): Path to your `www` directory containing your sites.
+- `greenlockConfigDir` (string): Directory for Greenlock configuration.
+- `staging` (boolean): Set to `true` to use Let's Encrypt's staging environment (for testing).
+
+## 🧂 A Touch of Magic
+
+You might be thinking, "But setting up HTTPS and virtual hosts is supposed to be complicated and time-consuming!" Well, not anymore. With RosterExpress, you can get back to writing code that matters, like defending Earth from alien invaders! 👾👾👾
+
+
+## 🤝 Contributing
+
+Feel free to submit issues or pull requests. Or don't. I'm not your boss. 😜
+
+If you find any issues or have suggestions for improvement, please open an issue or submit a pull request on the [GitHub repository](https://github.com/clasen/RosterExpress).
+
+## 🙏 Acknowledgments 
+
+- [Node.js](https://nodejs.org/) - JavaScript runtime
+- [Greenlock](https://git.coolaj86.com/coolaj86/greenlock.js) - Fully-featured ACME client
+
+## 📄 License
+
+The MIT License (MIT)
+
+Copyright (c) Martin Clasen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---
+
+Happy hosting! 🎈

package/demo/roster/server.js

@@ -0,0 +1,9 @@
+const Roster = require('../../index.js');
+const path = require('path');
+
+const roster = new Roster({
+    maintainerEmail: 'mclasen@blyts.com',
+    wwwPath: path.join(__dirname, '..', 'www'),
+});
+
+roster.start();

package/demo/www/eample.com/index.js

@@ -0,0 +1,28 @@
+module.exports = (req, res) => {
+    // Send a simple response
+    res.writeHead(200, { 'Content-Type': 'text/html' });
+    res.end(`
+        <!DOCTYPE html>
+        <html>
+            <head>
+                <title>Example Site</title>
+                <style>
+                    body {
+                        font-family: Arial, sans-serif;
+                        max-width: 800px;
+                        margin: 40px auto;
+                        padding: 0 20px;
+                        line-height: 1.6;
+                    }
+                    h1 { color: #333; }
+                </style>
+            </head>
+            <body>
+                <h1>Welcome to Example.com</h1>
+                <p>This is a sample page served by the Roster server.</p>
+                <p>Request received from: ${req.headers.host}</p>
+                <p>URL path: ${req.url}</p>
+            </body>
+        </html>
+    `);
+};

package/index.js

@@ -0,0 +1,219 @@
+const fs = require('fs');
+const path = require('path');
+const Greenlock = require('greenlock-express');
+
+class Roster {
+    constructor(options = {}) {
+        this.maintainerEmail = options.maintainerEmail || 'admin@example.com';
+        this.wwwPath = options.wwwPath || path.join(__dirname, '..', '..', '..', 'www');
+        this.greenlockConfigDir = options.greenlockConfigDir || path.join(__dirname, '..', '..', 'greenlock.d');
+        this.staging = options.staging || false; // Set to true for testing
+        this.domains = [];
+        this.sites = {};
+    }
+
+    // Function to dynamically load domain applications
+    loadSites() {
+        fs.readdirSync(this.wwwPath, { withFileTypes: true })
+            .filter(dirent => dirent.isDirectory())
+            .forEach((dirent) => {
+                const domain = dirent.name;
+                const domainPath = path.join(this.wwwPath, domain);
+                
+                // Check for different module file extensions
+                const possibleIndexFiles = ['index.js', 'index.mjs', 'index.cjs'];
+                let siteApp;
+                let loadedFile;
+
+                for (const indexFile of possibleIndexFiles) {
+                    const indexPath = path.join(domainPath, indexFile);
+                    if (fs.existsSync(indexPath)) {
+                        siteApp = require(indexPath);
+                        loadedFile = indexFile;
+                        break;
+                    }
+                }
+
+                if (siteApp) {
+                    // Add the main domain and 'www' subdomain by default
+                    const domainEntries = [domain, `www.${domain}`];
+                    this.domains.push(...domainEntries);
+                    domainEntries.forEach(d => {
+                        this.sites[d] = siteApp;
+                    });
+
+                    console.log(`✅ Loaded site: ${domain} (using ${loadedFile})`);
+                } else {
+                    console.warn(`⚠️ No index file (js/mjs/cjs) found in ${domainPath}`);
+                }
+            });
+    }
+
+    generateConfigJson() {
+        const configDir = this.greenlockConfigDir;
+        const configPath = path.join(configDir, 'config.json');
+
+        // Create the directory if it does not exist
+        if (!fs.existsSync(configDir)) {
+            fs.mkdirSync(configDir, { recursive: true });
+        }
+
+        const sitesConfig = [];
+        const uniqueDomains = new Set();
+
+        this.domains.forEach(domain => {
+            const rootDomain = domain.replace(/^www\./, '');
+            uniqueDomains.add(rootDomain);
+        });
+
+        // Read the existing config.json if it exists
+        let existingConfig = {};
+        if (fs.existsSync(configPath)) {
+            // Read the current content
+            const currentConfigContent = fs.readFileSync(configPath, 'utf8');
+            existingConfig = JSON.parse(currentConfigContent);
+        }
+
+        uniqueDomains.forEach(domain => {
+            const altnames = [domain];
+            if ((domain.match(/\./g) || []).length < 2) {
+                altnames.push(`www.${domain}`);
+            }
+
+            // Find the existing site to preserve renewAt
+            let existingSite = null;
+            if (existingConfig.sites) {
+                existingSite = existingConfig.sites.find(site => site.subject === domain);
+            }
+
+            const siteConfig = {
+                subject: domain,
+                altnames: altnames
+            };
+
+            // Preserve renewAt if it exists
+            if (existingSite && existingSite.renewAt) {
+                siteConfig.renewAt = existingSite.renewAt;
+            }
+
+            sitesConfig.push(siteConfig);
+        });
+
+        const newConfig = {
+            defaults: {
+                store: {
+                    module: "greenlock-store-fs",
+                    basePath: this.greenlockConfigDir
+                },
+                challenges: {
+                    "http-01": {
+                        module: "acme-http-01-standalone"
+                    }
+                },
+                renewOffset: "-45d",
+                renewStagger: "3d",
+                accountKeyType: "EC-P256",
+                serverKeyType: "RSA-2048",
+                subscriberEmail: this.maintainerEmail
+            },
+            sites: sitesConfig
+        };
+
+        // Check if config.json already exists and compare
+        if (fs.existsSync(configPath)) {
+            // Read the current content
+            const currentConfigContent = fs.readFileSync(configPath, 'utf8');
+            const currentConfig = JSON.parse(currentConfigContent);
+
+            // Compare the entire configurations
+            const newConfigContent = JSON.stringify(newConfig, null, 2);
+            const currentConfigContentFormatted = JSON.stringify(currentConfig, null, 2);
+
+            if (newConfigContent === currentConfigContentFormatted) {
+                console.log('ℹ️ Configuration has not changed. config.json will not be overwritten.');
+                return; // Exit the function without overwriting
+            } else {
+                console.log('🔄 Configuration has changed. config.json will be updated.');
+            }
+        } else {
+            console.log('🆕 config.json does not exist. A new one will be created.');
+        }
+
+        // Write the new config.json
+        fs.writeFileSync(configPath, JSON.stringify(newConfig, null, 2));
+        console.log(`📁 config.json generated at ${configPath}`);
+    }
+
+    handleRequest(req, res) {
+        const host = req.headers.host || '';
+        
+        // Handle www redirect
+        if (host.startsWith('www.')) {
+            const newHost = host.slice(4);
+            res.writeHead(301, { Location: `https://${newHost}${req.url}` });
+            res.end();
+            return;
+        }
+
+        // Find and execute the appropriate site handler
+        const siteApp = this.sites[host];
+        if (siteApp) {
+            siteApp(req, res);
+        } else {
+            res.writeHead(404);
+            res.end('Site not found');
+        }
+    }
+
+    initGreenlock() {
+        Greenlock.init({
+            packageRoot: __dirname,
+            configDir: this.greenlockConfigDir,
+            maintainerEmail: this.maintainerEmail,
+            cluster: false,
+            staging: this.staging,
+            manager: { module: "@greenlock/manager" },
+            approveDomains: (opts, certs, cb) => {
+                // If certs is defined, we already have a certificate and are renewing it
+                if (certs) {
+                    opts.domains = certs.altnames;
+                } else {
+                    // If it's a new request, verify if the domain is in our list
+                    if (this.domains.includes(opts.domain)) {
+                        opts.email = this.maintainerEmail;
+                        opts.agreeTos = true;
+                        opts.domains = [opts.domain];
+                    } else {
+                        console.warn(`⚠️ Domain not approved: ${opts.domain}`);
+                        return cb(new Error(`Domain not approved: ${opts.domain}`));
+                    }
+                }
+                cb(null, { options: opts, certs });
+            }
+        }).ready((glx) => {
+            // Setup HTTPS server
+            const httpsServer = glx.httpsServer(null, (req, res) => {
+                this.handleRequest(req, res);
+            });
+
+            httpsServer.listen(443, "0.0.0.0", () => {
+                console.info("HTTPS Listening on", httpsServer.address());
+            });
+
+            // Setup HTTP server for ACME challenges
+            const httpServer = glx.httpServer();
+
+            httpServer.listen(80, "0.0.0.0", () => {
+                console.info("HTTP Listening on", httpServer.address());
+            });
+        });
+    }
+
+    start() {
+        this.loadSites();
+        this.generateConfigJson();
+        this.initGreenlock();
+    }
+}
+
+module.exports = Roster;

package/package.json

@@ -0,0 +1,34 @@
+{
+    "name": "roster-server",
+    "version": "1.1.8",
+    "description": "👾 RosterServer - A domain host router to host multiple HTTPS.",
+    "main": "index.js",
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/clasen/RosterExpress.git"
+    },
+    "keywords": [
+        "greenlock",
+        "https",
+        "domain",
+        "multi-domain",
+        "letsencrypt",
+        "hosting",
+        "ssl",
+        "host",
+        "greenlock-express",
+        "clasen"
+    ],
+    "author": "Martin Clasen",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/clasen/RosterExpress/issues"
+    },
+    "homepage": "https://github.com/clasen/RosterExpress#readme",
+    "dependencies": {
+        "greenlock-express": "^4.0.3"
+    }
+}