roster-server 3.4.0 → 3.4.2

package/README.md

@@ -28,7 +28,7 @@ await roster.start();
 console.log(roster.getUrl('example.com'));
 ```
 
-Local mode binds to `localhost`, skips certificates, and assigns domain ports within `minLocalPort`–`maxLocalPort` (default `4000`–`9999`). Assignments use a domain hash and resolve collisions within the instance; they do not probe for available OS ports. A bind failure rejects startup. Read the assigned URL with `getUrl()` instead of hardcoding a sample port.
+Local mode binds to `hostname` (default `::`, IPv4 and IPv6 on all interfaces), skips certificates, and assigns domain ports within `minLocalPort`–`maxLocalPort` (default `4000`–`9999`). Assignments use a domain hash and resolve collisions within the instance; they do not probe for available OS ports. A bind failure rejects startup. Read the assigned URL with `getUrl()` instead of hardcoding a sample port.
 
 For production HTTPS, use a real contact email, public DNS pointing to the host, and explicit storage paths:
 
@@ -313,7 +313,7 @@ Pass operational settings through the constructor, using the consuming applicati
 | `filename` | `index` | Script entry basename, without extension. |
 | `local` | `false` | Local HTTP mode with assigned ports and no certificates. |
 | `port` | `443` | Default port for manual registrations and routing helpers. |
-| `hostname` | `::` | Production bind address; local mode uses `localhost`. |
+| `hostname` | `::` | Bind address in production and local mode. |
 | `minLocalPort`, `maxLocalPort` | `4000`, `9999` | Inclusive local assignment range. |
 | `staging` | `false` | ACME staging environment. |
 | `autoCertificates` | `true` | Certificate runtime during `init()`; disable for serving-only workers. |

package/index.js

@@ -785,6 +785,12 @@ class Roster {
         }
     }
 
+    // Names the production site and the local URL that serves it, e.g. `example.com:3334 → tcp://localhost:6702`.
+    _describeLocalSite(domain, sitePort, localPort, scheme) {
+        const site = `${domain}${sitePort !== this.defaultPort ? ':' + sitePort : ''}`;
+        return `${site} → ${scheme}://${localHostForDomain(normalizeDomainForLocalHost(domain))}:${localPort}`;
+    }
+
     parseDomainWithPort(domainString) {
         const parts = domainString.split(':');
         if (parts.length === 2) {
@@ -950,6 +956,7 @@ class Roster {
         const plugins = this.plugins.map(isolatedPluginSource);
         const options = {
             local: this.local,
+            hostname: this.hostname,
             port: this.defaultPort,
             filename: this.filename,
             greenlockStorePath: this.greenlockStorePath,
@@ -1630,9 +1637,8 @@ class Roster {
                     virtualServer.processUpgrade(req, socket, head);
                 });
 
-                await this._listen(httpServer, port, 'localhost');
-                const cleanDomain = normalizeDomainForLocalHost(domain);
-                log.info(`🌐 ${domain} → http://${localHostForDomain(cleanDomain)}:${port}`);
+                await this._listen(httpServer, port, this.hostname);
+                log.info(`🌐 ${this._describeLocalSite(domain, Number(sitePort), port, 'http')}`);
             }
         }
 

package/lib/site-worker.js

@@ -56,15 +56,16 @@ class SiteWorkerRoster extends Roster {
         for (const key of this._site.keys) {
             if (key.startsWith('www.')) continue;
             const { domain, port } = this.parseDomainWithPort(key);
+            const localPort = this._site.localPorts[`${domain}:${port}`];
             const server = net.createServer({ pauseOnConnect: true });
-            const listening = this._listen(server, this._site.localPorts[`${domain}:${port}`], 'localhost');
+            const listening = this._listen(server, localPort, this.hostname);
             server.on('connection', socket => {
                 // The site owns the connection from here; it may pass it to another process.
                 this._sockets.delete(socket);
                 this._handOff(head, socket);
             });
             await listening;
-            log.info(`🌐 ${domain} → tcp://localhost:${this._site.localPorts[`${domain}:${port}`]} (socket site)`);
+            log.info(`🌐 ${this._describeLocalSite(domain, port, localPort, 'tcp')} (socket site)`);
         }
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "roster-server",
-    "version": "3.4.0",
+    "version": "3.4.2",
     "description": "👾 RosterServer - A domain host router to host multiple HTTPS.",
     "main": "index.js",
     "scripts": {

package/skills/roster-server/SKILL.md

@@ -9,7 +9,7 @@ Use this skill to configure a consuming application. Keep its existing configura
 
 ## Choose the lifecycle owner
 
-- **Local development:** `new Roster({ local: true, wwwPath: absolutePath })`, register sites, then `await roster.start()`. Local mode binds to `localhost` and assigns ports; read URLs with `roster.getUrl(domain)` after startup.
+- **Local development:** `new Roster({ local: true, wwwPath: absolutePath })`, register sites, then `await roster.start()`. Local mode binds to `hostname` (default `::`, IPv4 and IPv6) and assigns ports; read URLs with `roster.getUrl(domain)` after startup.
 - **Standalone HTTPS:** set the real `email`, absolute `wwwPath` and `greenlockStorePath`; leave `local` false. `await roster.start()` owns ACME HTTP on port 80 and the configured HTTPS listeners. A different HTTPS port does not eliminate the need for port 80.
 - **External server/worker:** `await roster.init()`, then `roster.attach(server, { port })` or an HTTPS helper. The caller owns listening and closing that server. `port` on `attach()` selects the routing table, not the TCP port.
 - **Serving-only worker:** use `autoCertificates: false` with `init()` and `createServingHttpsServer({ servername })`. A separate manager must provide certificates first. Calling `start()` still enables the standalone ACME lifecycle.

package/test/isolation.test.js

@@ -91,9 +91,9 @@ function get(port, servername, { pathname = '/', headers = {} } = {}) {
     });
 }
 
-function localGet(port, pathname = '/') {
+function localGet(port, pathname = '/', hostname = 'localhost') {
     return new Promise((resolve, reject) => {
-        http.get({ hostname: 'localhost', port, path: pathname, agent: false }, res => {
+        http.get({ hostname, port, path: pathname, agent: false }, res => {
             let body = '';
             res.on('data', chunk => { body += chunk; });
             res.on('end', () => resolve({ status: res.statusCode, body }));
@@ -315,6 +315,9 @@ it('isolates directory sites in local mode, including aliases and request plugin
     assert.equal(alias.pid, site.pid);
     assert.notEqual(other.pid, site.pid);
     assert.deepEqual(await localGet(port('other.example'), '/wp-login.php'), { status: 404, body: 'Not Found' });
+    for (const address of ['127.0.0.1', '::1']) {
+        assert.equal(JSON.parse((await localGet(port('site.example'), '/', address)).body).pid, site.pid);
+    }
 });
 
 it('serves a site module already loaded by the main process from that process', { timeout: 20000 }, async t => {
@@ -479,6 +482,7 @@ it('gives a socket site plain connections on its local port', { timeout: 20000 }
     await roster.start();
     const { port } = new URL(roster.getUrl('raw.example'));
     assert.notEqual(JSON.parse((await localGet(port)).body).pid, process.pid);
+    for (const address of ['127.0.0.1', '::1']) assert.equal((await localGet(port, '/', address)).status, 200);
     assert.equal(fs.readFileSync(`${marker}.head`, 'utf8'), '0');
     await roster.close();
     assert.equal(fs.readFileSync(marker, 'utf8'), 'closed');

package/test/lifecycle.test.js

@@ -94,7 +94,7 @@ it('waits for listening, shares start, and closes owned servers once', async t =
 
 it('rejects bind failures and rolls back already opened ports', async t => {
     const blocker = http.createServer();
-    await new Promise(resolve => blocker.listen(0, 'localhost', resolve));
+    await new Promise(resolve => blocker.listen(0, '::', resolve));
     t.after(() => new Promise(resolve => blocker.close(resolve)));
     const roster = createRoster(t);
     const ports = [0, blocker.address().port];

package/test/roster-server.test.js

@@ -372,6 +372,14 @@ describe('Roster', () => {
         });
     });
 
+    describe('local site description', () => {
+        it('names the production port only when it differs from the default', () => {
+            const roster = new Roster({ local: true });
+            assert.strictEqual(roster._describeLocalSite('truco.example.com', 443, 6701, 'http'), 'truco.example.com → http://truco.localhost:6701');
+            assert.strictEqual(roster._describeLocalSite('truco.example.com', 3334, 6702, 'tcp'), 'truco.example.com:3334 → tcp://truco.localhost:6702');
+        });
+    });
+
     describe('getUrl (exact domain)', () => {
         it('returns http://localhost:PORT in local mode for registered domain', () => {
             const roster = new Roster({ local: true });