@cero-base/core 1.2.0 → 1.4.0

package/src/network/bluetooth.js

@@ -1,324 +0,0 @@
-import ReadyResource from 'ready-resource'
-import b4a from 'b4a'
-import { hash } from 'hypercore-crypto'
-import safetyCatch from 'safety-catch'
-
-// Readable characteristic carrying "<psm>:<nodeId-hex>" — the L2CAP PSM to
-// connect on plus the advertiser's stable id for the initiate tie-break. Read
-// over GATT after connecting (bare-mobile-doctor reads the PSM the same way);
-// advertisement service-data is not a portable channel for this.
-const PSM_UUID = 'ce1a0003-0000-1000-8000-00805f9b34fb'
-const DEFAULT_CAP = 4
-const CONNECT_TIMEOUT = 15000
-
-/**
- * Derive a stable 128-bit BLE service UUID from a topic. Only devices that
- * compute the same UUID (same channel / same invite) ever discover each other.
- *
- * @param {Uint8Array} topic
- * @param {string} [tag]  Namespace so channel and invite meshes never collide.
- * @returns {string}
- */
-export function toServiceUUID(topic, tag = 'cero-ble') {
-  const h = hash([b4a.from(tag), topic])
-  const hex = b4a.toString(h.subarray(0, 16), 'hex')
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`
-}
-
-// Backend adapter state → the app-facing state the facade exposes.
-const STATE = {
-  poweredOn: 'on',
-  poweredOff: 'waiting',
-  unauthorized: 'unauthorized',
-  unsupported: 'unsupported',
-  resetting: 'waiting',
-  unknown: 'waiting'
-}
-
-const uuidEq = (a, b) =>
-  String(a || '')
-    .toLowerCase()
-    .replace(/-/g, '') ===
-  String(b || '')
-    .toLowerCase()
-    .replace(/-/g, '')
-
-const findByUUID = (items, uuid) => (items || []).find((i) => uuidEq(i.uuid, uuid)) || null
-
-/**
- * Dual-role BLE transport: advertises + scans one service UUID, opens an L2CAP
- * channel to each discovered peer, and feeds it into `network.inject`. From
- * there replication and pairing are transport-agnostic (see Network.inject).
- *
- * Choreography mirrors the proven bare-mobile-doctor worklet: server adds a
- * readable PSM characteristic at startup and answers reads dynamically; the
- * central connects, reads "<psm>:<nodeId>", tie-breaks, then opens the channel.
- * `backend` is bare-bluetooth in production and a mock in tests.
- *
- * ponytail: capability-handshake DoS link-scoring is deferred — it needs a
- * replication-progress signal (design §4b). v1 caps links + times out dials.
- *
- * @extends ReadyResource
- */
-export class BluetoothTransport extends ReadyResource {
-  /**
-   * @param {object} opts
-   * @param {any} opts.backend            bare-bluetooth-shaped module (Central, Server, Service, Characteristic).
-   * @param {import('./index.js').Network} opts.network
-   * @param {Uint8Array} opts.uuid        The 32-byte topic the service UUID derives from.
-   * @param {Uint8Array} opts.nodeId      Stable local id (identity/device key) for the initiate tie-break.
-   * @param {string} [opts.tag]           UUID namespace (channel mesh vs invite mesh).
-   * @param {number} [opts.cap]           Max concurrent links; gossip covers the rest.
-   * @param {{ scanMode?: any }} [opts.scanOptions]  Platform scan options (e.g. Android low-power).
-   * @param {boolean} [opts.keepLinks]    On close, stop the radio but leave established links alive (invite rendezvous: the link outlives the QR and carries the initial replication).
-   */
-  constructor({
-    backend,
-    network,
-    uuid,
-    nodeId,
-    tag = 'cero-ble',
-    cap = DEFAULT_CAP,
-    scanOptions,
-    keepLinks = false
-  }) {
-    super()
-    this.backend = backend
-    this.network = network
-    this.nodeId = nodeId
-    this.nodeHex = b4a.toString(nodeId, 'hex')
-    this.serviceUUID = toServiceUUID(uuid, tag)
-    this.cap = cap
-    this.scanOptions = scanOptions
-    this.keepLinks = keepLinks
-
-    this.state = 'off'
-    this.central = null
-    this.server = null
-    this.psm = null
-    this._scanning = false
-    this._advertising = false
-    this._serviceAdded = false
-    /** peripheral id being dialed → its connect-timeout timer */
-    this._dialing = new Map()
-    /** live injected links keyed by remote node id hex */
-    this.peers = new Map()
-  }
-
-  /**
-   * Whether we should be the one to open the connection to `peerNodeId`. The
-   * lexicographically smaller id initiates; the larger waits — so a pair
-   * connects once, not twice. Equal (our own reflection) → false.
-   *
-   * @param {Uint8Array} peerNodeId
-   * @returns {boolean}
-   */
-  shouldInitiate(peerNodeId) {
-    return b4a.compare(this.nodeId, peerNodeId) < 0
-  }
-
-  get linkCount() {
-    return this.peers.size
-  }
-
-  async _open() {
-    const { Central, Server, Service, Characteristic } = this.backend
-
-    this.server = new Server()
-    this.server.on('stateChange', (s) => {
-      this._onState(s)
-      if (s === 'poweredOn') this._startServer(Service, Characteristic)
-    })
-    this.server.on('serviceAdd', () => {
-      this._serviceAdded = true
-      this._maybeAdvertise()
-    })
-    this.server.on('channelPublish', (psm) => {
-      this.psm = psm
-      this._maybeAdvertise()
-    })
-    // A central reads this to learn the PSM (+ our id) before opening the
-    // channel. Answer dynamically: the PSM isn't known when the service is added.
-    this.server.on('readRequest', (req) => {
-      const ok = this.server.constructor.ATT_SUCCESS ?? 0
-      const val = this.psm == null ? b4a.alloc(0) : b4a.from(`${this.psm}:${this.nodeHex}`)
-      this.server.respondToRequest(req, ok, val)
-    })
-    this.server.on('channelOpen', (l2cap) => this._onChannel(l2cap, false, null))
-    this.server.on('error', safetyCatch)
-
-    this.central = new Central()
-    this.central.on('stateChange', (s) => {
-      this._onState(s)
-      if (s === 'poweredOn') this._startScan()
-    })
-    this.central.on('discover', (peripheral) => this._onDiscover(peripheral))
-    this.central.on('connect', (peripheral) => this._onConnect(peripheral))
-    this.central.on('disconnect', () => {})
-    this.central.on('error', (err) => this._onCentralError(err))
-
-    this._startServer(Service, Characteristic)
-    this._startScan()
-    this.state = 'starting'
-  }
-
-  _startServer(Service, Characteristic) {
-    if (this.server.state !== 'poweredOn') return // wait for the adapter (stateChange)
-    if (!this._serviceAdded) {
-      const char = new Characteristic(PSM_UUID, { read: true })
-      this.server.addService(new Service(this.serviceUUID, [char]))
-    }
-    if (this.psm == null) this.server.publishChannel({})
-  }
-
-  _maybeAdvertise() {
-    if (this._advertising || !this._serviceAdded || this.psm == null) return
-    this._advertising = true
-    this.server.startAdvertising({ serviceUUIDs: [this.serviceUUID] })
-  }
-
-  _startScan() {
-    if (this._scanning || this.central.state !== 'poweredOn') return
-    this._scanning = true
-    this.central.startScan([this.serviceUUID], this.scanOptions)
-  }
-
-  _onState(raw) {
-    const next = STATE[raw] ?? 'waiting'
-    if (next === this.state) return
-    this.state = next
-    this.emit('update')
-  }
-
-  _onDiscover(peripheral) {
-    if (this.closing || this.closed) return
-    if (this._dialing.has(peripheral.id)) return // already connecting to this one
-    if (this.linkCount >= this.cap) return // gossip covers the rest
-    // tie-break is decided post-read (we can't trust advertisement payloads);
-    // dial now, learn the peer id from the PSM characteristic, decide there.
-    const timer = setTimeout(() => this._abortDial(peripheral, 'timeout'), CONNECT_TIMEOUT)
-    this._dialing.set(peripheral.id, timer)
-    try {
-      this.central.connect(peripheral)
-    } catch (err) {
-      this._abortDial(peripheral, err)
-    }
-  }
-
-  _onConnect(peripheral) {
-    peripheral.on('error', () => this._abortDial(peripheral, 'peripheral-error'))
-    peripheral.once('servicesDiscover', (services) => {
-      const svc = findByUUID(services, this.serviceUUID)
-      if (svc) peripheral.discoverCharacteristics(svc, [PSM_UUID])
-      else this._abortDial(peripheral, 'no-service')
-    })
-    peripheral.once('characteristicsDiscover', (_svc, chars) => {
-      const psmChar = findByUUID(chars, PSM_UUID)
-      if (psmChar) peripheral.read(psmChar)
-      else this._abortDial(peripheral, 'no-psm-char')
-    })
-    peripheral.once('read', (_char, data) => {
-      const [psmStr, peerHex] = b4a.toString(data).split(':')
-      const psm = Number(psmStr)
-      const peerId = peerHex ? b4a.from(peerHex, 'hex') : null
-      // the smaller id opens the channel; the larger disconnects and waits for
-      // the peer to dial back — a pair links once, not twice
-      if (!psm || !peerId || !this.shouldInitiate(peerId)) {
-        this._abortDial(peripheral, 'yield')
-        return
-      }
-      peripheral.once('channelOpen', (l2cap) => {
-        this._clearDial(peripheral.id)
-        this._onChannel(l2cap, true, peripheral.id)
-      })
-      peripheral.openL2CAPChannel(psm)
-    })
-    peripheral.discoverServices([this.serviceUUID])
-  }
-
-  _abortDial(peripheral, _reason) {
-    const id = peripheral?.id
-    this._clearDial(id)
-    try {
-      this.central.disconnect(peripheral)
-    } catch (err) {
-      safetyCatch(err)
-    }
-  }
-
-  _clearDial(id) {
-    if (id == null) return
-    const timer = this._dialing.get(id)
-    if (timer) clearTimeout(timer)
-    this._dialing.delete(id) // free the slot — rediscovery can re-dial
-  }
-
-  // iOS & Android report errored connects as 'error' with a code, not
-  // 'disconnect' — without this a failed dial pins the peripheral forever.
-  _onCentralError(err) {
-    safetyCatch(err)
-    const code = err && err.code
-    if (code === 'CONNECTION_FAILED' || code === 'DISCONNECT') {
-      for (const id of [...this._dialing.keys()]) this._clearDial(id)
-    }
-  }
-
-  _onChannel(l2cap, isInitiator, peripheralId) {
-    if (this.closing || this.closed) {
-      l2cap.destroy()
-      return
-    }
-    const conn = this.network.inject(l2cap, { isInitiator })
-    conn.on('open', () => this._track(conn, peripheralId))
-    conn.on('close', () => this._untrack(conn, peripheralId))
-  }
-
-  _track(conn, peripheralId) {
-    if (this.closing || this.closed) return
-    const key = b4a.toString(conn.remotePublicKey, 'hex')
-    const existing = this.peers.get(key)
-    if (existing && existing !== conn) {
-      conn.destroy() // duplicate link to the same peer — keep the first
-      return
-    }
-    conn._peripheralId = peripheralId
-    conn._peerKey = key
-    this.peers.set(key, conn)
-    this.emit('update')
-  }
-
-  _untrack(conn) {
-    const key = conn._peerKey
-    if (key && this.peers.get(key) === conn) this.peers.delete(key)
-    if (!this.closing && !this.closed) this.emit('update')
-  }
-
-  async _close() {
-    // doctor-app rule: never call central/server.destroy() — it double-frees in
-    // the native teardown; stop advertising/scanning and let the runtime reclaim.
-    for (const timer of this._dialing.values()) clearTimeout(timer)
-    this._dialing.clear()
-    try {
-      this.central?.stopScan()
-    } catch (err) {
-      safetyCatch(err)
-    }
-    try {
-      this.server?.stopAdvertising()
-    } catch (err) {
-      safetyCatch(err)
-    }
-    if (!this.keepLinks) {
-      // channel mesh: toggling nearby off means stop syncing nearby
-      for (const conn of this.peers.values()) {
-        try {
-          conn.destroy()
-        } catch (err) {
-          safetyCatch(err)
-        }
-      }
-    }
-    this.peers.clear()
-    this.state = 'off'
-  }
-}