npm - hypercore-fetch - Versions diffs - 8.6.0 → 8.6.2-0 - Mend

hypercore-fetch 8.6.0 → 8.6.2-0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/.github/workflows/test.yml +22 -0
package/LICENSE +0 -0
package/README.md +67 -116
package/index.js +482 -670
package/package.json +11 -18
package/test.js +245 -186
package/bin.js +0 -27

package/index.js CHANGED Viewed

@@ -1,787 +1,599 @@
-const resolveDatPath = require('resolve-dat-path')
-const Headers = require('fetch-headers')
-const mime = require('mime/lite')
-const SDK = require('hyper-sdk')
-const parseRange = require('range-parser')
-const makeDir = require('make-dir')
-const { Readable } = require('streamx')
-const makeFetch = require('make-fetch')
-const { EventIterator } = require('event-iterator')
-const Busboy = require('busboy')
-const posixPath = require('path').posix
+import { posix } from 'path'
-const DEFAULT_TIMEOUT = 5000
-const NUMBER_REGEX = /^\d+$/
-const PROTOCOL_REGEX = /^\w+:\/\//
-const NOT_WRITABLE_ERROR = 'Archive not writable'
+import { Readable, pipelinePromise } from 'streamx'
+import Hyperdrive from 'hyperdrive'
+import { makeRoutedFetch } from 'make-fetch'
+import mime from 'mime/lite.js'
+import parseRange from 'range-parser'
+import { EventIterator } from 'event-iterator'
-const READABLE_ALLOW = ['GET', 'HEAD']
-const WRITABLE_ALLOW = ['PUT', 'POST', 'DELETE']
-const ALL_ALLOW = READABLE_ALLOW.concat(WRITABLE_ALLOW)
+const DEFAULT_TIMEOUT = 5000
-const SPECIAL_FOLDER = '/$/'
-const TAGS_FOLDER_NAME = 'tags/'
-const TAGS_FOLDER = SPECIAL_FOLDER + TAGS_FOLDER_NAME
-const EXTENSIONS_FOLDER_NAME = 'extensions/'
-const EXTENSIONS_FOLDER = SPECIAL_FOLDER + EXTENSIONS_FOLDER_NAME
+const SPECIAL_DOMAIN = 'localhost'
+const SPECIAL_FOLDER = '$'
+const EXTENSIONS_FOLDER_NAME = 'extensions'
 const EXTENSION_EVENT = 'extension-message'
 const PEER_OPEN = 'peer-open'
 const PEER_REMOVE = 'peer-remove'
