roster-server 2.4.13 → 3.0.0

package/lib/isolated-site.js

@@ -0,0 +1,146 @@
+'use strict';
+
+const path = require('path');
+const { fork } = require('child_process');
+const log = require('lemonlog')('roster');
+
+const WORKER_PATH = path.join(__dirname, 'site-worker.js');
+
+function serializeError(error) {
+    if (!(error instanceof Error)) return { message: String(error) };
+    return { name: error.name, message: error.message, stack: error.stack, code: error.code };
+}
+
+function deserializeError(data) {
+    const error = new Error(data.message);
+    if (data.name) error.name = data.name;
+    if (data.stack) error.stack = data.stack;
+    if (data.code !== undefined) error.code = data.code;
+    return error;
+}
+
+/**
+ * A site that runs in its own process. The main process hands it raw client
+ * sockets; the site process terminates TLS and serves them.
+ */
+class IsolatedSite {
+    /**
+     * @param {object} site
+     * @param {string} site.name - Label for logs and the process title.
+     * @param {object} site.config - Serializable start payload for the site process.
+     * @param {{ restartDelayMs: number, backlog: number }} site.isolation
+     * @param {(servername: string) => Promise<unknown>} site.issueCertificate
+     */
+    constructor({ name, config, isolation, issueCertificate }) {
+        this.name = name;
+        this.config = config;
+        this.isolation = isolation;
+        this.issueCertificate = issueCertificate;
+        this.localPorts = {};
+        this.child = null;
+        this.ready = false;
+        this.pending = 0;
+        this._closing = null;
+        this._resolveClose = null;
+        this._restartTimer = null;
+    }
+
+    start() {
+        return new Promise((resolve, reject) => this._spawn({ resolve, reject }));
+    }
+
+    _spawn(startup) {
+        if (this._closing) {
+            startup?.reject(new Error('Roster is closing or closed'));
+            return;
+        }
+        const child = fork(WORKER_PATH, [], { serialization: 'json' });
+        this.child = child;
+        let failure = null;
+        let closedErrors = null;
+        child.on('message', message => {
+            if (message.type === 'ready') {
+                this.ready = true;
+                if (startup) {
+                    log.info(`(✔) Isolated site ${this.name} (pid ${child.pid})`);
+                    startup.resolve();
+                    startup = null;
+                } else {
+                    log.info(`(✔) Isolated site ${this.name} restarted (pid ${child.pid})`);
+                }
+            } else if (message.type === 'failed') {
+                failure = deserializeError(message.error);
+            } else if (message.type === 'certificate') {
+                this._issueCertificate(child, message);
+            } else if (message.type === 'closed') {
+                closedErrors = message.errors.map(deserializeError);
+            }
+        });
+        child.on('error', error => { failure = failure || error; });
+        child.once('exit', (code, signal) => {
+            this.child = null;
+            this.ready = false;
+            this.pending = 0;
+            const reason = failure || new Error(`Isolated site ${this.name} exited with ${signal || `code ${code}`}`);
+            if (startup) startup.reject(this._closing ? new Error('Roster is closing or closed') : reason);
+            if (this._resolveClose) {
+                this._resolveClose(closedErrors || [reason]);
+                return;
+            }
+            if (startup) return;
+            log.error(`❌ Isolated site ${this.name} stopped: ${reason.message}. Restarting in ${this.isolation.restartDelayMs} ms`);
+            this._restartTimer = setTimeout(() => {
+                this._restartTimer = null;
+                this._spawn(null);
+            }, this.isolation.restartDelayMs);
+        });
+        child.send({ type: 'start', ...this.config, name: this.name, localPorts: this.localPorts });
+    }
+
+    _issueCertificate(child, { id, servername }) {
+        Promise.resolve()
+            .then(() => this.issueCertificate(servername))
+            .then(() => ({}), error => ({ error: serializeError(error) }))
+            .then(result => {
+                if (child.connected) child.send({ type: 'certificate', id, ...result });
+            });
+    }
+
+    /**
+     * Pass an accepted client socket, with the bytes already read from it, to the site process.
+     */
+    handoff(port, head, socket) {
+        const child = this.child;
+        if (!this.ready || this.pending >= this.isolation.backlog) {
+            socket.destroy();
+            return;
+        }
+        this.pending++;
+        child.send({ type: 'connection', port, head: head.toString('base64') }, socket, error => {
+            if (this.child === child) this.pending--;
+            if (error) socket.destroy();
+        });
+    }
+
+    /**
+     * Ask the site process to drain and run its cleanup hooks, then wait for it to exit.
+     * @returns {Promise<Error[]>} Errors reported by the site's shutdown.
+     */
+    close() {
+        if (this._closing) return this._closing;
+        clearTimeout(this._restartTimer);
+        if (!this.child) {
+            this._closing = Promise.resolve([]);
+            return this._closing;
+        }
+        this._closing = new Promise(resolve => { this._resolveClose = resolve; });
+        if (this.child.connected) this.child.send({ type: 'close' });
+        return this._closing;
+    }
+
+    kill() {
+        if (this.child) this.child.kill('SIGKILL');
+    }
+}
+
+module.exports = { IsolatedSite, serializeError };

