@stoprocent/noble 2.5.0 → 2.5.2

package/lib/dbus/bindings.js

@@ -49,6 +49,13 @@ function loadDbus () {
   }
 }
 
+function normalizeId (id) {
+  // BlueZ emits MACs uppercase; noble's id form is colon-stripped lowercase.
+  // Accept either, plus mixed case, so external callers don't have to care.
+  if (id == null) return id;
+  return String(id).replace(/:/g, '').toLowerCase();
+}
+
 function unwrapVariant (variant) {
   if (variant && typeof variant === 'object' && 'value' in variant && 'signature' in variant) {
     return variant.value;
@@ -102,7 +109,8 @@ function buildAdvertisement (deviceProps) {
     const entries = Object.entries(deviceProps.ManufacturerData);
     if (entries.length > 0) {
       const buffers = [];
-      for (const [companyId, payload] of entries) {
+      for (const [companyId, rawPayload] of entries) {
+        const payload = unwrapVariant(rawPayload);
         const id = Number(companyId) & 0xffff;
         const header = Buffer.from([id & 0xff, (id >> 8) & 0xff]);
         const data = Buffer.isBuffer(payload) ? payload : Buffer.from(payload);
@@ -113,7 +121,8 @@ function buildAdvertisement (deviceProps) {
   }
 
   if (deviceProps.ServiceData && typeof deviceProps.ServiceData === 'object') {
-    for (const [uuid, payload] of Object.entries(deviceProps.ServiceData)) {
+    for (const [uuid, rawPayload] of Object.entries(deviceProps.ServiceData)) {
+      const payload = unwrapVariant(rawPayload);
       advertisement.serviceData.push({
         uuid: normalizeUuid(uuid),
         data: Buffer.isBuffer(payload) ? payload : Buffer.from(payload)
@@ -485,6 +494,7 @@ class DbusBindings extends EventEmitter {
   // ---- Connect / disconnect ----
 
   connect (peripheralUuid, _parameters) {
+    peripheralUuid = normalizeId(peripheralUuid);
     this._connect(peripheralUuid).catch(err => {
       this.emit('connect', peripheralUuid, err);
     });
@@ -518,10 +528,11 @@ class DbusBindings extends EventEmitter {
   }
 
   cancelConnect (peripheralUuid, _parameters) {
-    this.disconnect(peripheralUuid);
+    this.disconnect(normalizeId(peripheralUuid));
   }
 
   disconnect (peripheralUuid) {
+    peripheralUuid = normalizeId(peripheralUuid);
     this._disconnect(peripheralUuid).catch(err => {
       this.emit('warning', `disconnect failed: ${err.message}`);
     });
@@ -540,6 +551,7 @@ class DbusBindings extends EventEmitter {
   }
 
   updateRssi (peripheralUuid) {
+    peripheralUuid = normalizeId(peripheralUuid);
     const device = this._devices.get(peripheralUuid);
     if (!device || !device.path) {
       this.emit('rssiUpdate', peripheralUuid, 0, new Error('unknown peripheral'));
@@ -596,6 +608,7 @@ class DbusBindings extends EventEmitter {
   }
 
   discoverServices (peripheralUuid, uuids) {
+    peripheralUuid = normalizeId(peripheralUuid);
     const wanted = (uuids || []).map(normalizeUuid);
     const found = this._findServicesForDevice(peripheralUuid);
     const filtered = wanted.length === 0 ? found : found.filter(s => wanted.includes(s.uuid));
@@ -605,11 +618,13 @@ class DbusBindings extends EventEmitter {
   }
 
   discoverIncludedServices (peripheralUuid, serviceUuid, _serviceUuids) {
+    peripheralUuid = normalizeId(peripheralUuid);
     // BlueZ does not expose included services directly via D-Bus.
     this.emit('includedServicesDiscover', peripheralUuid, serviceUuid, []);
   }
 
   discoverCharacteristics (peripheralUuid, serviceUuid, characteristicUuids) {
+    peripheralUuid = normalizeId(peripheralUuid);
     const services = this._findServicesForDevice(peripheralUuid);
     const service = services.find(s => s.uuid === normalizeUuid(serviceUuid));
     if (!service) {
@@ -642,6 +657,7 @@ class DbusBindings extends EventEmitter {
   }
 
   read (peripheralUuid, serviceUuid, characteristicUuid) {
+    peripheralUuid = normalizeId(peripheralUuid);
     this._readChar(peripheralUuid, serviceUuid, characteristicUuid).catch(err => {
       this.emit('read', peripheralUuid, serviceUuid, characteristicUuid, null, false, err);
     });
@@ -658,6 +674,7 @@ class DbusBindings extends EventEmitter {
   }
 
   write (peripheralUuid, serviceUuid, characteristicUuid, data, withoutResponse) {
+    peripheralUuid = normalizeId(peripheralUuid);
     this._writeChar(peripheralUuid, serviceUuid, characteristicUuid, data, withoutResponse).catch(err => {
       this.emit('write', peripheralUuid, serviceUuid, characteristicUuid, err);
     });
@@ -676,11 +693,13 @@ class DbusBindings extends EventEmitter {
   }
 
   broadcast (peripheralUuid, serviceUuid, characteristicUuid, _broadcast) {
+    peripheralUuid = normalizeId(peripheralUuid);
     this.emit('warning', 'broadcast is not supported on the dbus backend');
     this.emit('broadcast', peripheralUuid, serviceUuid, characteristicUuid, false);
   }
 
   notify (peripheralUuid, serviceUuid, characteristicUuid, notify) {
+    peripheralUuid = normalizeId(peripheralUuid);
     this._setNotify(peripheralUuid, serviceUuid, characteristicUuid, notify).catch(err => {
       this.emit('notify', peripheralUuid, serviceUuid, characteristicUuid, false, err);
     });
@@ -724,6 +743,7 @@ class DbusBindings extends EventEmitter {
   }
 
   discoverDescriptors (peripheralUuid, serviceUuid, characteristicUuid) {
+    peripheralUuid = normalizeId(peripheralUuid);
     const charPath = this._findCharacteristicPath(peripheralUuid, serviceUuid, characteristicUuid);
     if (!charPath) {
       this.emit('descriptorsDiscover', peripheralUuid, serviceUuid, characteristicUuid, [], new Error('characteristic not found'));
@@ -734,6 +754,7 @@ class DbusBindings extends EventEmitter {
   }
 
   readValue (peripheralUuid, serviceUuid, characteristicUuid, descriptorUuid) {
+    peripheralUuid = normalizeId(peripheralUuid);
     this._readDesc(peripheralUuid, serviceUuid, characteristicUuid, descriptorUuid).catch(err => {
       this.emit('valueRead', peripheralUuid, serviceUuid, characteristicUuid, descriptorUuid, null, err);
     });
@@ -750,6 +771,7 @@ class DbusBindings extends EventEmitter {
   }
 
   writeValue (peripheralUuid, serviceUuid, characteristicUuid, descriptorUuid, data) {
+    peripheralUuid = normalizeId(peripheralUuid);
     this._writeDesc(peripheralUuid, serviceUuid, characteristicUuid, descriptorUuid, data).catch(err => {
       this.emit('valueWrite', peripheralUuid, serviceUuid, characteristicUuid, descriptorUuid, err);
     });
@@ -766,11 +788,13 @@ class DbusBindings extends EventEmitter {
   }
 
   readHandle (peripheralUuid, handle) {
+    peripheralUuid = normalizeId(peripheralUuid);
     const err = new Error('readHandle is not supported on the dbus backend (BlueZ exposes UUIDs only)');
     this.emit('handleRead', peripheralUuid, handle, null, err);
   }
 
   writeHandle (peripheralUuid, handle, _data, _withoutResponse) {
+    peripheralUuid = normalizeId(peripheralUuid);
     const err = new Error('writeHandle is not supported on the dbus backend (BlueZ exposes UUIDs only)');
     this.emit('handleWrite', peripheralUuid, handle, err);
   }

package/package.json

@@ -6,7 +6,7 @@
   "license": "MIT",
   "name": "@stoprocent/noble",
   "description": "A Node.js BLE (Bluetooth Low Energy) central library.",
-  "version": "2.5.0",
+  "version": "2.5.2",
   "repository": {
     "type": "git",
     "url": "https://github.com/stoprocent/noble.git"
@@ -36,6 +36,14 @@
   "optionalDependencies": {
     "@stoprocent/bluetooth-hci-socket": "^2.2.6"
   },
+  "peerDependencies": {
+    "dbus-next": "^0.10.0"
+  },
+  "peerDependenciesMeta": {
+    "dbus-next": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@babel/eslint-parser": "^7.27.0",
     "@commitlint/cli": "^19.3.0",

package/test/lib/dbus/bindings.test.js

@@ -270,6 +270,44 @@ describe('dbus/bindings', () => {
     expect(advertisement.serviceUuids).toEqual(['180d']);
   });
 
+  test('InterfacesAdded unwraps Variant-wrapped ManufacturerData and ServiceData payloads', async () => {
+    const bindings = new DbusBindings();
+    const discoveries = [];
+    bindings.on('discover', (...args) => discoveries.push(args));
+
+    bindings.start();
+    await flush();
+
+    // BlueZ exposes ManufacturerData as a{qv} and ServiceData as a{sv}; dbus-next
+    // surfaces each inner value as a Variant, not the raw bytes.
+    const mfgPayload = Buffer.from([0xde, 0xad, 0xbe, 0xef]);
+    const svcPayload = Buffer.from([0x01, 0x02, 0x03]);
+
+    const om = state.rootProxy.getInterface('org.freedesktop.DBus.ObjectManager');
+    om.emit('InterfacesAdded', '/org/bluez/hci0/dev_AA_BB_CC_DD_EE_FF', {
+      'org.bluez.Device1': wrapDict({
+        Address: 'AA:BB:CC:DD:EE:FF',
+        AddressType: 'public',
+        ManufacturerData: { 0x004c: v('ay', mfgPayload) },
+        ServiceData: { '0000180d-0000-1000-8000-00805f9b34fb': v('ay', svcPayload) }
+      })
+    });
+    await flush();
+
+    expect(discoveries.length).toBe(1);
+    const advertisement = discoveries[0][4];
+
+    // Manufacturer: 2-byte little-endian company id (0x004c => Apple) + payload
+    expect(Buffer.isBuffer(advertisement.manufacturerData)).toBe(true);
+    expect(advertisement.manufacturerData.equals(
+      Buffer.concat([Buffer.from([0x4c, 0x00]), mfgPayload])
+    )).toBe(true);
+
+    expect(advertisement.serviceData).toEqual([
+      { uuid: '180d', data: svcPayload }
+    ]);
+  });
+
   test('discoverServices/Characteristics/Descriptors walk the cached object tree', async () => {
     const tree = adapterTree({
       '/org/bluez/hci0/dev_AA_BB_CC_DD_EE_FF': {
@@ -409,4 +447,75 @@ describe('dbus/bindings', () => {
     const bindings = new DbusBindings();
     expect(bindings.addressToId('AA:BB:CC:DD:EE:FF')).toBe('aabbccddeeff');
   });
+
+  describe('peripheral id normalization on public methods', () => {
+    const tree = () => adapterTree({
+      '/org/bluez/hci0/dev_AA_BB_CC_DD_EE_FF': {
+        'org.bluez.Device1': { Address: 'AA:BB:CC:DD:EE:FF', AddressType: 'public', Connected: false }
+      },
+      '/org/bluez/hci0/dev_AA_BB_CC_DD_EE_FF/service0001': {
+        'org.bluez.GattService1': { UUID: '0000180d-0000-1000-8000-00805f9b34fb', Primary: true }
+      },
+      '/org/bluez/hci0/dev_AA_BB_CC_DD_EE_FF/service0001/char0002': {
+        'org.bluez.GattCharacteristic1': {
+          UUID: '00002a37-0000-1000-8000-00805f9b34fb',
+          Flags: ['read', 'notify']
+        }
+      }
+    });
+
+    const variants = [
+      ['canonical id', 'aabbccddeeff'],
+      ['uppercase id', 'AABBCCDDEEFF'],
+      ['mixed-case id', 'AaBbCcDdEeFf'],
+      ['colon MAC uppercase', 'AA:BB:CC:DD:EE:FF'],
+      ['colon MAC lowercase', 'aa:bb:cc:dd:ee:ff'],
+      ['colon MAC mixed', 'Aa:Bb:Cc:Dd:Ee:Ff']
+    ];
+
+    test.each(variants)('discoverServices accepts %s and emits canonical id', async (_label, input) => {
+      resetState(tree());
+      const bindings = new DbusBindings();
+      bindings.start();
+      await flush();
+
+      const services = [];
+      bindings.on('servicesDiscover', (...a) => services.push(a));
+
+      bindings.discoverServices(input, []);
+
+      expect(services[0]).toEqual(['aabbccddeeff', ['180d']]);
+    });
+
+    test.each(variants)('read accepts %s and emits canonical id', async (_label, input) => {
+      resetState(tree());
+      const bindings = new DbusBindings();
+      bindings.start();
+      await flush();
+
+      const reads = [];
+      bindings.on('read', (...a) => reads.push(a));
+
+      bindings.read(input, '180d', '2a37');
+      await flush();
+
+      expect(reads.length).toBe(1);
+      expect(reads[0][0]).toBe('aabbccddeeff');
+    });
+
+    test.each(variants)('readHandle (unsupported) emits canonical id for %s', (_label, input) => {
+      resetState(tree());
+      const bindings = new DbusBindings();
+      const events = [];
+      bindings.on('handleRead', (...a) => events.push(a));
+      bindings.readHandle(input, 0x42);
+      expect(events[0][0]).toBe('aabbccddeeff');
+    });
+
+    test('null/undefined peripheralUuid does not throw', () => {
+      const bindings = new DbusBindings();
+      expect(() => bindings.discoverServices(undefined, [])).not.toThrow();
+      expect(() => bindings.discoverServices(null, [])).not.toThrow();
+    });
+  });
 });