dsh-remote-control-plugin 0.3.6 → 0.4.0

package/host/qr.js

@@ -0,0 +1,212 @@
+/**
+ * Minimal QR encoder for invite payloads: byte mode, error correction level L,
+ * versions 1-5 (up to 106 bytes), mask 0.
+ *
+ * Deliberately small: no micro-QR, no multi-block interleaving, no mask
+ * selection heuristics. Enough for `http://host:port/ <key>#<code>`, and every
+ * byte of it is verified by scripts/qr-test.mjs (round trip + RS syndromes).
+ */
+
+const DATA_CODEWORDS = [19, 34, 55, 80, 108]
+const ECC_CODEWORDS = [7, 10, 15, 20, 26]
+
+/* ---- GF(256) ---- */
+const EXP = new Uint8Array(512)
+const LOG = new Uint8Array(256)
+{
+  let value = 1
+  for (let i = 0; i < 255; i += 1) {
+    EXP[i] = value
+    LOG[value] = i
+    value <<= 1
+    if (value & 0x100) value ^= 0x11d
+  }
+  for (let i = 255; i < 512; i += 1) EXP[i] = EXP[i - 255]
+}
+
+function gfMul(a, b) {
+  if (a === 0 || b === 0) return 0
+  return EXP[LOG[a] + LOG[b]]
+}
+
+function rsGenerator(count) {
+  // Descending coefficients: generator[0] is the leading (x^count) term, 1.
+  let poly = [1]
+  for (let i = 0; i < count; i += 1) {
+    const root = EXP[i]
+    const next = new Array(poly.length + 1).fill(0)
+    for (let j = 0; j <= poly.length; j += 1) {
+      let value = 0
+      if (j < poly.length) value ^= poly[j]
+      if (j > 0) value ^= gfMul(poly[j - 1], root)
+      next[j] = value
+    }
+    poly = next
+  }
+  return poly
+}
+
+function rsEncode(data, eccCount) {
+  const generator = rsGenerator(eccCount)
+  const buffer = new Uint8Array(data.length + eccCount)
+  buffer.set(data)
+  // Long division: buffer starts as d(x) * x^ecc, subtract g(x) until the
+  // leading coefficient is gone. The remainder is the ECC block.
+  for (let i = 0; i < data.length; i += 1) {
+    const factor = buffer[i]
+    if (factor === 0) continue
+    for (let j = 0; j < generator.length; j += 1) {
+      buffer[i + j] ^= gfMul(generator[j], factor)
+    }
+  }
+  return buffer.slice(data.length)
+}
+
+/* ---- bit stream ---- */
+function buildCodewords(bytes) {
+  let version = 1
+  for (let index = 0; index < DATA_CODEWORDS.length; index += 1) {
+    if (bytes.length <= DATA_CODEWORDS[index]) { version = index + 1; break }
+    version = index + 1
+  }
+  const capacity = DATA_CODEWORDS[version - 1]
+  if (bytes.length > capacity) throw new Error(`payload too long for QR v${version}`)
+
+  const bits = []
+  const push = (value, length) => { for (let i = length - 1; i >= 0; i -= 1) bits.push((value >>> i) & 1) }
+  push(0b0100, 4) // byte mode
+  push(bytes.length, 8)
+  for (const byte of bytes) push(byte, 8)
+  const totalBits = capacity * 8
+  push(0, Math.min(4, totalBits - bits.length)) // terminator
+  while (bits.length % 8 !== 0) bits.push(0)
+  const data = new Uint8Array(capacity)
+  for (let i = 0; i < bits.length; i += 8) {
+    let value = 0
+    for (let j = 0; j < 8; j += 1) value = (value << 1) | bits[i + j]
+    data[i / 8] = value
+  }
+  const pads = [0xec, 0x11]
+  for (let i = bits.length / 8, p = 0; i < capacity; i += 1, p += 1) data[i] = pads[p % 2]
+
+  return { version, data, ecc: rsEncode(data, ECC_CODEWORDS[version - 1]) }
+}
+
+/* ---- matrix ---- */
+export function encodeQr(text) {
+  const bytes = Buffer.from(String(text), 'utf8')
+  const { version, data, ecc } = buildCodewords(bytes)
+  const size = 17 + version * 4
+  const modules = Array.from({ length: size }, () => new Array(size).fill(false))
+  const reserved = Array.from({ length: size }, () => new Array(size).fill(false))
+
+  const set = (row, col, dark) => { modules[row][col] = dark; reserved[row][col] = true }
+
+  // finder patterns + separators
+  for (const [top, left] of [[0, 0], [0, size - 7], [size - 7, 0]]) {
+    for (let r = -1; r <= 7; r += 1) {
+      for (let c = -1; c <= 7; c += 1) {
+        const row = top + r
+        const col = left + c
+        if (row < 0 || col < 0 || row >= size || col >= size) continue
+        const inside = r >= 0 && r <= 6 && c >= 0 && c <= 6
+        const border = r === 0 || r === 6 || c === 0 || c === 6
+        const core = r >= 2 && r <= 4 && c >= 2 && c <= 4
+        set(row, col, inside && (border || core))
+      }
+    }
+  }
+
+  // timing patterns
+  for (let i = 8; i < size - 8; i += 1) {
+    if (!reserved[6][i]) set(6, i, i % 2 === 0)
+    if (!reserved[i][6]) set(i, 6, i % 2 === 0)
+  }
+
+  // alignment pattern (one per version 2-5)
+  if (version >= 2) {
+    const center = size - 7
+    for (let r = -2; r <= 2; r += 1) {
+      for (let c = -2; c <= 2; c += 1) {
+        set(center + r, center + c, Math.max(Math.abs(r), Math.abs(c)) !== 1)
+      }
+    }
+  }
+
+  // format information: level L (01), mask 0
+  const formatData = (1 << 3) | 0
+  let remainder = formatData
+  for (let i = 0; i < 10; i += 1) remainder = (remainder << 1) ^ ((remainder >> 9) * 0x537)
+  const formatBits = ((formatData << 10) | remainder) ^ 0x5412
+  for (let i = 0; i < 15; i += 1) {
+    const dark = ((formatBits >> i) & 1) === 1
+    if (i < 6) set(i, 8, dark)
+    else if (i < 8) set(i + 1, 8, dark)
+    else set(size - 15 + i, 8, dark)
+    if (i < 8) set(8, size - i - 1, dark)
+    else if (i === 8) set(8, 15 - i - 1 + 1, dark)
+    else set(8, 15 - i - 1, dark)
+  }
+  set(size - 8, 8, true) // dark module
+
+  // data placement, right-to-left zigzag, mask 0
+  let byteIndex = 0
+  let bitIndex = 7
+  let row = size - 1
+  let direction = -1
+  for (let col = size - 1; col > 0; col -= 2) {
+    if (col === 6) col -= 1
+    for (;;) {
+      for (let c = 0; c < 2; c += 1) {
+        const target = col - c
+        if (reserved[row][target]) continue
+        let dark = false
+        if (byteIndex < data.length + ecc.length) {
+          const block = byteIndex < data.length ? data : ecc
+          const offset = byteIndex < data.length ? byteIndex : byteIndex - data.length
+          dark = ((block[offset] >>> bitIndex) & 1) === 1
+        }
+        if ((row + target) % 2 === 0) dark = !dark
+        modules[row][target] = dark
+        bitIndex -= 1
+        if (bitIndex === -1) { byteIndex += 1; bitIndex = 7 }
+      }
+      row += direction
+      if (row < 0 || row >= size) { row -= direction; direction = -direction; break }
+    }
+  }
+
+  return { version, size, modules, data, ecc, reserved }
+}
+
+/** Reed-Solomon syndromes of a full codeword block; all zero means valid. */
+export function syndromesOf(codewords, eccCount) {
+  const out = []
+  for (let i = 0; i < eccCount; i += 1) {
+    let value = 0
+    for (const byte of codewords) value = gfMul(value, EXP[i]) ^ byte
+    out.push(value)
+  }
+  return out
+}
+
+export { DATA_CODEWORDS, ECC_CODEWORDS, rsEncode }
+
+/** Render an invite string as a standalone SVG (no external service). */
+export function qrSvg(text, moduleSize = 4, margin = 4) {
+  const qr = encodeQr(text)
+  const dimension = (qr.size + margin * 2) * moduleSize
+  let path = ''
+  for (let row = 0; row < qr.size; row += 1) {
+    for (let col = 0; col < qr.size; col += 1) {
+      if (!qr.modules[row][col]) continue
+      const x = (col + margin) * moduleSize
+      const y = (row + margin) * moduleSize
+      path += `M${x} ${y}h${moduleSize}v${moduleSize}h-${moduleSize}z`
+    }
+  }
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${dimension}" height="${dimension}" `
+    + `viewBox="0 0 ${dimension} ${dimension}" shape-rendering="crispEdges">`
+    + `<rect width="${dimension}" height="${dimension}" fill="#fff"/>`
+    + `<path d="${path}" fill="#000"/></svg>`
+}