-// TODO: Add caching support
-const { resolveURL: DEFAULT_RESOLVE_URL } = require('hyper-dns')
+const MIME_TEXT_PLAIN = 'text/plain; charset=utf-8'
+const MIME_APPLICATION_JSON = 'application/json'
+const MIME_TEXT_HTML = 'text/html; charset=utf-8'
+const MIME_EVENT_STREAM = 'text/event-stream; charset=utf-8'
+const HEADER_CONTENT_TYPE = 'Content-Type'
+async function DEFAULT_RENDER_INDEX (url, files, fetch) {
+  return `
+<!DOCTYPE html>
+<title>Index of ${url.pathname}</title>
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<h1>Index of ${url.pathname}</h1>
+<ul>
+  <li><a href="../">../</a></li>
+  ${files.map((file) => `<li><a href="${file}">./${file}</a></li>`).join('\n')}
+</ul>
+`
+}
+export default async function makeHyperFetch ({
+  sdk,
+  writable = false,
+  extensionMessages = writable,
+  timeout = DEFAULT_TIMEOUT,
+  renderIndex = DEFAULT_RENDER_INDEX
+}) {
+  const { fetch, router } = makeRoutedFetch()
+  // Map loaded drive hostnames to their keys
+  // TODO: Track LRU + cache clearing
+  const drives = new Map()
+  const extensions = new Map()
+  const cores = new Map()
+  async function getCore (hostname) {
+    if (cores.has(hostname)) {
+      return cores.get(hostname)
+    }
+    const core = await sdk.get(hostname)
+    await core.ready()
+    cores.set(core.id, core)
+    cores.set(core.url, core)
+    return core
+  }
-module.exports = function makeHyperFetch (opts = {}) {
-  let {
-    Hyperdrive,
-    resolveURL = DEFAULT_RESOLVE_URL,
-    base,
-    timeout = DEFAULT_TIMEOUT,
-    writable = false
-  } = opts
+  async function getDBCoreForName (name) {
+    const corestore = sdk.namespace(name)
+    const dbCore = corestore.get({ name: 'db' })
+    await dbCore.ready()
+    if (!dbCore.discovery) {
+      const discovery = sdk.join(dbCore.discoveryKey)
+      dbCore.discovery = discovery
+      dbCore.once('close', () => {
+        discovery.destroy()
+      })
+      await discovery.flushed()
+    }
+    return dbCore
+  }
+  async function getDrive (hostname) {
+    if (drives.has(hostname)) {
+      return drives.get(hostname)
+    }
+    const core = await getCore(hostname)
+    const corestore = sdk.namespace(core.id)
+    const drive = new Hyperdrive(corestore, core.key)
+    await drive.ready()
+    drives.set(drive.core.id, drive)
+    drives.set(hostname, drive)
+    return drive
+  }
+  async function getDriveFromKey (key, errorOnNew = false) {
+    if (drives.has(key)) {
+      return drives.get(key)
+    }
+    const core = await getDBCoreForName(key)
+    if (!core.length && errorOnNew) {
+      return { status: 400, body: 'Must create key with POST before reading' }
+    }
-  let sdk = null
-  let gettingSDK = null
-  let onClose = async () => undefined
+    const corestore = sdk.namespace(key)
+    const drive = new Hyperdrive(corestore)
-  const isSourceDat = base && base.startsWith('hyper://')
+    await drive.ready()
-  const fetch = makeFetch(hyperFetch)
+    drives.set(key, drive)
+    drives.set(drive.core.id, drive)
-  fetch.close = () => onClose()
+    return drive
+  }
-  function getExtension (archive, name) {
-    const existing = archive.metadata.extensions.get(name)
-    if (existing) return existing
+  async function getExtension (core, name) {
+    const key = core.url + name
+    if (extensions.has(key)) {
+      return extensions.get(key)
+    }
+    const existing = core.extensions.get(name)
+    if (existing) {
+      extensions.set(key, existing)
+      return existing
+    }
-    const extension = archive.registerExtension(name, {
+    const extension = core.registerExtension(name, {
       encoding: 'utf8',
       onmessage: (content, peer) => {
-        archive.emit(EXTENSION_EVENT, name, content, peer)
+        core.emit(EXTENSION_EVENT, name, content, peer)
       }
     })
+    extensions.set(key, extension)
     return extension
   }
-  function getExtensionPeers (archive, name) {
+  async function getExtensionPeers (core, name) {
     // List peers with this extension
-    const allPeers = archive.peers
+    const allPeers = core.peers
     return allPeers.filter((peer) => {
-      const { remoteExtensions } = peer
-      if (!remoteExtensions) return false
-      const { names } = remoteExtensions
-      if (!names) return false
-      return names.includes(name)
+      return peer?.extensions?.has(name)
     })
   }
-  function listExtensionNames (archive) {
-    return archive.metadata.extensions.names()
+  function listExtensionNames (core) {
+    return [...core.extensions.keys()]
   }
-  async function loadArchive (key) {
-    const Hyperdrive = await getHyperdrive()
-    return Hyperdrive(key)
-  }
+  if (extensionMessages) {
+    router.get(`hyper://*/${SPECIAL_FOLDER}/${EXTENSIONS_FOLDER_NAME}/`, async function listExtensions (request) {
+      const { hostname } = new URL(request.url)
+      const accept = request.headers.get('Accept') || ''
-  return fetch
+      const core = await getCore(`hyper://${hostname}/`)
-  async function hyperFetch ({ url, headers: rawHeaders, method, signal, body }) {
-    const isHyperURL = url.startsWith('hyper://')
-    const urlHasProtocol = url.match(PROTOCOL_REGEX)
+      if (accept.includes('text/event-stream')) {
+        const events = new EventIterator(({ push }) => {
+          function onMessage (name, content, peer) {
+            const id = peer.remotePublicKey.toString('hex')
+            // TODO: Fancy verification on the `name`?
+            // Send each line of content separately on a `data` line
+            const data = content.split('\n').map((line) => `data:${line}\n`).join('')
-    const shouldIntercept = isHyperURL || (!urlHasProtocol && isSourceDat)
+            push(`id:${id}\nevent:${name}\n${data}\n`)
+          }
+          function onPeerOpen (peer) {
+            const id = peer.remotePublicKey.toString('hex')
+            push(`id:${id}\nevent:${PEER_OPEN}\n\n`)
+          }
+          function onPeerRemove (peer) {
+            // Whatever, probably an uninitialized peer
+            if (!peer.remotePublicKey) return
+            const id = peer.remotePublicKey.toString('hex')
+            push(`id:${id}\nevent:${PEER_REMOVE}\n\n`)
+          }
+          core.on(EXTENSION_EVENT, onMessage)
+          core.on(PEER_OPEN, onPeerOpen)
+          core.on(PEER_REMOVE, onPeerRemove)
+          return () => {
+            core.removeListener(EXTENSION_EVENT, onMessage)
+            core.removeListener(PEER_OPEN, onPeerOpen)
+            core.removeListener(PEER_REMOVE, onPeerRemove)
+          }
+        })
-    if (!shouldIntercept) throw new Error('Invalid protocol, must be hyper://')
+        return {
+          statusCode: 200,
+          headers: {
+            [HEADER_CONTENT_TYPE]: MIME_EVENT_STREAM
+          },
+          body: events
+        }
+      }
-    const headers = new Headers(rawHeaders || {})
+      const extensions = listExtensionNames(core)
+      return {
+        status: 200,
+        headers: { [HEADER_CONTENT_TYPE]: MIME_APPLICATION_JSON },
+        body: JSON.stringify(extensions, null, '\t')
+      }
+    })
+    router.get(`hyper://*/${SPECIAL_FOLDER}/${EXTENSIONS_FOLDER_NAME}/*`, async function listenExtension (request) {
+      const { hostname, pathname } = new URL(request.url)
+      const name = pathname.slice(`/${SPECIAL_FOLDER}/${EXTENSIONS_FOLDER_NAME}/`.length)
+      const core = await getCore(`hyper://${hostname}/`)
-    const responseHeaders = {}
-    responseHeaders['Access-Control-Allow-Origin'] = '*'
-    responseHeaders['Allow-CSP-From'] = '*'
-    responseHeaders['Access-Control-Allow-Headers'] = '*'
+      await getExtension(core, name)
-    try {
-      let { pathname: path, key, version, searchParams } = parseDatURL(url)
-      if (!path) path = '/'
-      if (!path.startsWith('/')) path = '/' + path
+      const peers = await getExtensionPeers(core, name)
+      const finalPeers = formatPeers(peers)
+      const body = JSON.stringify(finalPeers, null, '\t')
-      try {
-        const resolvedURL = await resolveURL(`hyper://${key}`)
-        key = resolvedURL.hostname
-      } catch (e) {
-        // Probably a domain that couldn't resolve
-        if (key.includes('.')) throw e
+      return {
+        status: 200,
+        body,
+        headers: {
+          [HEADER_CONTENT_TYPE]: MIME_APPLICATION_JSON
+        }
       }
+    })
+    router.post(`hyper://*/${SPECIAL_FOLDER}/${EXTENSIONS_FOLDER_NAME}/*`, async function broadcastExtension (request) {
+      const { hostname, pathname } = new URL(request.url)
+      const name = pathname.slice(`/${SPECIAL_FOLDER}/${EXTENSIONS_FOLDER_NAME}/`.length)
+      const core = await getCore(`hyper://${hostname}/`)
-      let archive = await loadArchive(key)
+      const extension = await getExtension(core, name)
+      const data = await request.text()
+      extension.broadcast(data)
-      if (!archive) {
+      return { status: 200 }
+    })
+    router.post(`hyper://*/${SPECIAL_FOLDER}/${EXTENSIONS_FOLDER_NAME}/*/*`, async function extensionToPeer (request) {
+      const { hostname, pathname } = new URL(request.url)
+      const subFolder = pathname.slice(`/${SPECIAL_FOLDER}/${EXTENSIONS_FOLDER_NAME}/`.length)
+      const [name, extensionPeer] = subFolder.split('/')
+      const core = await getCore(`hyper://${hostname}/`)
+      const extension = await getExtension(core, name)
+      const peers = await getExtensionPeers(core, name)
+      const peer = peers.find(({ remotePublicKey }) => remotePublicKey.toString('hex') === extensionPeer)
+      if (!peer) {
         return {
-          statusCode: 404,
-          headers: responseHeaders,
-          data: intoAsyncIterable('Unknown drive')
+          status: 404,
+          headers: {
+            [HEADER_CONTENT_TYPE]: MIME_TEXT_PLAIN
+          },
+          body: 'Peer Not Found'
         }
       }
+      const data = await request.arrayBuffer()
+      extension.send(data, peer)
+      return { status: 200 }
+    })
+  }
-      await archive.ready()
+  if (writable) {
+    router.get(`hyper://${SPECIAL_DOMAIN}/`, async function getKey (request) {
+      const key = new URL(request.url).searchParams.get('key')
+      if (!key) {
+        return { status: 400, body: 'Must specify key parameter to resolve' }
+      }
-      if (!archive.version) {
-        if (!archive.peers.length) {
-          await new Promise((resolve, reject) => {
-            setTimeout(() => reject(new Error('Timed out looking for peers')), timeout)
-            archive.once('peer-open', resolve)
-          })
-        }
-        await new Promise((resolve, reject) => {
-          archive.metadata.update({ ifAvailable: true }, (err) => {
-            if (err) reject(err)
-            else resolve()
-          })
-        })
+      const drive = await getDriveFromKey(key, true)
+      return { body: drive.url }
+    })
+    router.post(`hyper://${SPECIAL_DOMAIN}/`, async function createKey (request) {
+      // TODO: Allow importing secret keys here
+      // Maybe specify a seed to use for generating the blobs?
+      // Else we'd need to specify the blobs keys and metadata keys
+      const key = new URL(request.url).searchParams.get('key')
+      if (!key) {
+        return { status: 400, body: 'Must specify key parameter to resolve' }
       }
-      if (version) {
-        if (NUMBER_REGEX.test(version)) {
-          archive = await archive.checkout(version)
-        } else {
-          archive = await archive.checkout(await archive.getTaggedVersion(version))
+      const drive = await getDriveFromKey(key, false)
+      return { body: drive.core.url }
+    })
+    router.put('hyper://*/**', async function putFiles (request) {
+      const { hostname, pathname } = new URL(request.url)
+      const contentType = request.headers.get('Content-Type') || ''
+      const isFormData = contentType.includes('multipart/form-data')
+      const drive = await getDrive(hostname)
+      if (isFormData) {
+        // It's a form! Get the files out and process them
+        const formData = await request.formData()
+        for (const [name, data] of formData) {
+          if (name !== 'file') continue
+          const filePath = posix.join(pathname, data.name)
+          await pipelinePromise(
+            Readable.from(data.stream()),
+            drive.createWriteStream(filePath, {
+              metadata: {
+                mtime: Date.now()
+              }
+            })
+          )
         }
-        await archive.ready()
+      } else {
+        await pipelinePromise(
+          Readable.from(request.body),
+          drive.createWriteStream(pathname)
+        )
       }
-      const canonical = `hyper://${archive.key.toString('hex')}${path || ''}`
-      responseHeaders.Link = `<${canonical}>; rel="canonical"`
-      const isWritable = writable && archive.writable
-      const allowHeaders = isWritable ? ALL_ALLOW : READABLE_ALLOW
-      responseHeaders.Allow = allowHeaders.join(', ')
-      // We can say the file hasn't changed if the drive version hasn't changed
-      responseHeaders.ETag = `"${archive.version}"`
-      if (path.startsWith(SPECIAL_FOLDER)) {
-        if (path === SPECIAL_FOLDER) {
-          const files = [
-            TAGS_FOLDER_NAME,
-            EXTENSIONS_FOLDER_NAME
-          ]
-          const data = renderFiles(headers, responseHeaders, url, path, files)
-          if (method === 'HEAD') {
-            return {
-              statusCode: 204,
-              headers: responseHeaders,
-              data: intoAsyncIterable('')
-            }
-          } else {
-            return {
-              statusCode: 200,
-              headers: responseHeaders,
-              data
-            }
-          }
-        } else if (path.startsWith(TAGS_FOLDER)) {
-          if (method === 'GET') {
-            if (path === TAGS_FOLDER) {
-              responseHeaders['x-is-directory'] = 'true'
-              const tags = await archive.getAllTags()
-              const tagsObject = Object.fromEntries(tags)
-              const json = JSON.stringify(tagsObject, null, '\t')
-              responseHeaders['Content-Type'] = 'application/json; charset=utf-8'
-              return {
-                statusCode: 200,
-                headers: responseHeaders,
-                data: intoAsyncIterable(json)
-              }
-            } else {
-              const tagName = path.slice(TAGS_FOLDER.length)
-              try {
-                const tagVersion = await archive.getTaggedVersion(tagName)
-                return {
-                  statusCode: 200,
-                  headers: responseHeaders,
-                  data: intoAsyncIterable(`${tagVersion}`)
-                }
-              } catch {
-                return {
-                  statusCode: 404,
-                  headers: responseHeaders,
-                  data: intoAsyncIterable('Tag Not Found')
-                }
-              }
-            }
-          } else if (method === 'DELETE') {
-            checkWritable(archive)
-            const tagName = path.slice(TAGS_FOLDER.length)
-            await archive.deleteTag(tagName || version)
-            responseHeaders.ETag = `"${archive.version}"`
-            return {
-              statusCode: 200,
-              headers: responseHeaders,
-              data: intoAsyncIterable('')
-            }
-          } else if (method === 'PUT') {
-            checkWritable(archive)
-            const tagName = path.slice(TAGS_FOLDER.length)
-            const tagVersion = archive.version
-            await archive.createTag(tagName, tagVersion)
-            responseHeaders['Content-Type'] = 'text/plain; charset=utf-8'
-            responseHeaders.ETag = `"${archive.version}"`
-            return {
-              statusCode: 200,
-              headers: responseHeaders,
-              data: intoAsyncIterable(`${tagVersion}`)
-            }
-          } else if (method === 'HEAD') {
-            return {
-              statusCode: 204,
-              headers: responseHeaders,
-              data: intoAsyncIterable('')
-            }
-          } else {
-            return {
-              statusCode: 405,
-              headers: responseHeaders,
-              data: intoAsyncIterable('Method Not Allowed')
-            }
-          }
-        } else if (path.startsWith(EXTENSIONS_FOLDER)) {
-          if (path === EXTENSIONS_FOLDER) {
-            if (method === 'GET') {
-              const accept = headers.get('Accept') || ''
-              if (!accept.includes('text/event-stream')) {
-                responseHeaders['x-is-directory'] = 'true'
-                const extensions = listExtensionNames(archive)
-                const data = renderFiles(headers, responseHeaders, url, path, extensions)
-                return {
-                  statusCode: 204,
-                  headers: responseHeaders,
-                  data
-                }
-              }
+      // TODO: Use 201 with location in response headers
+      return { status: 200 }
+    })
+    router.delete('hyper://*/**', async function putFiles (request) {
+      const { hostname, pathname } = new URL(request.url)
-              const events = new EventIterator(({ push }) => {
-                function onMessage (name, content, peer) {
-                  const id = peer.remotePublicKey.toString('hex')
-                  // TODO: Fancy verification on the `name`?
-                  // Send each line of content separately on a `data` line
-                  const data = content.split('\n').map((line) => `data:${line}\n`).join('')
-                  push(`id:${id}\nevent:${name}\n${data}\n`)
-                }
-                function onPeerOpen (peer) {
-                  const id = peer.remotePublicKey.toString('hex')
-                  push(`id:${id}\nevent:${PEER_OPEN}\n\n`)
-                }
-                function onPeerRemove (peer) {
-                  // Whatever, probably an uninitialized peer
-                  if (!peer.remotePublicKey) return
-                  const id = peer.remotePublicKey.toString('hex')
-                  push(`id:${id}\nevent:${PEER_REMOVE}\n\n`)
-                }
-                archive.on(EXTENSION_EVENT, onMessage)
-                archive.on(PEER_OPEN, onPeerOpen)
-                archive.on(PEER_REMOVE, onPeerRemove)
-                return () => {
-                  archive.removeListener(EXTENSION_EVENT, onMessage)
-                  archive.removeListener(PEER_OPEN, onPeerOpen)
-                  archive.removeListener(PEER_REMOVE, onPeerRemove)
-                }
-              })
-              responseHeaders['Content-Type'] = 'text/event-stream'
-              return {
-                statusCode: 200,
-                headers: responseHeaders,
-                data: events
-              }
-            } else {
-              return {
-                statusCode: 405,
-                headers: responseHeaders,
-                data: intoAsyncIterable('Method Not Allowed')
-              }
-            }
-          } else {
-            let extensionName = path.slice(EXTENSIONS_FOLDER.length)
-            let extensionPeer = null
-            if (extensionName.includes('/')) {
-              const split = extensionName.split('/')
-              extensionName = split[0]
-              if (split[1]) extensionPeer = split[1]
-            }
-            if (method === 'POST') {
-              const extension = getExtension(archive, extensionName)
-              if (extensionPeer) {
-                const peers = getExtensionPeers(archive, extensionName)
-                const peer = peers.find(({ remotePublicKey }) => remotePublicKey.toString('hex') === extensionPeer)
-                if (!peer) {
-                  return {
-                    statusCode: 404,
-                    headers: responseHeaders,
-                    data: intoAsyncIterable('Peer Not Found')
-                  }
-                }
-                extension.send(await collect(body), peer)
-              } else {
-                extension.broadcast(await collect(body))
-              }
-              return {
-                statusCode: 200,
-                headers: responseHeaders,
-                data: intoAsyncIterable('')
-              }
-            } else if (method === 'GET') {
-              const accept = headers.get('Accept') || ''
-              if (!accept.includes('text/event-stream')) {
-                // Load up the extension into memory
-                getExtension(archive, extensionName)
-                const extensionPeers = getExtensionPeers(archive, extensionName)
-                const finalPeers = formatPeers(extensionPeers)
-                const json = JSON.stringify(finalPeers, null, '\t')
-                return {
-                  statusCode: 200,
-                  header: responseHeaders,
-                  data: intoAsyncIterable(json)
-                }
-              }
-            } else {
-              return {
-                statusCode: 405,
-                headers: responseHeaders,
-                data: intoAsyncIterable('Method Not Allowed')
-              }
-            }
-          }
-        } else {
-          return {
-            statusCode: 404,
-            headers: responseHeaders,
-            data: intoAsyncIterable('Not Found')
-          }
+      const drive = await getDrive(hostname)
+      if (pathname.endsWith('/')) {
+        let didDelete = false
+        for await (const entry of drive.list(pathname)) {
+          await drive.del(entry.key)
+          didDelete = true
         }
+        if (!didDelete) {
+          return { status: 404, body: 'Not Found', headers: { [HEADER_CONTENT_TYPE]: MIME_TEXT_PLAIN } }
+        }
+        return { status: 200 }
       }
-      if (method === 'PUT') {
-        checkWritable(archive)
-        const contentType = headers.get('Content-Type') || headers.get('content-type')
-        const isFormData = contentType && contentType.includes('multipart/form-data')
-        if (path.endsWith('/')) {
-          await makeDir(path, { fs: archive })
-          const busboy = new Busboy({ headers: rawHeaders })
-          const toUpload = new EventIterator(({ push, stop, fail }) => {
-            busboy.once('error', fail)
-            busboy.once('finish', stop)
-            busboy.on('file', async (fieldName, fileData, fileName) => {
-              const finalPath = posixPath.join(path, fileName)
-              const source = Readable.from(fileData)
-              const destination = archive.createWriteStream(finalPath)
-              source.pipe(destination)
-              try {
-                Promise.race([
-                  once(source, 'error').then((e) => { throw e }),
-                  once(destination, 'error').then((e) => { throw e }),
-                  once(source, 'end')
-                ])
-              } catch (e) {
-                fail(e)
-              }
-            })
+      const entry = await drive.entry(pathname)
-            // TODO: Does busboy need to be GC'd?
-            return () => {}
-          })
+      if (!entry) {
+        return { status: 404, body: 'Not Found', headers: { [HEADER_CONTENT_TYPE]: MIME_TEXT_PLAIN } }
+      }
+      await drive.del(pathname)
-          Readable.from(body).pipe(busboy)
+      return { status: 200 }
+    })
+  }
-          await Promise.all(await collect(toUpload))
+  router.head('hyper://*/**', async function headFiles (request) {
+    const url = new URL(request.url)
+    const { hostname, pathname, searchParams } = url
+    const accept = request.headers.get('Accept') || ''
+    const isRanged = request.headers.get('Range') || ''
+    const noResolve = searchParams.has('noResolve')
+    const isDirectory = pathname.endsWith('/')
-          return {
-            statusCode: 200,
-            headers: responseHeaders,
-            data: intoAsyncIterable(canonical)
-          }
-        } else {
-          if (isFormData) {
-            return {
-              statusCode: 400,
-              headers: responseHeaders,
-              data: intoAsyncIterable('FormData only supported for folders (ending with a /)')
-            }
-          }
-          const parentDir = path.split('/').slice(0, -1).join('/')
-          if (parentDir) {
-            await makeDir(parentDir, { fs: archive })
-          }
+    const drive = await getDrive(hostname)
-          const source = Readable.from(body)
-          const destination = archive.createWriteStream(path)
-          // The sink is needed because Hyperdrive's write stream is duplex
+    const resHeaders = {
+      ETag: `${drive.version}`,
+      'Accept-Ranges': 'bytes',
+      Link: `<${drive.core.url}>; rel="canonical"`
+    }
-          source.pipe(destination)
+    if (isDirectory) {
+      const entries = await listEntries(drive, pathname)
-          await Promise.race([
-            once(source, 'error'),
-            once(destination, 'error'),
-            once(source, 'end')
-          ])
-        }
-        responseHeaders.ETag = `"${archive.version}"`
+      const hasItems = entries.length
+      if (!hasItems && pathname !== '/') {
         return {
-          statusCode: 200,
-          headers: responseHeaders,
-          data: intoAsyncIterable(canonical)
-        }
-      } else if (method === 'DELETE') {
-        if (headers.get('x-clear') === 'cache') {
-          await archive.clear(path)
-          return {
-            statusCode: 200,
-            headers: responseHeaders,
-            data: intoAsyncIterable('')
+          status: 404,
+          headers: {
+            [HEADER_CONTENT_TYPE]: MIME_TEXT_PLAIN
           }
-        } else {
-          checkWritable(archive)
-          const stats = await archive.stat(path)
-          // Weird stuff happening up in here...
-          const stat = Array.isArray(stats) ? stats[0] : stats
+        }
+      }
-          if (stat.isDirectory()) {
-            await archive.rmdir(path)
-          } else {
-            await archive.unlink(path)
+      if (!noResolve) {
+        if (entries.includes('index.html')) {
+          return {
+            status: 204,
+            headers: {
+              ...resHeaders,
+              [HEADER_CONTENT_TYPE]: MIME_TEXT_HTML
+            }
           }
-          responseHeaders.ETag = `"${archive.version}"`
+        }
+      }
-          return {
-            statusCode: 200,
-            headers: responseHeaders,
-            data: intoAsyncIterable('')
+      // TODO: Add range header calculation
+      if (accept.includes('text/html')) {
+        return {
+          status: 204,
+          headers: {
+            ...resHeaders,
+            [HEADER_CONTENT_TYPE]: MIME_TEXT_HTML
           }
         }
-      } else if ((method === 'GET') || (method === 'HEAD')) {
-        if (method === 'GET' && headers.get('Accept') === 'text/event-stream') {
-          const contentFeed = await archive.getContent()
-          const events = new EventIterator(({ push, fail }) => {
-            const watcher = archive.watch(path, () => {
-              const event = 'change'
-              const data = archive.version
-              push({ event, data })
-            })
-            watcher.on('error', fail)
-            function onDownloadMetadata (index) {
-              const event = 'download'
-              const source = archive.metadata.key.toString('hex')
-              const data = { index, source }
-              push({ event, data })
-            }
-            function onUploadMetadata (index) {
-              const event = 'download'
-              const source = archive.metadata.key.toString('hex')
-              const data = { index, source }
-              push({ event, data })
-            }
+      }
-            function onDownloadContent (index) {
-              const event = 'download'
-              const source = contentFeed.key.toString('hex')
-              const data = { index, source }
-              push({ event, data })
-            }
-            function onUploadContent (index) {
-              const event = 'download'
-              const source = contentFeed.key.toString('hex')
-              const data = { index, source }
-              push({ event, data })
-            }
+      return {
+        status: 204,
+        headers: {
+          ...resHeaders,
+          [HEADER_CONTENT_TYPE]: MIME_APPLICATION_JSON
+        }
+      }
+    }
+    const entry = await drive.entry(pathname)
-            // TODO: Filter out indexes that don't belong to files?
-            archive.metadata.on('download', onDownloadMetadata)
-            archive.metadata.on('upload', onUploadMetadata)
-            contentFeed.on('download', onDownloadContent)
-            contentFeed.on('upload', onUploadMetadata)
-            return () => {
-              watcher.destroy()
-              archive.metadata.removeListener('download', onDownloadMetadata)
-              archive.metadata.removeListener('upload', onUploadMetadata)
-              contentFeed.removeListener('download', onDownloadContent)
-              contentFeed.removeListener('upload', onUploadContent)
-            }
-          })
-          async function * startReader () {
-            for await (const { event, data } of events) {
-              yield `event:${event}\ndata:${JSON.stringify(data)}\n\n`
-            }
-          }
+    if (!entry) {
+      return { status: 404, body: 'Not Found' }
+    }
-          responseHeaders['Content-Type'] = 'text/event-stream'
+    resHeaders.ETag = `${entry.seq}`
-          return {
-            statusCode: 200,
-            headers: responseHeaders,
-            data: startReader()
-          }
-        }
+    const contentType = getMimeType(pathname)
+    resHeaders['Content-Type'] = contentType
-        let stat = null
-        let finalPath = path
+    if (entry.metadata?.mtime) {
+      const date = new Date(entry.metadata.mtime)
+      resHeaders['Last-Modified'] = date.toUTCString()
+    }
-        if (headers.get('x-download') === 'cache') {
-          await archive.download(path)
-        }
+    const size = entry.value.byteLength
+    if (isRanged) {
+      const ranges = parseRange(size, isRanged)
-        // Legacy DNS spec from Dat protocol: https://github.com/datprotocol/DEPs/blob/master/proposals/0005-dns.md
-        if (finalPath === '/.well-known/dat') {
-          const { key } = archive
-          const entry = `dat://${key.toString('hex')}\nttl=3600`
-          return {
-            statusCode: 200,
-            headers: responseHeaders,
-            data: intoAsyncIterable(entry)
-          }
-        }
+      if (ranges && ranges.length && ranges.type === 'bytes') {
+        const [{ start, end }] = ranges
+        const length = (end - start + 1)
-        // New spec from hyper-dns https://github.com/martinheidegger/hyper-dns
-        if (finalPath === '/.well-known/hyper') {
-          const { key } = archive
-          const entry = `hyper://${key.toString('hex')}\nttl=3600`
-          return {
-            statusCode: 200,
-            headers: responseHeaders,
-            data: intoAsyncIterable(entry)
-          }
-        }
-        try {
-          if (searchParams.has('noResolve')) {
-            const stats = await archive.stat(path)
-            stat = stats[0]
-          } else {
-            const resolved = await resolveDatPath(archive, path)
-            finalPath = resolved.path
-            stat = resolved.stat
-          }
-        } catch (e) {
-          responseHeaders['Content-Type'] = 'text/plain; charset=utf-8'
-          return {
-            statusCode: 404,
-            headers: responseHeaders,
-            data: intoAsyncIterable(e.stack)
+        return {
+          status: 200,
+          headers: {
+            ...resHeaders,
+            'Content-Length': `${length}`,
+            'Content-Range': `bytes ${start}-${end}/${size}`
           }
         }
+      }
+    }
-        responseHeaders['Content-Type'] = getMimeType(finalPath)
-        responseHeaders['Last-Modified'] = stat.mtime.toUTCString()
-        let data = null
-        const isRanged = headers.get('Range') || headers.get('range')
-        let statusCode = 200
+    return {
+      status: 200,
+      headers: resHeaders
+    }
+  })
-        if (stat.isDirectory()) {
-          responseHeaders['x-is-directory'] = 'true'
-          const stats = await archive.readdir(finalPath, { includeStats: true })
-          const files = stats.map(({ stat, name }) => (stat.isDirectory() ? `${name}/` : name))
+  // TODO: Redirect on directories without trailing slash
+  router.get('hyper://*/**', async function getFiles (request) {
+    const url = new URL(request.url)
+    const { hostname, pathname, searchParams } = url
+    const accept = request.headers.get('Accept') || ''
+    const noResolve = searchParams.has('noResolve')
+    const isDirectory = pathname.endsWith('/')
-          // Add special directory
-          if (finalPath === '/') files.unshift('$/')
+    const drive = await getDrive(hostname)
-          data = renderFiles(headers, responseHeaders, url, path, files)
-        } else {
-          responseHeaders['Accept-Ranges'] = 'bytes'
+    if (isDirectory) {
+      const resHeaders = {
+        ETag: `${drive.version}`,
+        Link: `<${drive.core.url}>; rel="canonical"`
+      }
-          try {
-            const { blocks, downloadedBlocks } = await archive.stats(finalPath)
-            responseHeaders['X-Blocks'] = `${blocks}`
-            responseHeaders['X-Blocks-Downloaded'] = `${downloadedBlocks}`
-          } catch (e) {
-            // Don't worry about it, it's optional.
-          }
+      const entries = await listEntries(drive, pathname)
-          const { size } = stat
-          responseHeaders['Content-Length'] = `${size}`
-          if (isRanged) {
-            const ranges = parseRange(size, isRanged)
-            if (ranges && ranges.length && ranges.type === 'bytes') {
-              statusCode = 206
-              const [{ start, end }] = ranges
-              const length = (end - start + 1)
-              responseHeaders['Content-Length'] = `${length}`
-              responseHeaders['Content-Range'] = `bytes ${start}-${end}/${size}`
-              if (method !== 'HEAD') {
-                data = archive.createReadStream(finalPath, {
-                  start,
-                  end
-                })
-              }
-            } else {
-              if (method !== 'HEAD') {
-                data = archive.createReadStream(finalPath)
-              }
-            }
-          } else if (method !== 'HEAD') {
-            data = archive.createReadStream(finalPath)
+      if (!entries.length && pathname !== '/') {
+        return {
+          status: 404,
+          body: '[]',
+          headers: {
+            ...resHeaders,
+            [HEADER_CONTENT_TYPE]: MIME_APPLICATION_JSON
           }
         }
+      }
-        if (method === 'HEAD') {
-          return {
-            statusCode: 204,
-            headers: responseHeaders,
-            data: intoAsyncIterable('')
-          }
-        } else {
-          return {
-            statusCode,
-            headers: responseHeaders,
-            data
-          }
+      if (!noResolve) {
+        if (entries.includes('index.html')) {
+          return serveFile(request.headers, drive, posix.join(pathname, 'index.html'))
         }
-      } else {
+      }
+      if (accept.includes('text/html')) {
+        const body = renderIndex(url, entries, fetch)
         return {
-          statusCode: 405,
-          headers: responseHeaders,
-          data: intoAsyncIterable('Method Not Allowed')
+          status: 200,
+          body,
+          headers: {
+            ...resHeaders,
+            [HEADER_CONTENT_TYPE]: MIME_TEXT_HTML
+          }
         }
       }
-    } catch (e) {
-      const isUnauthorized = (e.message === NOT_WRITABLE_ERROR)
-      const statusCode = isUnauthorized ? 403 : 500
-      const statusText = isUnauthorized ? 'Not Authorized' : 'Server Error'
       return {
-        statusCode,
-        statusText,
-        headers: responseHeaders,
-        data: intoAsyncIterable(e.stack)
+        status: 200,
+        body: JSON.stringify(entries, null, '\t'),
+        headers: {
+          ...resHeaders,
+          [HEADER_CONTENT_TYPE]: MIME_APPLICATION_JSON
+        }
       }
     }
-  }
-  function getHyperdrive () {
-    if (Hyperdrive) return Hyperdrive
-    return getSDK().then(({ Hyperdrive }) => Hyperdrive)
-  }
+    const entry = await drive.entry(pathname)
-  function getSDK () {
-    if (sdk) return Promise.resolve(sdk)
-    if (gettingSDK) return gettingSDK
-    gettingSDK = SDK(opts).then((gotSDK) => {
-      sdk = gotSDK
-      gettingSDK = null
-      onClose = async () => sdk.close()
-      Hyperdrive = sdk.Hyperdrive
-      return sdk
-    })
-    return gettingSDK
-  }
-  function checkWritable (archive) {
-    if (!writable) throw new Error(NOT_WRITABLE_ERROR)
-    if (!archive.writable) {
-      throw new Error(NOT_WRITABLE_ERROR)
+    if (!entry) {
+      return { status: 404, body: 'Not Found' }
     }
-  }
-}
-function parseDatURL (url) {
-  const parsed = new URL(url)
-  let key = parsed.hostname
-  let version = null
-  if (key.includes('+')) [key, version] = key.split('+')
-  parsed.key = key
-  parsed.version = version
+    return serveFile(request.headers, drive, pathname)
+  })
-  return parsed
+  return fetch
 }
-async function * intoAsyncIterable (data) {
-  yield Buffer.from(data)
-}
+async function serveFile (headers, drive, pathname) {
+  const isRanged = headers.get('Range') || ''
+  const contentType = getMimeType(pathname)
-function getMimeType (path) {
-  let mimeType = mime.getType(path) || 'text/plain; charset=utf-8'
-  if (mimeType.startsWith('text/')) mimeType = `${mimeType}; charset=utf-8`
-  return mimeType
-}
+  const entry = await drive.entry(pathname)
-function renderDirectory (url, path, files) {
-  return `<!DOCTYPE html>
-<title>${url}</title>
-<meta name="viewport" content="width=device-width, initial-scale=1" />
-<h1>Index of ${path}</h1>
-<ul>
-  <li><a href="../">../</a></li>${files.map((file) => `
-  <li><a href="${file}">./${file}</a></li>
-`).join('')}
-</ul>
-`
-}
+  const resHeaders = {
+    ETag: `${entry.seq}`,
+    [HEADER_CONTENT_TYPE]: contentType,
+    'Accept-Ranges': 'bytes',
+    Link: `<${drive.core.url}>; rel="canonical"`
+  }
-function renderFiles (headers, responseHeaders, url, path, files) {
-  if (headers.get('Accept') && headers.get('Accept').includes('text/html')) {
-    const page = renderDirectory(url, path, files)
-    responseHeaders['Content-Type'] = 'text/html; charset=utf-8'
-    return intoAsyncIterable(page)
-  } else {
-    const json = JSON.stringify(files, null, '\t')
-    responseHeaders['Content-Type'] = 'application/json; charset=utf-8'
-    return intoAsyncIterable(json)
+  if (entry.metadata?.mtime) {
+    const date = new Date(entry.metadata.mtime)
+    resHeaders['Last-Modified'] = date.toUTCString()
   }
-}
-function once (ee, name) {
-  return new Promise((resolve, reject) => {
-    const isError = name === 'error'
-    const cb = isError ? reject : resolve
-    ee.once(name, cb)
-  })
-}
+  const size = entry.value.blob.byteLength
+  if (isRanged) {
+    const ranges = parseRange(size, isRanged)
-async function collect (source) {
-  let buffer = ''
+    if (ranges && ranges.length && ranges.type === 'bytes') {
+      const [{ start, end }] = ranges
+      const length = (end - start + 1)
-  for await (const chunk of source) {
-    buffer += chunk
+      return {
+        status: 200,
+        body: drive.createReadStream(pathname, {
+          start,
+          end
+        }),
+        headers: {
+          ...resHeaders,
+          'Content-Length': `${length}`,
+          'Content-Range': `bytes ${start}-${end}/${size}`
+        }
+      }
+    }
+  }
+  return {
+    status: 200,
+    headers: {
+      ...resHeaders,
+      'Content-Length': `${size}`
+    },
+    body: drive.createReadStream(pathname)
   }
+}
-  return buffer
+async function listEntries (drive, pathname = '/') {
+  const entries = []
+  for await (const path of drive.readdir(pathname)) {
+    const stat = await drive.entry(path)
+    if (stat === null) {
+      entries.push(path + '/')
+    } else {
+      entries.push(path)
+    }
+  }
+  return entries
 }
 function formatPeers (peers) {
-  return peers.map(({ remotePublicKey, remoteAddress, remoteType, stats }) => {
+  return peers.map((peer) => {
+    const remotePublicKey = peer.remotePublicKey.toString('hex')
+    const remoteHost = peer.stream?.rawStream?.remoteHost
     return {
-      remotePublicKey: remotePublicKey.toString('hex'),
-      remoteType,
-      remoteAddress,
-      stats
+      remotePublicKey,
+      remoteHost
     }
   })
 }
+function getMimeType (path) {
+  let mimeType = mime.getType(path) || 'text/plain; charset=utf-8'
+  if (mimeType.startsWith('text/')) mimeType = `${mimeType}; charset=utf-8`
+  return mimeType
+}