package/lib/resolve-site-app.js

@@ -5,38 +5,40 @@ const path = require('path');
 const { createStaticHandler } = require('./static-site-handler.js');
 
 /**
- * Resolve a site app for a domain directory.
+ * Locate a site's entry without loading it.
  * Tries index.js / index.mjs / index.cjs first; falls back to static (index.html) if present.
  * @param {string} domainPath - Absolute path to the domain folder (e.g. www/example.com)
  * @param {{ filename?: string }} options - Optional. filename defaults to 'index'.
- * @returns {Promise<{ siteApp: function, type: 'js' | 'static' } | null>}
+ * @returns {{ type: 'js' | 'static', path: string } | null}
  */
-async function resolveSiteApp(domainPath, options = {}) {
+function locateSiteEntry(domainPath, options = {}) {
     const filename = options.filename || 'index';
-    const possibleIndexFiles = ['js', 'mjs', 'cjs'].map(ext => `${filename}.${ext}`);
-
-    for (const indexFile of possibleIndexFiles) {
-        const indexPath = path.join(domainPath, indexFile);
-        if (fs.existsSync(indexPath)) {
-            try {
-                let siteApp = await import(indexPath).catch(() => {
-                    return require(indexPath);
-                });
-                siteApp = siteApp.default || siteApp;
-                return { siteApp, type: 'js' };
-            } catch (err) {
-                throw err;
-            }
-        }
+    for (const extension of ['js', 'mjs', 'cjs']) {
+        const indexPath = path.join(domainPath, `${filename}.${extension}`);
+        if (fs.existsSync(indexPath)) return { type: 'js', path: indexPath };
     }
-
     const indexHtmlPath = path.join(domainPath, 'index.html');
-    if (fs.existsSync(indexHtmlPath)) {
-        const siteApp = createStaticHandler(domainPath);
-        return { siteApp, type: 'static' };
-    }
-
+    if (fs.existsSync(indexHtmlPath)) return { type: 'static', path: indexHtmlPath };
     return null;
 }
 
-module.exports = { resolveSiteApp };
+/**
+ * Resolve a site app for a domain directory.
+ * @param {string} domainPath - Absolute path to the domain folder (e.g. www/example.com)
+ * @param {{ filename?: string }} options - Optional. filename defaults to 'index'.
+ * @returns {Promise<{ siteApp: function, type: 'js' | 'static' } | null>}
+ */
+async function resolveSiteApp(domainPath, options = {}) {
+    const entry = locateSiteEntry(domainPath, options);
+    if (!entry) return null;
+    if (entry.type === 'static') {
+        return { siteApp: createStaticHandler(domainPath), type: 'static' };
+    }
+    let siteApp = await import(entry.path).catch(() => {
+        return require(entry.path);
+    });
+    siteApp = siteApp.default || siteApp;
+    return { siteApp, type: 'js' };
+}
+
+module.exports = { locateSiteEntry, resolveSiteApp };

package/lib/site-worker.js

@@ -0,0 +1,145 @@
+'use strict';
+
+// Entry point of an isolated site process, forked by IsolatedSite.
+const https = require('https');
+const Roster = require('../index.js');
+const { resolveSiteApp } = require('./resolve-site-app.js');
+const { serializeError } = require('./isolated-site.js');
+const log = require('lemonlog')('roster');
+
+class SiteWorkerRoster extends Roster {
+    constructor(site) {
+        super({ ...site.options, isolation: false, autoCertificates: false, handleSignals: false });
+        this._site = site;
+        this._httpsServers = new Map();
+        this._certificateRequests = new Map();
+        this._nextCertificateRequest = 0;
+        // Certificates are issued by the main process, which owns the ACME runtime.
+        this._greenlockRuntime = { get: ({ servername }) => this._requestCertificate(servername) };
+    }
+
+    async loadSites() {
+        const { path: sitePath, keys } = this._site;
+        let resolved;
+        try {
+            resolved = await resolveSiteApp(sitePath, { filename: this.filename });
+        } catch (error) {
+            log.warn(`⚠️  Error loading site in ${sitePath}:`, error);
+            return;
+        }
+        if (!resolved) {
+            log.warn(`⚠️  No index file (js/mjs/cjs or index.html) found in ${sitePath}`);
+            return;
+        }
+        for (const key of keys) this.sites[key] = resolved.siteApp;
+    }
+
+    generateConfigJson() {}
+
+    assignPortToDomain(domain, port) {
+        return this._site.localPorts[`${domain}:${port}`];
+    }
+
+    _requestCertificate(servername) {
+        const id = this._nextCertificateRequest++;
+        return new Promise((resolve, reject) => {
+            this._certificateRequests.set(id, { resolve, reject });
+            process.send({ type: 'certificate', id, servername });
+        });
+    }
+
+    rejectCertificateRequests() {
+        for (const request of this._certificateRequests.values()) {
+            request.reject(new Error('Main process disconnected'));
+        }
+        this._certificateRequests.clear();
+    }
+
+    settleCertificate({ id, error }) {
+        const request = this._certificateRequests.get(id);
+        this._certificateRequests.delete(id);
+        if (error) request.reject(new Error(error.message));
+        else request.resolve();
+    }
+
+    serveHttps() {
+        const ports = new Set(this._site.keys.map(key => this.parseDomainWithPort(key).port));
+        for (const port of ports) {
+            // Only the default port issues missing certificates, as in the main process.
+            const issue = port === this.defaultPort;
+            const server = https.createServer({
+                minVersion: this.tlsMinVersion,
+                maxVersion: this.tlsMaxVersion,
+                SNICallback: (servername, callback) => {
+                    this._getSecureContext(servername, issue).then(context => callback(null, context), callback);
+                }
+            });
+            this.attach(server, { port });
+            this._ownedServers.add(server);
+            this._httpsServers.set(port, server);
+        }
+    }
+
+    accept(port, head, socket) {
+        const server = this._httpsServers.get(port);
+        if (this._closing || !server) {
+            socket.destroy();
+            return;
+        }
+        this._sockets.add(socket);
+        socket.once('close', () => this._sockets.delete(socket));
+        socket.unshift(head);
+        server.emit('connection', socket);
+    }
+}
+
+let roster = null;
+let closing = false;
+
+async function start(site) {
+    process.title = `roster ${site.name}`;
+    roster = new SiteWorkerRoster(site);
+    try {
+        for (const plugin of site.plugins) {
+            roster.use(require(plugin.module)[plugin.export](plugin.options));
+        }
+        if (roster.local) {
+            await roster.start();
+        } else {
+            await roster.init();
+            roster.serveHttps();
+        }
+        process.send({ type: 'ready' });
+    } catch (error) {
+        if (closing) return;
+        process.send({ type: 'failed', error: serializeError(error) }, () => process.exit(1));
+    }
+}
+
+async function shutdown() {
+    if (closing) return;
+    closing = true;
+    let errors = [];
+    if (roster && !process.connected) roster.rejectCertificateRequests();
+    try {
+        if (roster) await roster.close();
+    } catch (error) {
+        errors = error instanceof AggregateError ? error.errors : [error];
+    }
+    if (!process.connected) process.exit(0);
+    process.send({ type: 'closed', errors: errors.map(serializeError) }, () => process.exit(0));
+}
+
+// The main process coordinates shutdown; a terminal or process manager that
+// signals the whole process group must not cut this site's drain short.
+process.on('SIGINT', () => {});
+process.on('SIGTERM', () => {});
+process.on('disconnect', shutdown);
+process.on('message', (message, handle) => {
+    if (message.type === 'start') start(message);
+    else if (message.type === 'connection') {
+        if (roster) roster.accept(message.port, Buffer.from(message.head, 'base64'), handle);
+        else handle.destroy();
+    } else if (message.type === 'certificate') roster.settleCertificate(message);
+    else if (message.type === 'close') shutdown();
+});

package/package.json

@@ -1,54 +1,54 @@
 {
-  "name": "roster-server",
-  "version": "2.4.13",
-  "description": "👾 RosterServer - A domain host router to host multiple HTTPS.",
-  "main": "index.js",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/clasen/RosterServer.git"
-  },
-  "keywords": [
-    "greenlock",
-    "https",
-    "domain",
-    "multi-domain",
-    "letsencrypt",
-    "hosting",
-    "ssl",
-    "host",
-    "vhost",
-    "virtual-host",
-    "socket.io",
-    "websocket",
-    "express",
-    "greenlock-express",
-    "shotx",
-    "bun",
-    "clasen"
-  ],
-  "author": "Martin Clasen",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/clasen/RosterServer/issues"
-  },
-  "homepage": "https://github.com/clasen/RosterServer#readme",
-  "dependencies": {
-    "@greenlock/manager": "^3.1.0",
-    "@root/acme": "^3.1.0",
-    "@root/csr": "^0.8.1",
-    "@root/encoding": "^1.0.1",
-    "@root/keypairs": "^0.10.0",
-    "@root/mkdirp": "^1.0.0",
-    "@root/request": "^1.6.1",
-    "acme-dns-01-cli": "^3.0.7",
-    "acme-http-01-standalone": "^3.0.5",
-    "cert-info": "^1.5.1",
-    "greenlock-store-fs": "^3.2.2",
-    "lemonlog": "^1.2.0",
-    "redirect-https": "^1.3.1",
-    "safe-replace": "^1.1.0"
-  },
-  "scripts": {
-    "test": "node --test 'test/**/*.test.js'"
-  }
-}
+    "name": "roster-server",
+    "version": "3.0.0",
+    "description": "👾 RosterServer - A domain host router to host multiple HTTPS.",
+    "main": "index.js",
+    "scripts": {
+        "test": "node --test 'test/**/*.test.js'"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/clasen/RosterServer.git"
+    },
+    "keywords": [
+        "greenlock",
+        "https",
+        "domain",
+        "multi-domain",
+        "letsencrypt",
+        "hosting",
+        "ssl",
+        "host",
+        "vhost",
+        "virtual-host",
+        "socket.io",
+        "websocket",
+        "express",
+        "greenlock-express",
+        "shotx",
+        "bun",
+        "clasen"
+    ],
+    "author": "Martin Clasen",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/clasen/RosterServer/issues"
+    },
+    "homepage": "https://github.com/clasen/RosterServer#readme",
+    "dependencies": {
+        "@greenlock/manager": "^3.1.0",
+        "@root/acme": "^3.1.0",
+        "@root/csr": "^0.8.1",
+        "@root/encoding": "^1.0.1",
+        "@root/keypairs": "^0.10.0",
+        "@root/mkdirp": "^1.0.0",
+        "@root/request": "^1.6.1",
+        "acme-dns-01-cli": "^3.0.7",
+        "acme-http-01-standalone": "^3.0.5",
+        "cert-info": "^1.5.1",
+        "greenlock-store-fs": "^3.2.2",
+        "lemonlog": "^1.2.0",
+        "redirect-https": "^1.3.1",
+        "safe-replace": "^1.1.0"
+    }
+}