package/host/reachability.js

@@ -0,0 +1,252 @@
+import dgram from 'node:dgram'
+import http from 'node:http'
+import os from 'node:os'
+
+/**
+ * Relay reachability and address policy.
+ *
+ * A relay is only usable across NATs when it has a public address. This module
+ * tries, in order, to make this Host reachable and to prove it:
+ *   1. UPnP IGD port mapping, then the router's external address;
+ *   2. an HTTP public-address lookup (display only — no mapping);
+ *   3. a self-test that talks to the relay over its public URL.
+ *
+ * It never adds a third-party dependency: SSDP and SOAP are plain UDP/HTTP.
+ */
+
+const PRIVATE = [
+  /^10\./,
+  /^127\./,
+  /^169\.254\./,
+  /^172\.(1[6-9]|2\d|3[01])\./,
+  /^192\.168\./,
+  /^::1$/,
+  /^f[cd][0-9a-f]{2}:/i,
+]
+
+export function isPrivateHost(host) {
+  const value = String(host || '').replace(/^\[|\]$/g, '').toLowerCase()
+  if (!value) return false
+  if (value === 'localhost') return true
+  return PRIVATE.some((pattern) => pattern.test(value))
+}
+
+/**
+ * Relay addresses must be TLS unless they stay on this machine or a private
+ * network. A public plain-HTTP relay would expose the workspace key and every
+ * signed call in transit.
+ */
+export function checkRelayUrl(rawUrl, { allowInsecure = false } = {}) {
+  let url
+  try {
+    url = new URL(rawUrl)
+  } catch {
+    return { ok: false, error: 'bad-url', message: 'Relay URL must be absolute.' }
+  }
+  if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+    return { ok: false, error: 'bad-protocol', message: 'Relay URL must use http or https.' }
+  }
+  if (url.protocol === 'https:') return { ok: true, url }
+  if (isPrivateHost(url.hostname)) return { ok: true, url, insecure: true }
+  if (allowInsecure) return { ok: true, url, insecure: true, warning: 'Plain HTTP to a public relay: traffic is readable in transit.' }
+  return {
+    ok: false,
+    error: 'tls-required',
+    message: 'A public relay must use https. Enable allowInsecureRelay only for a network you trust.',
+  }
+}
+
+/** The address this machine would use to reach the internet. */
+export function primaryAddress() {
+  return new Promise((resolve) => {
+    const socket = dgram.createSocket('udp4')
+    let settled = false
+    const done = (value) => {
+      if (settled) return
+      settled = true
+      try { socket.close() } catch { /* ignore */ }
+      resolve(value)
+    }
+    socket.on('error', () => done(undefined))
+    try {
+      socket.connect(53, '8.8.8.8', () => {
+        const address = socket.address()
+        done(address?.address)
+      })
+    } catch {
+      done(undefined)
+    }
+    setTimeout(() => done(undefined), 1500).unref?.()
+  })
+}
+
+const SSDP_SEARCH = Buffer.from(
+  'M-SEARCH * HTTP/1.1\r\n'
+  + 'HOST: 239.255.255.250:1900\r\n'
+  + 'MAN: "ssdp:discover"\r\n'
+  + 'MX: 2\r\n'
+  + 'ST: urn:schemas-upnp-org:service:WANIPConnection:1\r\n\r\n',
+)
+
+/** Discover UPnP internet-gateway devices (SSDP). */
+export function discoverGateways({ timeoutMs = 2500 } = {}) {
+  return new Promise((resolve) => {
+    const socket = dgram.createSocket('udp4')
+    const locations = new Set()
+    socket.on('message', (message) => {
+      const location = /LOCATION:\s*(\S+)/i.exec(message.toString('utf8'))?.[1]
+      if (location) locations.add(location)
+    })
+    socket.on('error', () => { try { socket.close() } catch { /* ignore */ } resolve([]) })
+    socket.bind(() => {
+      try { socket.setBroadcast(true) } catch { /* ignore */ }
+      socket.send(SSDP_SEARCH, 0, SSDP_SEARCH.length, 1900, '239.255.255.250')
+    })
+    setTimeout(() => {
+      try { socket.close() } catch { /* ignore */ }
+      resolve([...locations])
+    }, timeoutMs).unref?.()
+  })
+}
+
+const fetchText = (url, options = {}, timeoutMs = 4000) => new Promise((resolve, reject) => {
+  const request = http.request(url, { ...options, timeout: timeoutMs }, (response) => {
+    let body = ''
+    response.on('data', (chunk) => { body += chunk })
+    response.on('end', () => resolve({ status: response.statusCode ?? 0, body }))
+  })
+  request.on('timeout', () => request.destroy(new Error('timeout')))
+  request.on('error', reject)
+  if (options.body) request.write(options.body)
+  request.end()
+})
+
+function soapRequest(controlUrl, service, action, args) {
+  const body = `<?xml version="1.0"?><s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"><s:Body><u:${action} xmlns:u="${service}">${args}</u:${action}></s:Body></s:Envelope>`
+  return fetchText(controlUrl, {
+    method: 'POST',
+    headers: {
+      'content-type': 'text/xml; charset="utf-8"',
+      soapaction: `"${service}#${action}"`,
+      'content-length': Buffer.byteLength(body),
+    },
+    body,
+  })
+}
+
+/**
+ * Ask the router to forward a TCP port to this machine and report its external
+ * address. Returns `{ available: false }` when there is no IGD to talk to.
+ */
+export async function mapUpnpPort({ port, internalIp, description = 'DSH remote control', leaseSeconds = 0 }) {
+  const locations = await discoverGateways()
+  if (locations.length === 0) {
+    return { available: false, error: 'no-igd', message: 'No UPnP internet gateway answered on this network.' }
+  }
+  for (const location of locations) {
+    try {
+      const description0 = await fetchText(location)
+      const service = /urn:schemas-upnp-org:service:(WANIPConnection|WANPPPConnection):\d/.exec(description0.body)?.[1]
+      const controlPath = /<controlURL>([^<]+)<\/controlURL>/i.exec(description0.body)?.[1]
+      if (!service || !controlPath) continue
+      const serviceType = `urn:schemas-upnp-org:service:${service}:1`
+      const controlUrl = new URL(controlPath, location).toString()
+      const address = await soapRequest(controlUrl, serviceType, 'AddPortMapping', [
+        '<NewRemoteHost></NewRemoteHost>',
+        `<NewExternalPort>${port}</NewExternalPort>`,
+        '<NewProtocol>TCP</NewProtocol>',
+        `<NewInternalPort>${port}</NewInternalPort>`,
+        `<NewInternalClient>${internalIp}</NewInternalClient>`,
+        '<NewEnabled>1</NewEnabled>',
+        `<NewPortMappingDescription>${description}</NewPortMappingDescription>`,
+        `<NewLeaseDuration>${leaseSeconds}</NewLeaseDuration>`,
+      ].join(''))
+      if (address.status !== 200) continue
+      const ip = await soapRequest(controlUrl, serviceType, 'GetExternalIPAddress', '')
+      const externalIp = /<NewExternalIPAddress>([^<]+)<\/NewExternalIPAddress>/.exec(ip.body)?.[1]
+      return {
+        available: true,
+        mapped: true,
+        controlUrl,
+        serviceType,
+        externalIp: externalIp && externalIp !== '0.0.0.0' ? externalIp : undefined,
+      }
+    } catch { /* try the next gateway */ }
+  }
+  return { available: true, mapped: false, error: 'map-failed', message: 'The gateway refused the port mapping.' }
+}
+
+export async function removeUpnpMapping({ controlUrl, serviceType, port }) {
+  try {
+    await soapRequest(controlUrl, serviceType, 'DeletePortMapping', [
+      '<NewRemoteHost></NewRemoteHost>',
+      `<NewExternalPort>${port}</NewExternalPort>`,
+      '<NewProtocol>TCP</NewProtocol>',
+    ].join(''))
+  } catch { /* best effort */ }
+}
+
+/** Public address via an HTTP echo service; display only, no mapping. */
+export async function publicAddressViaHttp() {
+  try {
+    const response = await fetchText('http://api.ipify.org', {}, 3000)
+    const value = response.body.trim()
+    return /^\d{1,3}(\.\d{1,3}){3}$/.test(value) ? value : undefined
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Prove a relay is reachable at `url`: POST /v1/register with no group.
+ * A reachable relay answers 400 (bad-group); anything else means we cannot
+ * talk to it from outside.
+ */
+export async function relaySelfTest(url, timeoutMs = 4000) {
+  try {
+    const response = await fetchText(`${String(url).replace(/\/+$/, '')}/v1/register`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json', 'content-length': 2 },
+      body: '{}',
+    }, timeoutMs)
+    return { ok: response.status === 400, status: response.status }
+  } catch (error) {
+    return { ok: false, error: error?.message || String(error) }
+  }
+}
+
+/**
+ * Full reachability attempt for a relay hosted on `port`.
+ * Returns the public URL only when the relay actually answers through it.
+ */
+export async function ensureReachable({ port, allowInsecure = false } = {}) {
+  const internalIp = await primaryAddress()
+  const upnp = await mapUpnpPort({ port, internalIp: internalIp ?? '0.0.0.0' })
+  const publicIp = upnp.externalIp ?? (await publicAddressViaHttp())
+
+  const candidates = []
+  if (publicIp) candidates.push(`http://${publicIp}:${port}`)
+
+  let selfTest = { ok: false, error: 'no-public-address' }
+  let reachableUrl
+  for (const candidate of candidates) {
+    const verdict = await relaySelfTest(candidate)
+    selfTest = verdict
+    if (verdict.ok) { reachableUrl = candidate; break }
+  }
+
+  const secure = reachableUrl ? checkRelayUrl(reachableUrl, { allowInsecure }) : { ok: false }
+
+  return {
+    ok: Boolean(reachableUrl && secure.ok),
+    url: reachableUrl ?? null,
+    secure: Boolean(secure.ok),
+    publicIp: publicIp ?? null,
+    internalIp: internalIp ?? null,
+    upnp,
+    selfTest,
+    hint: upnp.available
+      ? (upnp.mapped ? undefined : upnp.message)
+      : 'No UPnP gateway on this network; the relay cannot be published from here. Use a public relay or a tunnel.',
+  }
+}

package/host/relay-core.js

@@ -12,7 +12,7 @@ import { randomBytes } from 'node:crypto'
  * relay never sees the workspace key. Peer control stays end-to-end signed by
  * the devices themselves; this process only routes.
  */
-export function createRelay({ log = console } = {}) {
+export function createRelay({ log = console, onMessage } = {}) {
   const devices = new Map() // deviceId -> record
   const tokens = new Map() // token -> deviceId
 
@@ -93,6 +93,7 @@ export function createRelay({ log = console } = {}) {
       return send(res, 413, { error: 'too-large' })
     }
     if (to.queue.length >= MAX_QUEUE) to.queue.shift()
+    onMessage?.({ from: from.deviceId, to: to.deviceId, message })
     to.queue.push({ from: from.deviceId, message, at: Date.now() })
     wake(to)
     return send(res, 200, { ok: true })

package/host/relay-link.js

@@ -26,6 +26,7 @@ export function createRelayLink({ url, key, deviceId, deviceName, userId, localP
   let stopped = false
   let heartbeatTimer
   let sequence = 0
+  let security
 
   async function start() {
     await register()
@@ -118,11 +119,26 @@ export function createRelayLink({ url, key, deviceId, deviceName, userId, localP
   }
 
   async function dispatch(from, message) {
+    const encryptedInbound = Boolean(message && typeof message === 'object' && typeof message.enc === 'string')
+    if (encryptedInbound) {
+      // Sealed envelope from a peer that has pinned our keys.
+      const opened = security?.open?.(from, message.enc)
+      if (typeof opened !== 'string') return
+      try { message = JSON.parse(opened) } catch { return }
+    }
     if (!message || typeof message !== 'object') return
     switch (message.kind) {
       case 'http': {
         const result = await localRequest(message.method, message.path, message.headers, message.body)
-        await send(from, { kind: 'http-response', id: message.id, status: result.status, body: result.body })
+        await send(from, {
+          kind: 'http-response',
+          id: message.id,
+          status: result.status,
+          body: result.body,
+          // Answer in kind: a plaintext request predates the peer knowing our
+          // key (the approval response itself), so its reply must stay plain.
+          plain: !encryptedInbound,
+        })
         return
       }
       case 'http-response': {
@@ -133,7 +149,7 @@ export function createRelayLink({ url, key, deviceId, deviceName, userId, localP
         return
       }
       case 'stream-open':
-        openLocalStream(from, message)
+        openLocalStream(from, message, encryptedInbound)
         return
       case 'stream-status': {
         const entry = streams.get(message.id)
@@ -170,7 +186,7 @@ export function createRelayLink({ url, key, deviceId, deviceName, userId, localP
         port: localPort,
         path: pathname,
         method,
-        headers: { ...headers, host: `127.0.0.1:${localPort}` },
+        headers: { ...headers, host: `127.0.0.1:${localPort}`, 'x-dsh-via': 'relay' },
       }, (response) => {
         let data = ''
         response.on('data', (chunk) => { data += chunk })
@@ -185,7 +201,7 @@ export function createRelayLink({ url, key, deviceId, deviceName, userId, localP
     })
   }
 
-  function openLocalStream(from, message) {
+  function openLocalStream(from, message, encryptedInbound) {
     const id = message.id
     const request = http.request({
       host: '127.0.0.1',
@@ -200,23 +216,23 @@ export function createRelayLink({ url, key, deviceId, deviceName, userId, localP
       const push = (message) => {
         chain = chain.then(() => send(from, message)).catch(() => {})
       }
-      push({ kind: 'stream-status', id, status: response.statusCode ?? 502 })
+      push({ kind: 'stream-status', id, status: response.statusCode ?? 502, plain: !encryptedInbound })
       if ((response.statusCode ?? 500) >= 400) {
         response.resume()
         locals.delete(id)
-        push({ kind: 'stream-end', id })
+        push({ kind: 'stream-end', id, plain: !encryptedInbound })
         return
       }
       response.on('data', (chunk) => {
-        push({ kind: 'stream-chunk', id, chunk: chunk.toString('utf8') })
+        push({ kind: 'stream-chunk', id, chunk: chunk.toString('utf8'), plain: !encryptedInbound })
       })
       response.on('end', () => {
         locals.delete(id)
-        push({ kind: 'stream-end', id })
+        push({ kind: 'stream-end', id, plain: !encryptedInbound })
       })
       response.on('error', () => {
         locals.delete(id)
-        push({ kind: 'stream-end', id })
+        push({ kind: 'stream-end', id, plain: !encryptedInbound })
       })
     })
     request.on('error', () => {
@@ -229,10 +245,16 @@ export function createRelayLink({ url, key, deviceId, deviceName, userId, localP
 
   async function send(to, message) {
     if (!token) throw new Error('relay not registered')
+    const { plain, ...rest } = message ?? {}
+    let payload = rest
+    if (security && !plain) {
+      const sealed = security.seal?.(to, JSON.stringify(rest))
+      if (typeof sealed === 'string') payload = { enc: sealed }
+    }
     const response = await fetch(`${base}/v1/send`, {
       method: 'POST',
       headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ token, to, message }),
+      body: JSON.stringify({ token, to, message: payload }),
     })
     if (response.status === 401) { token = undefined; throw new Error('relay unauthorized') }
     if (!response.ok) throw new Error(`relay send failed: ${response.status}`)
@@ -330,6 +352,7 @@ export function createRelayLink({ url, key, deviceId, deviceName, userId, localP
     stop,
     request,
     stream,
+    setSecurity(next) { security = next },
     peers: () => [...peers.values()],
     url: () => base,
     connected: () => Boolean(token),