@libp2p/daemon-server 0.0.0

package/package.json

@@ -0,0 +1,165 @@
+{
+  "name": "@libp2p/daemon-server",
+  "version": "0.0.0",
+  "description": "API server for libp2p-daemon instances",
+  "license": "Apache-2.0 OR MIT",
+  "homepage": "https://github.com/libp2p/js-libp2p-daemon/tree/master/packages/libp2p-daemon#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/libp2p/js-libp2p-daemon.git"
+  },
+  "bugs": {
+    "url": "https://github.com/libp2p/js-libp2p-daemon/issues"
+  },
+  "keywords": [
+    "libp2p"
+  ],
+  "engines": {
+    "node": ">=16.0.0",
+    "npm": ">=7.0.0"
+  },
+  "bin": {
+    "jsp2pd": "src/cli/bin.js"
+  },
+  "type": "module",
+  "types": "./dist/src/index.d.ts",
+  "files": [
+    "src",
+    "dist/src",
+    "!dist/test",
+    "!**/*.tsbuildinfo"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/src/index.js"
+    }
+  },
+  "eslintConfig": {
+    "extends": "ipfs",
+    "parserOptions": {
+      "sourceType": "module"
+    },
+    "ignorePatterns": [
+      "*.d.ts",
+      "src/profocol/index.js"
+    ]
+  },
+  "release": {
+    "branches": [
+      "master"
+    ],
+    "plugins": [
+      [
+        "@semantic-release/commit-analyzer",
+        {
+          "preset": "conventionalcommits",
+          "releaseRules": [
+            {
+              "breaking": true,
+              "release": "major"
+            },
+            {
+              "revert": true,
+              "release": "patch"
+            },
+            {
+              "type": "feat",
+              "release": "minor"
+            },
+            {
+              "type": "fix",
+              "release": "patch"
+            },
+            {
+              "type": "chore",
+              "release": "patch"
+            },
+            {
+              "type": "docs",
+              "release": "patch"
+            },
+            {
+              "type": "test",
+              "release": "patch"
+            },
+            {
+              "scope": "no-release",
+              "release": false
+            }
+          ]
+        }
+      ],
+      [
+        "@semantic-release/release-notes-generator",
+        {
+          "preset": "conventionalcommits",
+          "presetConfig": {
+            "types": [
+              {
+                "type": "feat",
+                "section": "Features"
+              },
+              {
+                "type": "fix",
+                "section": "Bug Fixes"
+              },
+              {
+                "type": "chore",
+                "section": "Trivial Changes"
+              },
+              {
+                "type": "docs",
+                "section": "Trivial Changes"
+              },
+              {
+                "type": "test",
+                "section": "Tests"
+              }
+            ]
+          }
+        }
+      ],
+      "@semantic-release/changelog",
+      "@semantic-release/npm",
+      "@semantic-release/github",
+      "@semantic-release/git"
+    ]
+  },
+  "scripts": {
+    "lint": "aegir lint",
+    "build": "tsc",
+    "pretest": "npm run build",
+    "test": "aegir test -t node -f test/*.js test/**/*.js",
+    "test:node": "aegir test -t node -f test/*.js test/**/*.js",
+    "release": "semantic-release"
+  },
+  "dependencies": {
+    "@chainsafe/libp2p-noise": "^6.0.0",
+    "@libp2p/daemon-protocol": "^0.0.0",
+    "@libp2p/interfaces": "^1.3.17",
+    "@multiformats/multiaddr": "^10.1.8",
+    "it-all": "^1.0.6",
+    "it-drain": "^1.0.5",
+    "it-buffer": "^0.1.3",
+    "it-handshake": "^3.0.1",
+    "it-length-prefixed": "^7.0.1",
+    "it-pipe": "^2.0.3",
+    "it-pushable": "^2.0.1",
+    "multiformats": "^9.4.2",
+    "promisify-es6": "^1.0.3",
+    "protobufjs": "^6.10.2",
+    "stream-to-it": "^0.2.0",
+    "streaming-iterables": "^6.0.0",
+    "uint8arrays": "^3.0.0",
+    "yargs": "^17.3.1",
+    "yargs-promise": "^1.1.0"
+  },
+  "devDependencies": {
+    "aegir": "^36.0.0",
+    "delay": "^5.0.0",
+    "it-pair": "^2.0.2",
+    "mocha": "^9.1.1",
+    "p-defer": "^4.0.0",
+    "sinon": "^13.0.1"
+  }
+}

package/src/client.ts

