solid-server 5.6.9-beta

package/README.md

@@ -0,0 +1,453 @@
+# solid-server in Node
+
+[![](https://img.shields.io/badge/project-Solid-7C4DFF.svg?style=flat-square)](https://github.com/solid/solid)
+[![Build Status](https://travis-ci.org/solid/node-solid-server.svg?branch=master&style=flat-square)](https://travis-ci.org/solid/node-solid-server)
+[![NPM Version](https://img.shields.io/npm/v/solid-server.svg?style=flat-square)](https://npm.im/solid-server)
+[![Gitter chat](https://img.shields.io/badge/gitter-join%20chat%20%E2%86%92-brightgreen.svg?style=flat-square)](http://gitter.im/solid/node-solid-server)
+
+> [Solid](https://github.com/solid) server in [NodeJS](https://nodejs.org/)
+
+`solid-server` lets you run a Solid server on top of the file-system. You can use it as a [command-line tool](https://github.com/solid/node-solid-server/blob/master/README.md#command-line-usage) (easy) or as a [library](https://github.com/solid/node-solid-server/blob/master/README.md#library-usage) (advanced).
+
+## Solid Features supported
+- [x] [Linked Data Platform](http://www.w3.org/TR/ldp/)
+- [x] [Web Access Control](http://www.w3.org/wiki/WebAccessControl)
+- [x] [WebID+TLS Authentication](https://www.w3.org/2005/Incubator/webid/spec/tls/)
+- [x] [Real-time live updates](https://github.com/solid/solid-spec#subscribing) (using WebSockets)
+- [x] Identity provider for WebID
+- [x] CORS proxy for cross-site data access
+- [x] Group members in ACL
+- [x] Email account recovery
+
+## Command Line Usage
+
+### Install
+
+You can install and run the server either using Node.js directly or using
+[Docker](https://www.docker.com/).  This and the following sections describe the
+first approach, for the second approach see the section [use Docker](#use-docker)
+Section below.
+
+To install, first install [Node](https://nodejs.org/en/) and then run the following
+
+```bash
+$ npm install -g solid-server
+```
+
+### Run a single-user server (beginner)
+
+The easiest way to setup `solid-server` is by running the wizard. This will create a `config.json` in your current folder
+
+```bash
+$ solid init
+```
+**Note**: If prompted for an SSL key and certificate, follow the instructions below.
+
+To run your server, simply run `solid start`:
+
+```bash
+$ solid start
+# Solid server (solid v0.2.24) running on https://localhost:8443/
+```
+
+If you prefer to use flags instead, the following would be the equivalent
+
+```bash
+$ solid start --port 8443 --ssl-key path/to/ssl-key.pem --ssl-cert path/to/ssl-cert.pem
+# Solid server (solid v0.2.24) running on https://localhost:8443/
+```
+
+If you want to run `solid` on a particular folder (different from the one you are in, e.g. `path/to/folder`):
+
+```bash
+$ solid start --root path/to/folder --port 8443 --ssl-key path/to/ssl-key.pem --ssl-cert path/to/ssl-cert.pem
+# Solid server (solid v0.2.24) running on https://localhost:8443/
+```
+
+### Running in development environments
+
+Solid requires SSL certificates to be valid, so you cannot use self-signed certificates. To switch off this security feature in development environments, you can use the `bin/solid-test` executable, which unsets the `NODE_TLS_REJECT_UNAUTHORIZED` flag and sets the `rejectUnauthorized` option.
+
+If you want to run in multi-user mode on localhost, do the following:
+* configure the server as such with `bin/solid-test init`
+* start the server with `bin/solid-test start`
+* visit https://localhost:8443 and register a user, for instance 'myusername'.
+* Edit your hosts file and add a line `127.0.0.1 myusername.localhost`
+* Now you can visit https://myusername.localhost:8443.
+
+##### How do I get an SSL key and certificate?
+You need an SSL certificate from a _certificate authority_, such as your domain provider or [Let's Encrypt!](https://letsencrypt.org/getting-started/).
+
+For testing purposes, you can use `bin/solid-test` with a _self-signed_ certificate, generated as follows:
+
+```
+$ openssl req -outform PEM -keyform PEM -new -x509 -sha256 -newkey rsa:2048 -nodes -keyout ../privkey.pem -days 365 -out ../fullchain.pem
+
+```
+
+Note that this example creates the `fullchain.pem` and `privkey.pem` files
+in a directory one level higher from the current, so that you don't
+accidentally commit your certificates to `solid` while you're developing.
+
+If you would like to get rid of the browser warnings, import your fullchain.pem certificate into your 'Trusted Root Certificate' store.
+
+### Running Solid behind a reverse proxy (such as NGINX)
+See [Running Solid behind a reverse proxy](https://github.com/solid/node-solid-server/wiki/Running-Solid-behind-a-reverse-proxy).
+
+### Run multi-user server (intermediate)
+
+You can run `solid` so that new users can sign up, in other words, get their WebIDs _username.yourdomain.com_.
+
+Pre-requisites:
+- Get a [Wildcard Certificate](https://en.wikipedia.org/wiki/Wildcard_certificate)
+- Add a Wildcard DNS record in your DNS zone (e.g.`*.yourdomain.com`)
+- (If you are running locally) Add the line `127.0.0.1 *.localhost` to `/etc/hosts`
+
+```bash
+$ solid init
+..
+? Allow users to register their WebID (y/N) # write `y` here
+..
+$ solid start
+```
+
+Otherwise, if you want to use flags, this would be the equivalent
+
+```bash
+$ solid start --multiuser --port 8443 --ssl-cert /path/to/cert --ssl-key /path/to/key --root ./data
+```
+
+Your users will have a dedicated folder under `./data` at `./data/<username>.<yourdomain.tld>`. Also, your root domain's website will be in `./data/<yourdomain.tld>`. New users can create accounts on `/api/accounts/new` and create new certificates on `/api/accounts/cert`. An easy-to-use sign-up tool is found on `/api/accounts`.
+
+##### How can I send emails to my users with my Gmail?
+
+> To use Gmail you may need to configure ["Allow Less Secure Apps"](https://www.google.com/settings/security/lesssecureapps) in your Gmail account unless you are using 2FA in which case you would have to create an [Application Specific](https://security.google.com/settings/security/apppasswords) password. You also may need to unlock your account with ["Allow access to your Google account"](https://accounts.google.com/DisplayUnlockCaptcha) to use SMTP.
+
+also add to `config.json`
+``` 
+  "useEmail": true,
+  "emailHost": "smtp.gmail.com",
+  "emailPort": "465",
+  "emailAuthUser": "xxxx@gmail.com",
+  "emailAuthPass": "gmailPass"
+```
+
+### Upgrading from version <5.3
+Please take into account the [v5.3 upgrade notes](https://github.com/solid/node-solid-server/blob/master/CHANGELOG.md#530-upgrade-notes).
+
+### Upgrading from version <5.0
+To upgrade from version 4 to the current version 5, you need to run a migration script, as explained in the [v5.0 upgrade notes](https://github.com/solid/node-solid-server/blob/master/CHANGELOG.md#500-upgrade-notes).
+
+Also, be aware that starting from version 5, third-party apps are untrusted by default. To trust a third-party app, before you can log in to it, you first need to go to your profile at https://example.com/profile/card#me (important to include the '#me' there), and then hover over the 'card' header to reveal the context menu. From there, select the 'A' symbol to go to your trusted applications pane, where you can whitelist third-party apps before using them. See also https://github.com/solid/node-solid-server/issues/1142 about streamlining this UX flow.
+
+### Extra flags (expert)
+The command line tool has the following options
+
+```
+$ solid
+
+  Usage: solid [options] [command]
+
+  Commands:
+    init [options]    create solid server configurations
+    start [options]   run the Solid server
+
+  Options:
+    -h, --help     output usage information
+    -V, --version  output the version number
+
+
+$ solid init --help
+
+  Usage: init [options]
+  Create solid server configurations
+
+  Options:
+    -h, --help  output usage information
+    --advanced  Ask for all the settings
+
+
+$ solid start --help
+
+  Usage: start [options]
+
+  run the Solid server
+
+
+  Options:
+
+    --root [value]                Root folder to serve (default: './data')
+    --port [value]                SSL port to use
+    --server-uri [value]          Solid server uri (default: 'https://localhost:8443')
+    --webid                       Enable WebID authentication and access control (uses HTTPS)
+    --mount [value]               Serve on a specific URL path (default: '/')
+    --config-path [value]
+    --config-file [value]
+    --db-path [value]
+    --auth [value]                Pick an authentication strategy for WebID: `tls` or `oidc`
+    --owner [value]               Set the owner of the storage (overwrites the root ACL file)
+    --ssl-key [value]             Path to the SSL private key in PEM format
+    --ssl-cert [value]            Path to the SSL certificate key in PEM format
+    --no-reject-unauthorized      Accept self-signed certificates
+    --multiuser                   Enable multi-user mode
+    --idp [value]                 Obsolete; use --multiuser
+    --no-live                     Disable live support through WebSockets
+    --proxy [value]               Obsolete; use --corsProxy
+    --cors-proxy [value]          Serve the CORS proxy on this path
+    --suppress-data-browser       Suppress provision of a data browser
+    --data-browser-path [value]   An HTML file which is sent to allow users to browse the data (eg using mashlib.js)
+    --suffix-acl [value]          Suffix for acl files (default: '.acl')
+    --suffix-meta [value]         Suffix for metadata files (default: '.meta')
+    --secret [value]              Secret used to sign the session ID cookie (e.g. "your secret phrase")
+    --error-pages [value]         Folder from which to look for custom error pages files (files must be named <error-code>.html -- eg. 500.html)
+    --force-user [value]          Force a WebID to always be logged in (useful when offline)
+    --strict-origin               Enforce same origin policy in the ACL
+    --use-email                   Do you want to set up an email service?
+    --email-host [value]          Host of your email service
+    --email-port [value]          Port of your email service
+    --email-auth-user [value]     User of your email service
+    --email-auth-pass [value]     Password of your email service
+    --use-api-apps                Do you want to load your default apps on /api/apps?
+    --api-apps [value]            Path to the folder to mount on /api/apps
+    --redirect-http-from [value]  HTTP port or ','-separated ports to redirect to the solid server port (e.g. "80,8080").
+    --server-name [value]         A name for your server (not required, but will be presented on your server's frontpage)
+    --server-description [value]  A description of your server (not required)
+    --server-logo [value]         A logo that represents you, your brand, or your server (not required)
+    --enforce-toc                 Do you want to enforce Terms & Conditions for your service?
+    --toc-uri [value]             URI to your Terms & Conditions
+    --support-email [value]       The support email you provide for your users (not required)
+    -q, --quiet                   Do not print the logs to console
+    -h, --help                    output usage information
+```
+
+Instead of using flags, these same options can also be configured via environment variables taking the form of `SOLID_` followed by the `SNAKE_CASE` of the flag. For example `--api-apps` can be set via the `SOLID_API_APPS`environment variable, and `--serverUri` can be set with `SOLID_SERVER_URI`.
+
+CLI flags take precedence over Environment variables, which take precedence over entries in the config file.
+
+Configuring Solid via the config file can be a concise and convenient method and is the generally recommended approach. CLI flags can be useful when you would like to override a single configuration parameter, and using environment variables can be helpful in situations where you wish to deploy a single generic Docker image to multiple environments.
+
+## Use Docker
+
+
+### Production usage
+
+See the [documentation to run Solid using docker and docker-compose](https://github.com/solid/node-solid-server/tree/master/docker-image).
+
+We have automatic builds set up, so commits to master will trigger a build of https://hub.docker.com/r/nodesolidserver/node-solid-server.
+
+### Development usage
+
+If you want to use Docker in development, then you can build it locally with:
+
+```bash
+git clone https://github.com/solid/node-solid-server
+cd node-solid-server
+docker build -t node-solid-server .
+```
+
+Run with:
+```bash
+docker run -p 8443:8443 --name solid node-solid-server
+```
+
+This will enable you to login to solid on https://localhost:8443 and then create a new account
+but not yet use that account. After a new account is made you will need to create an entry for 
+it in your local (/etc/)hosts file in line with the account and subdomain, i.e. --
+
+```pre
+127.0.0.1	newsoliduser.localhost
+```
+
+You can modify the config within the docker container as follows:
+
+ - Copy the `config.json` to the current directory with: 
+   ```bash
+   docker cp solid:/usr/src/app/config.json .
+   ```
+ - Edit the `config.json` file
+ - Copy the file back with 
+   ```bash
+   docker cp config.json solid:/usr/src/app/
+   ```
+ - Restart the server with 
+   ```bash
+   docker restart solid
+   ```
+
+## Library Usage
+
+### Install Dependencies
+
+```
+npm install
+```
+
+### Library Usage
+
+The library provides two APIs:
+
+- `solid.createServer(settings)`: starts a ready to use
+    [Express](http://expressjs.com) app.
+- `lnode(settings)`: creates an [Express](http://expressjs.com) that you can
+    mount in your existing express app.
+
+In case the `settings` is not passed, then it will start with the following
+default settings.
+
+```javascript
+{
+  cache:        0,           // Set cache time (in seconds), 0 for no cache
+  live:         true,        // Enable live support through WebSockets
+  root:         './',        // Root location on the filesystem to serve resources
+  secret:       'node-ldp',  // Express Session secret key
+  cert:         false,       // Path to the ssl cert
+  key:          false,       // Path to the ssl key
+  mount:        '/',         // Where to mount Linked Data Platform
+  webid:        false,       // Enable WebID+TLS authentication
+  suffixAcl:    '.acl',      // Suffix for acl files
+  corsProxy:    false,       // Where to mount the CORS proxy
+  errorHandler: false,       // function(err, req, res, next) to have a custom error handler
+  errorPages:   false        // specify a path where the error pages are
+}
+```
+
+Have a look at the following examples or in the
+[`examples/`](https://github.com/solid/node-solid-server/tree/master/examples) folder
+for more complex ones
+
+##### Simple Example
+
+You can create a `solid` server ready to use using `solid.createServer(opts)`
+
+```javascript
+var solid = require('solid-server')
+var ldp = solid.createServer({
+    key: '/path/to/sslKey.pem',
+    cert: '/path/to/sslCert.pem',
+    webid: true
+})
+ldp.listen(3000, function() {
+  // Started Linked Data Platform
+})
+```
+
+##### Advanced Example
+
+You can integrate `solid` in your existing [Express](https://expressjs.org)
+app, by mounting the `solid` app on a specific path using `lnode(opts)`.
+
+```javascript
+var solid = require('solid-server')
+var app = require('express')()
+app.use('/test', solid(yourSettings))
+app.listen(3000, function() {
+  // Started Express app with ldp on '/test'
+})
+...
+```
+
+##### Logging
+
+Run your app with the `DEBUG` variable set:
+
+```bash
+$ DEBUG="solid:*" node app.js
+```
+
+## Testing `solid` Locally
+
+#### Pre-Requisites
+
+In order to really get a feel for the Solid platform, and to test out `solid`,
+you will need the following:
+
+1. A WebID profile and browser certificate from one of the Solid-compliant
+    identity providers, such as [solidcommunity.net](https://solidcommunity.net).
+
+2. A server-side SSL certificate for `solid` to use (see the section below
+    on creating a self-signed certificate for testing).
+
+While these steps are technically optional (since you could launch it in
+HTTP/LDP-only mode), you will not be able to use any actual Solid features
+without them.
+
+#### Creating a certificate for local testing
+
+When deploying `solid` in production, we recommend that you go the
+usual Certificate Authority route to generate your SSL certificate (as you
+would with any website that supports HTTPS). However, for testing it locally,
+you can easily [generate a self-signed certificate for whatever domain you're
+Working with](https://github.com/solid/node-solid-server#how-do-i-get-an-ssl-key-and-certificate).
+
+#### Accessing your server
+
+If you started your `solid` server locally on port 8443 as in the example
+above, you would then be able to visit `https://localhost:8443` in the browser
+(ignoring the Untrusted Connection browser warnings as usual), where your
+`solid` server would redirect you to the default data viewer app.
+
+#### Editing your local `/etc/hosts`
+
+To test certificates and account creation on subdomains, `solid`'s test suite
+uses the following localhost domains: `nic.localhost`, `tim.localhost`, and
+`nicola.localhost`. You will need to create host file entries for these, in
+order for the tests to pass.
+
+Edit your `/etc/hosts` file, and append:
+
+```
+# Used for unit testing solid
+127.0.0.1 nic.localhost
+127.0.0.1 tim.localhost
+127.0.0.1 nicola.localhost
+```
+
+#### Running the Unit Tests
+
+```bash
+$ npm test
+# running the tests with logs
+$ DEBUG="solid:*" npm test
+```
+
+In order to test a single component, you can run
+
+```javascript
+npm run test-(acl|formats|params|patch)
+```
+
+## Blacklisted usernames
+
+By default Solid will not allow [certain usernames as they might cause
+confusion or allow vulnerabilies for social engineering](https://github.com/marteinn/The-Big-Username-Blacklist).
+This list is configurable via `config/usernames-blacklist.json`. Solid does not
+blacklist profanities by default.
+
+## Quota
+
+By default, a file `serverSide.ttl.inactive` will be installed to new
+PODs. If you rename it to `serverSide.ttl`, it will currently set a
+quota for disk usage.  This file is not writeable to users, only
+server administrators who are authorized on the backend can modify
+it. It is currently adviceable to remove it or set it inactive rather
+than set a large quota, because the current implementation will impair
+write performance if there is a lot of data.
+
+## Get help and contribute
+
+Solid is only possible because of a large community of [contributors](https://github.com/solid/node-solid-server/blob/master/CONTRIBUTORS.md).
+A heartfelt thank you to everyone for all of your efforts!
+
+You can receive or provide help too:
+
+- [Join us in Gitter](https://gitter.im/solid/chat) to chat about Solid or to hang out with us :)
+- [NSS Gitter channel](https://gitter.im/solid/node-solid-server) for specific (installation) advice about this code base
+- [Create a new issue](https://github.com/solid/node-solid-server/issues/new) to report bugs
+- [Fix an issue](https://github.com/solid/node-solid-server/issues)
+- Reach out to Jackson at jacksonm@inrupt.com to become more involved in maintaining Node Solid Server
+
+Have a look at [CONTRIBUTING.md](https://github.com/solid/node-solid-server/blob/master/CONTRIBUTING.md).
+
+## License
+
+[The MIT License](https://github.com/solid/node-solid-server/blob/master/LICENSE.md)

package/bin/lib/cli-utils.js

@@ -0,0 +1,85 @@
+const fs = require('fs-extra')
+const { red, cyan, bold } = require('colorette')
+const { URL } = require('url')
+const LDP = require('../../lib/ldp')
+const AccountManager = require('../../lib/models/account-manager')
+const SolidHost = require('../../lib/models/solid-host')
+
+module.exports.getAccountManager = getAccountManager
+module.exports.loadAccounts = loadAccounts
+module.exports.loadConfig = loadConfig
+module.exports.loadUsernames = loadUsernames
+
+/**
+ * Returns an instance of AccountManager
+ *
+ * @param {Object} config
+ * @param {Object} [options]
+ * @returns {AccountManager}
+ */
+function getAccountManager (config, options = {}) {
+  const ldp = options.ldp || new LDP(config)
+  const host = options.host || SolidHost.from({ port: config.port, serverUri: config.serverUri })
+  return AccountManager.from({
+    host,
+    store: ldp,
+    multiuser: config.multiuser
+  })
+}
+
+function loadConfig (program, options) {
+  let argv = {
+    ...options,
+    version: program.version()
+  }
+  const configFile = argv.configFile || './config.json'
+
+  try {
+    const file = fs.readFileSync(configFile)
+
+    // Use flags with priority over config file
+    const config = JSON.parse(file)
+    argv = { ...config, ...argv }
+  } catch (err) {
+    // If config file was specified, but it doesn't exist, stop with error message
+    if (typeof argv.configFile !== 'undefined') {
+      if (!fs.existsSync(configFile)) {
+        console.log(red(bold('ERR')), 'Config file ' + configFile + ' doesn\'t exist.')
+        process.exit(1)
+      }
+    }
+
+    // If the file exists, but parsing failed, stop with error message
+    if (fs.existsSync(configFile)) {
+      console.log(red(bold('ERR')), 'config file ' + configFile + ' couldn\'t be parsed: ' + err)
+      process.exit(1)
+    }
+
+    // Legacy behavior - if config file does not exist, start with default
+    // values, but an info message to create a config file.
+    console.log(cyan(bold('TIP')), 'create a config.json: `$ solid init`')
+  }
+
+  return argv
+}
+
+/**
+ *
+ * @param root
+ * @param [serverUri] If not set, hostname must be set
+ * @param [hostname] If not set, serverUri must be set
+ * @returns {*}
+ */
+function loadAccounts ({ root, serverUri, hostname }) {
+  const files = fs.readdirSync(root)
+  hostname = hostname || new URL(serverUri).hostname
+  const isUserDirectory = new RegExp(`.${hostname}$`)
+  return files
+    .filter(file => isUserDirectory.test(file))
+}
+
+function loadUsernames ({ root, serverUri }) {
+  const hostname = new URL(serverUri).hostname
+  return loadAccounts({ root, hostname })
+    .map(userDirectory => userDirectory.substr(0, userDirectory.length - hostname.length - 1))
+}

package/bin/lib/cli.js

@@ -0,0 +1,39 @@
+const program = require('commander')
+const loadInit = require('./init')
+const loadStart = require('./start')
+const loadInvalidUsernames = require('./invalidUsernames')
+const loadMigrateLegacyResources = require('./migrateLegacyResources')
+const loadUpdateIndex = require('./updateIndex')
+const { spawnSync } = require('child_process')
+const path = require('path')
+
+module.exports = function startCli (server) {
+  program.version(getVersion())
+
+  loadInit(program)
+  loadStart(program, server)
+  loadInvalidUsernames(program)
+  loadMigrateLegacyResources(program)
+  loadUpdateIndex(program)
+
+  program.parse(process.argv)
+  if (program.args.length === 0) program.help()
+}
+
+function getVersion () {
+  try {
+    // Obtain version from git
+    const options = { cwd: __dirname, encoding: 'utf8' }
+    const { stdout } = spawnSync('git', ['describe', '--tags'], options)
+    const { stdout: gitStatusStdout } = spawnSync('git', ['status'], options)
+    const version = stdout.trim()
+    if (version === '' || gitStatusStdout.match('Not currently on any branch')) {
+      throw new Error('No git version here')
+    }
+    return version
+  } catch (e) {
+    // Obtain version from package.json
+    const { version } = require(path.join(__dirname, '../../package.json'))
+    return version
+  }
+}

package/bin/lib/init.js

@@ -0,0 +1,94 @@
+const inquirer = require('inquirer')
+const fs = require('fs')
+const options = require('./options')
+const camelize = require('camelize')
+
+let questions = options
+  .map((option) => {
+    if (!option.type) {
+      if (option.flag) {
+        option.type = 'confirm'
+      } else {
+        option.type = 'input'
+      }
+    }
+
+    option.message = option.question || option.help
+    return option
+  })
+
+module.exports = function (program) {
+  program
+    .command('init')
+    .option('--advanced', 'Ask for all the settings')
+    .description('create solid server configurations')
+    .action((opts) => {
+      // Filter out advanced commands
+      if (!opts.advanced) {
+        questions = questions.filter((option) => option.prompt)
+      }
+
+      // Prompt to the user
+      inquirer.prompt(questions)
+        .then((answers) => {
+          manipulateEmailSection(answers)
+          manipulateServerSection(answers)
+          cleanupAnswers(answers)
+
+          // write config file
+          const config = JSON.stringify(camelize(answers), null, '  ')
+          const configPath = process.cwd() + '/config.json'
+
+          fs.writeFile(configPath, config, (err) => {
+            if (err) {
+              return console.log('failed to write config.json')
+            }
+            console.log('config created on', configPath)
+          })
+        })
+        .catch((err) => {
+          console.log('Error:', err)
+        })
+    })
+}
+
+function cleanupAnswers (answers) {
+  // clean answers
+  Object.keys(answers).forEach((answer) => {
+    if (answer.startsWith('use')) {
+      delete answers[answer]
+    }
+  })
+}
+
+function manipulateEmailSection (answers) {
+  // setting email
+  if (answers.useEmail) {
+    answers.email = {
+      host: answers['email-host'],
+      port: answers['email-port'],
+      secure: true,
+      auth: {
+        user: answers['email-auth-user'],
+        pass: answers['email-auth-pass']
+      }
+    }
+    delete answers['email-host']
+    delete answers['email-port']
+    delete answers['email-auth-user']
+    delete answers['email-auth-pass']
+  }
+}
+
+function manipulateServerSection (answers) {
+  answers.server = {
+    name: answers['server-info-name'],
+    description: answers['server-info-description'],
+    logo: answers['server-info-logo']
+  }
+  Object.keys(answers).forEach((answer) => {
+    if (answer.startsWith('server-info-')) {
+      delete answers[answer]
+    }
+  })
+}