package/plugins/scanner-blocker.js

@@ -116,7 +116,7 @@ function createScannerBlocker(options = {}) {
         if (onBlock) onBlock(details);
     }
 
-    return function scannerBlocker(req, res, context = {}) {
+    function scannerBlocker(req, res, context = {}) {
         const timestamp = clock();
         const ip = clientIp(req, trustProxy);
         let state = ip ? clients.get(ip) : null;
@@ -163,7 +163,15 @@ function createScannerBlocker(options = {}) {
             bannedUntil
         });
         return true;
+    }
+
+    // Lets Roster recreate this plugin, with its own ban state, in each isolated site process.
+    scannerBlocker[Symbol.for('roster-server.plugin-source')] = {
+        module: __filename,
+        export: 'createScannerBlocker',
+        options
     };
+    return scannerBlocker;
 }
 
 module.exports = { createScannerBlocker };

package/skills/roster-server/SKILL.md

@@ -52,11 +52,11 @@ module.exports = (server) => {
 
 Socket.IO wraps the request listeners and captures the returned handler as its fallback. Do not add a manual endpoint exclusion to that handler; use `io.path()` when application code needs the path. Do not use `io.opts.path`.
 
-A virtual request listener owns its request even before it ends the response. Roster does not infer that an asynchronous listener declined the request. Thrown/rejected handler errors produce 500 or destroy an already-started response. Virtual servers share a process; they are not process isolation boundaries.
+A virtual request listener owns its request even before it ends the response. Roster does not infer that an asynchronous listener declined the request. Thrown/rejected handler errors produce 500 or destroy an already-started response. Virtual servers are not process boundaries. `start()` runs each site directory in its own process unless `isolation: false` is set. Factories passed to `register()` stay in the main process; register a site directory to isolate one.
 
 ## Shutdown
 
-- Connect `await roster.close()` to the application's existing shutdown flow. Roster does not install signal handlers or terminate processes.
+- Connect `await roster.close()` to the application's existing shutdown flow, or explicitly set `handleSignals: true` for automatic `SIGINT`/`SIGTERM` cleanup. It defaults to `false`; listeners are installed during `init()`/`start()` and removed after closure, including failure. Repeated signals during closure do not repeat hooks. Existing signal listeners are preserved; shutdown errors are logged and set `process.exitCode = 1`. Roster never forces process termination.
 - Register `virtualServer.onClose(fn)` for each site's timers, databases, and other resources. Return/await its cleanup Promise; wrap callback APIs when needed.
 - Roster signals virtual `close` at shutdown start to release integrations such as long polling, closes routed WebSockets, drains HTTP, then runs cleanup hooks concurrently. Put dependent cleanup steps in one hook.
 - Hooks run once. Failures are aggregated after other hooks are attempted. `closeTimeoutMs` bounds the complete operation; timeout cannot cancel arbitrary user Promises or in-flight ACME work.