@@ -0,0 +1,56 @@
+import { TCP } from '@libp2p/tcp'
+import { passThroughUpgrader } from './util/index.js'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import type { Connection } from '@libp2p/interfaces/connection'
+import type { ConnectionHandler, Listener } from '@libp2p/interfaces/transport'
+
+export class Client {
+  private multiaddr: Multiaddr
+  private tcp: TCP
+  private listener?: Listener
+
+  constructor (addr: Multiaddr) {
+    this.multiaddr = addr
+    this.tcp = new TCP()
+  }
+
+  /**
+   * Connects to a daemon at the unix socket path the client
+   * was created with
+   */
+  connect (): Promise<Connection> {
+    return this.tcp.dial(this.multiaddr, {
+      upgrader: passThroughUpgrader
+    })
+  }
+
+  /**
+   * Starts a server listening at `socketPath`. New connections
+   * will be sent to the `connectionHandler`.
+   */
+  async start (addr: Multiaddr, handler: ConnectionHandler): Promise<void> {
+    if (this.listener != null) {
+      await this.close()
+    }
+
+    this.listener = this.tcp.createListener({
+      handler,
+      upgrader: passThroughUpgrader
+    })
+
+    await this.listener.listen(addr)
+  }
+
+  /**
+   * Closes the socket
+   *
+   * @returns {Promise}
+   */
+  async close () {
+    if (this.listener != null) {
+      await this.listener.close()
+    }
+
+    this.listener = undefined
+  }
+}

package/src/dht.ts

@@ -0,0 +1,153 @@
+/* eslint max-depth: ["error", 6] */
+
+import {
+  DHTResponse,
+} from '@libp2p/daemon-protocol'
+import { ErrorResponse, OkResponse } from './responses.js'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { DualDHT } from '@libp2p/interfaces/dht'
+import type { CID } from 'multiformats/cid'
+import drain from 'it-drain'
+
+export interface DHTOperationsInit {
+  dht: DualDHT
+}
+
+export class DHTOperations {
+  private dht: DualDHT
+
+  constructor (init: DHTOperationsInit) {
+    const { dht } = init
+
+    this.dht = dht
+  }
+
+  async * provide (cid: CID) {
+    await this.dht.provide(cid)
+    yield OkResponse()
+  }
+
+  async * getClosestPeers (key: Uint8Array) {
+    yield OkResponse({
+      dht: {
+        type: DHTResponse.Type.BEGIN
+      }
+    })
+
+    for await (const event of this.dht.getClosestPeers(key)) {
+      if (event.name === 'PEER_RESPONSE') {
+        yield * event.closer.map(peer => DHTResponse.encode({
+          type: DHTResponse.Type.VALUE,
+          value: peer.id.toBytes()
+        }).finish())
+      }
+    }
+
+    yield DHTResponse.encode({
+      type: DHTResponse.Type.END
+    }).finish()
+  }
+
+  async * getPublicKey (peerId: PeerId) {
+    yield ErrorResponse(new Error('FIX ME: not implemented'))
+
+    /*
+    const pubKey = await this.dht.getPublicKey(peerId)
+
+    yield OkResponse({
+      dht: {
+        type: DHTResponse.Type.VALUE,
+        value: pubKey.bytes
+      }
+    })
+    */
+  }
+
+  async * getValue (key: Uint8Array) {
+    try {
+      for await (const event of this.dht.getClosestPeers(key)) {
+        if (event.name === 'VALUE') {
+          yield OkResponse({
+            dht: {
+              type: DHTResponse.Type.VALUE,
+              value: event.value
+            }
+          })
+        }
+      }
+    } catch (err: any) {
+      yield ErrorResponse(err.message)
+    }
+  }
+
+  async * putValue (key: Uint8Array, value: Uint8Array) {
+    try {
+      await drain(this.dht.put(key, value))
+
+      yield OkResponse()
+    } catch (err: any) {
+      yield ErrorResponse(err.message)
+    }
+  }
+
+  async * findPeer (peerId: PeerId) {
+    try {
+      for await (const event of this.dht.findPeer(peerId)) {
+        if (event.name === 'FINAL_PEER') {
+          yield OkResponse({
+            dht: {
+              type: DHTResponse.Type.VALUE,
+              peer: {
+                id: event.peer.id.toBytes(),
+                addrs: event.peer.multiaddrs.map(m => m.bytes)
+              }
+            }
+          })
+        }
+      }
+
+      throw new Error('Peer not found')
+    } catch (err: any) {
+      yield ErrorResponse(err)
+    }
+  }
+
+  async * findProviders (cid: CID, count: number) {
+    yield OkResponse({
+      dht: {
+        type: DHTResponse.Type.BEGIN
+      }
+    })
+
+    try {
+      const maxNumProviders = count
+      let found = 0
+
+      for await (const event of this.dht.findProviders(cid)) {
+        if (event.name === 'PEER_RESPONSE') {
+          for (const provider of event.providers) {
+            found++
+
+            yield DHTResponse.encode({
+              type: DHTResponse.Type.VALUE,
+              peer: {
+                id: provider.id.toBytes(),
+                addrs: (provider.multiaddrs || []).map(m => m.bytes)
+              }
+            }).finish()
+          }
+
+          if (maxNumProviders === found) {
+            return
+          }
+        }
+      }
+    } catch (err: any) {
+      yield ErrorResponse(err)
+    }
+
+    yield DHTResponse.encode({
+      type: DHTResponse.Type.END
+    }).finish()
+  }
+}