blind-peer 2.9.5 → 3.0.0

package/README.md

@@ -4,54 +4,23 @@ Blind peers help keep hypercores available.
 
 For the client side responsible for requesting cores be kept by Blind Peers, see [blind-peering](https://github.com/holepunchto/blind-peering).
 
-## Installation
+To run the server as a CLI, see [blind-peer-cli](https://github.com/holepunchto/blind-peer-cli).
 
-Install globally to use the `blind-peer` command:
+## Installation
 
 ```
-npm install -g blind-peer
+npm install blind-peer
 ```
 
 ## Usage
 
-Run a blind peer:
-
-```
-blind-peer
-```
-
-### Command Line Options
-
-- `--storage|-s [path]` - Storage path, defaults to ./blind-peer
-- `--port|-p [int]` - DHT Port to try to bind to. Only relevant when that port is not firewalled. (defaults to a random port)
-- `--trusted-peer|-t [trusted-peer]` - Public key of a trusted peer (allowed to set announce: true). Can be specified multiple times.
-- `--debug|-d` - Enable debug mode (more logs). Can be specified multiple times.
-- `--max-storage|-m [int]` - Max storage usage, in Mb (defaults to 100000)
-- `--autodiscovery-rpc-key [autodiscovery-rpc-key]` - Public key where the autodiscovery service is listening. When set, the autodiscovery-seed must also be set. Can be hex or z32.
-- `--autodiscovery-seed [autodiscovery-seed]` - 64-byte seed used to authenticate to the autodiscovery service. Can be hex or z32.
-- `--autodiscovery-service-name [autodiscovery-service-name]` - Name under which to register the service (default blind-peer)
-- `--scraper-public-key [scraper-public-key]` - Public key of a dht-prometheus scraper. Can be hex or z32.
-- `--scraper-secret [scraper-secret]` - Secret of the dht-prometheus scraper. Can be hex or z32.
-- `--scraper-alias [scraper-alias]` - (optional) Alias with which to register to the scraper
-
-### Output
-
-When started, ndjson (pino) will be emitted for events. An example startup will look like:
-
-```jsonl
-{"level":30,"time":1751662694931,"pid":96069,"hostname":"L293","msg":"Starting blind peer"}
-{"level":30,"time":1751662694932,"pid":96069,"hostname":"L293","msg":"Using storage 'blind-peer'"}
-{"level":30,"time":1751662696936,"pid":96069,"hostname":"L293","msg":"Blind peer listening, local address is 10.0.0.214:49741"}
-{"level":30,"time":1751662696936,"pid":96069,"hostname":"L293","msg":"Bytes allocated: 0B of 100GB"}
-{"level":30,"time":1751662696936,"pid":96069,"hostname":"L293","msg":"Listening at es4n7ty45odd1udfqyi9xz58mrbheuhdnxgdufsn9gz6e5uhsqco"}
-{"level":30,"time":1751662696936,"pid":96069,"hostname":"L293","msg":"Encryption public key is ur7d9r7s3zf1ryibixt5139bep67y94s5bg4gckzo1p6qgtwwfyy"}
-```
+to run a blind-peer server, use [blind-peer-cli](https://github.com/holepunchto/blind-peer-cli).
 
 ### Using a Blind Peer
 
-To use a blind peer, use [blind-peering](https://github.com/holepunchto/blind-peering)
+To talk to a blind peer, use [blind-peering](https://github.com/holepunchto/blind-peering)
 
-Here is an example, using the key from above
+Here is an example:
 
 ```js
 import BlindPeering from 'blind-peering'
@@ -63,7 +32,7 @@ const store = new Corestore(Pear.config.storage)
 const swarm = new Hyperswarm()
 const wakeup = new Wakeup()
 
-const DEFAULT_BLIND_PEER_KEYS = ['es4n7ty45odd1udfqyi9xz58mrbheuhdnxgdufsn9gz6e5uhsqco']
+const DEFAULT_BLIND_PEER_KEYS = ['es4n7ty45odd1udfqyi9xz58mrbheuhdnxgdufsn9gz6e5uhsqco'] // replace with your own key
 const blind = new BlindPeering(swarm, store, { wakeup, mirrors: DEFAULT_BLIND_PEER_KEYS })
 
 // Add your autobase

package/package.json

@@ -1,38 +1,27 @@
 {
   "name": "blind-peer",
-  "version": "2.9.5",
+  "version": "3.0.0",
   "description": "Blind peers help keep hypercores available",
   "main": "index.js",
-  "bin": {
-    "blind-peer": "bin.js",
-    "blind-peer-bare": "bare-bin.js"
-  },
   "dependencies": {
     "autobase": "^7.0.18",
-    "autobase-discovery": "^1.0.0",
     "b4a": "^1.6.7",
     "blind-peer-encodings": "^3.1.0",
     "compact-encoding": "^2.16.0",
     "corestore": "^7.4.4",
-    "graceful-goodbye": "^1.3.3",
-    "hyper-instrument": "^3.0.0",
     "hypercore": "^11.0.12",
     "hypercore-crypto": "^3.5.0",
     "hypercore-id-encoding": "^1.3.0",
     "hyperdb": "^4.9.4",
     "hyperschema": "^1.10.3",
     "hyperswarm": "^4.13.1",
-    "paparam": "^1.8.0",
-    "pino": "^9.6.0",
-    "pino-bare": "^0.0.1",
     "protomux-rpc": "^1.7.1",
     "protomux-wakeup": "^2.9.0",
     "ready-resource": "^1.1.2",
     "repl-swarm": "^2.3.0",
     "rocksdb-native": "^3.1.6",
     "safety-catch": "^1.0.2",
-    "scope-lock": "^1.2.4",
-    "tiny-byte-size": "^1.1.0"
+    "scope-lock": "^1.2.4"
   },
   "devDependencies": {
     "bare-events": "^2.8.2",
@@ -43,12 +32,11 @@
     "hyperdht": "^6.20.1",
     "prettier": "^3.6.2",
     "prettier-config-holepunch": "^2.0.0",
-    "prom-client": "^15.1.3",
+    "bare-prom-client": "^15.1.3",
     "test-tmp": "^1.3.0",
     "which-runtime": "^1.3.2"
   },
   "files": [
-    "bin.js",
     "index.js",
     "lib/"
   ],
@@ -69,10 +57,6 @@
   },
   "homepage": "https://github.com/holepunchto/blind-peer",
   "imports": {
-    "pino": {
-      "bare": "pino-bare",
-      "default": "pino"
-    },
     "events": {
       "bare": "bare-events",
       "default": "events"

package/bare-bin.js

@@ -1,3 +0,0 @@
-#!/usr/bin/env bare
-
-require('./bin')

package/bin.js

@@ -1,334 +0,0 @@
-#!/usr/bin/env node
-
-const { command, flag } = require('paparam')
-const goodbye = require('graceful-goodbye')
-const idEnc = require('hypercore-id-encoding')
-const Instrumentation = require('hyper-instrument')
-const RegisterClient = require('autobase-discovery/client/register')
-const safetyCatch = require('safety-catch')
-const byteSize = require('tiny-byte-size')
-const pino = require('pino')
-const b4a = require('b4a')
-const hypCrypto = require('hypercore-crypto')
-const { version: ownVersion } = require('./package.json')
-
-const BlindPeer = require('.')
-
-const SERVICE_NAME = 'blind-peer'
-const DEFAULT_STORAGE_LIMIT_MB = 100_000
-
-const cmd = command(
-  'blind-peer',
-  flag('--storage|-s [path]', 'Storage path, defaults to ./blind-peer'),
-  flag(
-    '--port|-p [int]',
-    'DHT Port to try to bind to. Only relevant when that port is not firewalled. (defaults to a random port)'
-  ),
-  flag(
-    '--trusted-peer|-t [trusted-peer]',
-    'Public key of a trusted peer (allowed to set announce: true). Can be more than 1.'
-  ).multiple(),
-  flag('--debug|-d', 'Enable debug mode (more logs)'),
-  flag(
-    `--max-storage|-m [int]', 'Max storage usage, in Mb (defaults to ${DEFAULT_STORAGE_LIMIT_MB})`
-  ),
-  flag(
-    '--autodiscovery-rpc-key [autodiscovery-rpc-key]',
-    'Public key where the autodiscovery service is listening. When set, the autodiscovery-seed must also be set. Can be hex or z32.'
-  ),
-  flag(
-    '--autodiscovery-seed [autodiscovery-seed]',
-    '64-byte seed used to authenticate to the autodiscovery service.  Can be hex or z32.'
-  ),
-  flag(
-    '--autodiscovery-service-name [autodiscovery-service-name]',
-    `Name under which to register the service (default ${SERVICE_NAME})`
-  ),
-  flag(
-    '--scraper-public-key [scraper-public-key]',
-    'Public key of a dht-prometheus scraper.  Can be hex or z32.'
-  ),
-  flag(
-    '--scraper-secret [scraper-secret]',
-    'Secret of the dht-prometheus scraper.  Can be hex or z32.'
-  ),
-  flag('--scraper-alias [scraper-alias]', '(optional) Alias with which to register to the scraper'),
-  flag(
-    '--log-streams',
-    '(Temporary, Advanced): enable debug logs on the UDX streams managed by the dht'
-  ),
-  flag(
-    '--repl [repl]',
-    'Expose a repl-swarm at the passed-in seed (32 bytes in hex or z32 notation). Use for debugging only.'
-  ),
-  flag(
-    '--auto-shutdown-minutes [auto-shutdown-minutes]',
-    '(Temporary, Advanced) Automatically shut the process down after X minutes, with a variation of 20%'
-  ),
-  async function ({ flags }) {
-    const debug = flags.debug
-    const logger = pino({
-      level: debug ? 'debug' : 'info',
-      name: 'blind-peer'
-    })
-    logger.info('Starting blind peer')
-
-    const logStreams = flags.logStreams
-
-    const storage = flags.storage || 'blind-peer'
-    const port = flags.port ? parseInt(flags.port) : null
-
-    const maxBytes = 1_000_000 * parseInt(flags.maxStorage || DEFAULT_STORAGE_LIMIT_MB)
-    const trustedPubKeys = (flags.trustedPeer || []).map((k) => idEnc.decode(k))
-
-    const blindPeer = new BlindPeer(storage, { trustedPubKeys, maxBytes, port })
-
-    blindPeer.on('flush-error', (e) => {
-      logger.warn(`Error while flushing the db: ${e.stack}`)
-    })
-
-    blindPeer.on('add-new-core', (record, _, stream) => {
-      try {
-        if (record.announce) {
-          logger.info(
-            `add-core request received from peer ${streamToStr(stream)} for record ${recordToStr(record)}`
-          )
-        } else {
-          logger.debug(
-            `add-core request received from peer ${streamToStr(stream)} for record ${recordToStr(record)}`
-          )
-        }
-      } catch (e) {
-        logger.info(`Invalid add-core request received: ${e.stack}`)
-        logger.info(record)
-      }
-    })
-    blindPeer.on('delete-blocked', (stream, { key }) => {
-      logger.info(
-        `Blocked delete-core request from untrusted peer ${streamToStr(stream)} for core ${idEnc.normalize(key)}`
-      )
-    })
-    blindPeer.on('delete-core', (stream, { key, existing }) => {
-      logger.info(
-        `Received delete-core request from trusted peer ${streamToStr(stream)} for core ${idEnc.normalize(key)}. Existing: ${existing}`
-      )
-    })
-    blindPeer.on('delete-core-end', (stream, { key, announced }) => {
-      logger.info(
-        `Completed delete-core request from trusted peer ${streamToStr(stream)} for core ${idEnc.normalize(key)}. Was announced: ${announced}`
-      )
-    })
-
-    blindPeer.on('downgrade-announce', ({ record, remotePublicKey }) => {
-      try {
-        logger.info(
-          `Downgraded announce for peer ${idEnc.normalize(remotePublicKey)} because the peer is not trusted (Original: ${recordToStr(record)})`
-        )
-      } catch (e) {
-        logger.error(`Unexpected error while logging downgrade-announce: ${e.stack}`)
-      }
-    })
-
-    blindPeer.on('announce-core', (core) => {
-      logger.info(`Started announcing core ${coreToInfo(core, true)}`)
-    })
-    blindPeer.on('announced-initial-cores', () => {
-      logger.info(`Announced all initial cores`)
-    })
-    blindPeer.on('core-downloaded', (core) => {
-      logger.info(`Announced core fully downloaded: ${coreToInfo(core, true)}`)
-    })
-    blindPeer.on('core-append', (core) => {
-      logger.info(`Detected announced-core length update: ${coreToInfo(core, true)}`)
-    })
-
-    blindPeer.on('gc-start', ({ bytesToClear }) => {
-      logger.info(
-        `Starting GC, trying to clear ${byteSize(bytesToClear)} (bytes allocated: ${byteSize(blindPeer.digest.bytesAllocated)} of ${byteSize(blindPeer.maxBytes)})`
-      )
-    })
-    blindPeer.on('gc-done', ({ bytesCleared }) => {
-      logger.info(
-        `Completed GC, cleared ${byteSize(bytesCleared)} bytes (bytes allocated: ${byteSize(blindPeer.digest.bytesAllocated)} of ${byteSize(blindPeer.maxBytes)})`
-      )
-    })
-    if (debug) {
-      blindPeer.on('core-activity', (core) => {
-        logger.debug(`Core activity for ${coreToInfo(core)}`)
-      })
-    }
-
-    blindPeer.on('invalid-request', (core, err, req, from) => {
-      const address = `${from.stream?.rawStream?.remoteHost}:${from.stream?.rawStream?.remotePort}`
-      const remotePubKey = idEnc.normalize(from.stream.remotePublicKey)
-      const key = idEnc.normalize(core.key)
-      logger.warn(
-        `Received invalid request for core ${key} from peer ${remotePubKey} at ${address} (${err.stack})`
-      )
-    })
-
-    logger.info(`Using storage '${storage}'`)
-    if (trustedPubKeys.length > 0) {
-      logger.info(
-        `Trusted public keys:\n  -${[...blindPeer.trustedPubKeys].map(idEnc.normalize).join('\n  -')}`
-      )
-    }
-
-    let instrumentation = null
-    goodbye(async () => {
-      if (instrumentation) {
-        logger.info('Closing instrumentation')
-        await instrumentation.close()
-      }
-      logger.info('Shutting down blind peer')
-      await blindPeer.close()
-      logger.info('Shut down blind peer')
-    })
-
-    if (flags.repl) {
-      const seed = idEnc.decode(flags.repl)
-      logger.warn('Setting up REPL swarm, enabling remote access to this process')
-      const replSwarm = require('repl-swarm')
-      replSwarm({ seed, logSeed: false, blindPeer, instrumentation })
-    }
-
-    await blindPeer.ready() // needed to be able to access the swarm object
-    blindPeer.swarm.on('ban', (peerInfo, err) => {
-      logger.warn(`Banned peer: ${b4a.toString(peerInfo.publicKey, 'hex')}.\n${err.stack}`)
-    })
-    if (debug) {
-      blindPeer.swarm.on('connection', (conn, peerInfo) => {
-        const key = idEnc.normalize(peerInfo.publicKey)
-        logger.debug(`Opened connection to ${key}`)
-        conn.on('close', () => logger.debug(`Closed connection to ${key}`))
-        conn.on('error', (err) => {
-          if (err.code === 'ECONNRESET') {
-            logger.debug(`Connection error with ${key}: ${err.stack}`)
-            return
-          }
-          logger.info(`Connection error with ${key}: ${err.stack}`)
-        })
-      })
-    }
-
-    if (logStreams) {
-      logger.warn('Advanced debugging option log-streams enabled')
-      setInterval(() => {
-        try {
-          let nrBigStreams = 0
-          for (const stream of blindPeer.swarm.dht.rawStreams) {
-            const pendingWrites = stream._wreqs.length - stream._wfree.length
-            if (pendingWrites >= 100) {
-              nrBigStreams++
-              logger.warn(
-                `Stream ${stream.id} (remote id: ${stream.remoteId}) has ${pendingWrites} pending writes:\nStream JSON: ${JSON.stringify(stream.toJSON(), null, 1)}\nSocket json: ${stream.socket ? JSON.stringify(stream.socket.toJSON(), null, 1) : 'none'}\nhex streamhandle: ${b4a.toString(stream._handle, 'hex')}\nhex socket handle: ${stream.socket ? b4a.toString(stream.socket._handle, 'hex') : 'none'}`
-              )
-            }
-          }
-          if (nrBigStreams > 0) {
-            logger.warn(`Total streams with many pending writes: ${nrBigStreams}`)
-          }
-        } catch (e) {
-          // we don't want to crash the process with our debugging
-          logger.warn(`logStreams errored unexpectedly: ${e.stack}`)
-        }
-      }, 30_000)
-    }
-
-    await blindPeer.listen()
-
-    logger.info(
-      `Blind peer listening, local address is ${blindPeer.swarm.dht.localAddress().host}:${blindPeer.swarm.dht.localAddress().port}`
-    )
-    logger.info(
-      `Bytes allocated: ${byteSize(blindPeer.digest.bytesAllocated)} of ${byteSize(blindPeer.maxBytes)}`
-    )
-
-    if (flags.autodiscoveryRpcKey) {
-      const autodiscoveryRpcKey = idEnc.decode(flags.autodiscoveryRpcKey)
-      const seed = idEnc.decode(flags.autodiscoverySeed)
-      const serviceName = flags.autodiscoveryServiceName || SERVICE_NAME
-      const registerClient = new RegisterClient(autodiscoveryRpcKey, blindPeer.swarm.dht, seed)
-
-      // No need to block on this, so we run it in the background
-      logger.info(
-        `Registering own RPC key rpc key ${idEnc.normalize(blindPeer.publicKey)} with service '${serviceName}' at autodiscovery service ${idEnc.normalize(autodiscoveryRpcKey)} (using public key ${idEnc.normalize(registerClient.keyPair.publicKey)})`
-      )
-      registerClient
-        .putService(blindPeer.publicKey, serviceName)
-        .then(() => {
-          logger.info('Successfully requested to be added to the autodiscovery service')
-        })
-        .catch((e) => {
-          logger.warn(`Failed to register to the autodiscovery service: ${e.stack}`)
-        })
-        .finally(() => {
-          registerClient.close().catch(safetyCatch)
-        })
-    }
-
-    if (flags.scraperPublicKey) {
-      const swarm = blindPeer.swarm
-      logger.info('Setting up instrumentation')
-
-      const scraperPublicKey = idEnc.decode(flags.scraperPublicKey)
-      const scraperSecret = idEnc.decode(flags.scraperSecret)
-
-      let prometheusAlias = flags.scraperAlias
-      if (prometheusAlias && prometheusAlias.length > 99) {
-        throw new Error('The Prometheus alias must have length less than 100')
-      }
-      if (!prometheusAlias) {
-        prometheusAlias = `blind-peer-${idEnc.normalize(swarm.keyPair.publicKey)}`.slice(0, 99)
-      }
-
-      instrumentation = new Instrumentation({
-        swarm,
-        corestore: blindPeer.store,
-        scraperPublicKey,
-        prometheusAlias,
-        scraperSecret,
-        prometheusServiceName: SERVICE_NAME,
-        version: ownVersion
-      })
-
-      blindPeer.registerMetrics(instrumentation.promClient)
-      instrumentation.registerLogger(logger)
-      await instrumentation.ready()
-    }
-
-    logger.info(`Listening at ${idEnc.normalize(blindPeer.publicKey)}`)
-    logger.info(`Encryption public key is ${idEnc.normalize(blindPeer.encryptionPublicKey)}`)
-
-    if (flags.autoShutdownMinutes) {
-      const delay = flags.autoShutdownMinutes * (1 + Math.random() / 5)
-      logger.warn(`Automatically shutting down the process in ${delay} minutes`)
-      setTimeout(
-        () => {
-          logger.warn('Auto-shutdown triggered. Shutting down...')
-          goodbye.exit()
-        },
-        delay * 60 * 1000
-      )
-    }
-  }
-)
-
-function recordToStr(record) {
-  const discKey = hypCrypto.discoveryKey(record.key)
-  return `DB Record for discovery key ${idEnc.normalize(discKey)} with priority: ${record.priority}. Announcing? ${record.announce}`
-}
-
-function streamToStr(stream) {
-  const pubKey = idEnc.normalize(stream.remotePublicKey)
-  return `${pubKey}`
-}
-
-function coreToInfo(core, includePublicKey = false) {
-  const discKey = hypCrypto.discoveryKey(core.key)
-  let res = `Discovery key ${idEnc.normalize(discKey)} (${core.contiguousLength} / ${core.length}, ${core.peers.length} peers)`
-  if (includePublicKey) res += `. Public key: ${idEnc.normalize(core.key)}`
-  return res
-}
-
-cmd.parse()