@onekeyfe/hd-transport-electron 1.2.8-alpha.9 → 1.2.8

package/dist/{index-21e34fdb.js → index-e2e3d2ba.js}

@@ -55,13 +55,13 @@ function invokeNobleBleIpc(request) {
 
 function initNobleBleSupport(webContents) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { setupNobleBleHandlers } = yield Promise.resolve().then(function () { return require('./noble-ble-handler-c4530a1b.js'); });
+        const { setupNobleBleHandlers } = yield Promise.resolve().then(function () { return require('./noble-ble-handler-d0991fa0.js'); });
         setupNobleBleHandlers(webContents);
     });
 }
 function disposeNobleBleSupport(releaseNoble) {
     return __awaiter(this, void 0, void 0, function* () {
-        const handler = yield Promise.resolve().then(function () { return require('./noble-ble-handler-c4530a1b.js'); });
+        const handler = yield Promise.resolve().then(function () { return require('./noble-ble-handler-d0991fa0.js'); });
         yield handler.disposeNobleBleSupport(releaseNoble);
     });
 }

package/dist/index.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var index = require('./index-21e34fdb.js');
+var index = require('./index-e2e3d2ba.js');
 
 
 

package/dist/{noble-ble-handler-c4530a1b.js → noble-ble-handler-d0991fa0.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./index-21e34fdb.js');
+var index = require('./index-e2e3d2ba.js');
 var hdShared = require('@onekeyfe/hd-shared');
 var pRetry = require('p-retry');
 
@@ -123,6 +123,13 @@ function assertBleActive() {
 }
 function createNobleBleConnectionError(error, messagePrefix = '') {
     const errorMessage = error.message;
+    const isInvalidMacOsBond = error.nativeErrorCode === 14 && error.nativeErrorDomain === 'CBErrorDomain';
+    if (isInvalidMacOsBond) {
+        const nativeErrorMessage = `${messagePrefix}${errorMessage}`;
+        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleBondInvalid, `${hdShared.HardwareErrorCodeMessage[hdShared.HardwareErrorCode.BleBondInvalid]} (${nativeErrorMessage})`, {
+            nativeErrorMessage,
+        });
+    }
     return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, `${messagePrefix}${errorMessage}`);
 }
 function createNobleBleIpcErrorResponse(error) {
@@ -376,18 +383,8 @@ function updateBluetoothState(state) {
 function initializeNoble() {
     return index.__awaiter(this, void 0, void 0, function* () {
         assertBleActive();
-        if (noble) {
-            if (noble.state === 'poweredOff') {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlePoweredOff);
-            }
-            if (noble.state === 'unsupported') {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleUnsupported);
-            }
-            if (noble.state === 'unauthorized') {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleLocationError);
-            }
+        if (noble)
             return;
-        }
         try {
             noble = require('@stoprocent/noble');
             logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Noble library loaded');
@@ -428,7 +425,7 @@ function initializeNoble() {
                     }
                     else if (state === 'unauthorized') {
                         cleanup();
-                        reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleLocationError));
+                        reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlePermissionError));
                     }
                 };
                 const cancel = () => {
@@ -437,7 +434,6 @@ function initializeNoble() {
                 };
                 pendingCancellations.add(cancel);
                 noble.on('stateChange', onStateChange);
-                onStateChange(noble.state);
             });
             assertBleActive();
             if (!persistentDiscoverListener) {
@@ -450,7 +446,7 @@ function initializeNoble() {
         }
         catch (error) {
             logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Failed to initialize Noble:', error);
-            bluetoothState.unsupported = (noble === null || noble === void 0 ? void 0 : noble.state) === 'unsupported';
+            bluetoothState.unsupported = true;
             bluetoothState.initialized = true;
             throw error;
         }
@@ -879,7 +875,9 @@ function performTargetedScan(targetDeviceId, timeoutMs = NOBLE_BLE_TARGETED_SCAN
 }
 function enumerateDevices(isWindowDestroyed) {
     return index.__awaiter(this, void 0, void 0, function* () {
-        yield initializeNoble();
+        if (!noble) {
+            yield initializeNoble();
+        }
         if (!noble) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Noble not available');
         }
@@ -1178,7 +1176,8 @@ function setupConnectionAndDiscoverServices(peripheral, deviceId, webContents) {
             yield forceReconnectPeripheral(peripheral, deviceId);
         }
         catch (resetError) {
-            if ((resetError === null || resetError === void 0 ? void 0 : resetError.errorCode) === hdShared.HardwareErrorCode.BleDeviceDisconnected) {
+            if (hdShared.isBleStaleBondHardwareError(resetError) ||
+                (resetError === null || resetError === void 0 ? void 0 : resetError.errorCode) === hdShared.HardwareErrorCode.BleDeviceDisconnected) {
                 throw resetError;
             }
             logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Connection reset before discovery failed, continuing', resetError);
@@ -1259,6 +1258,10 @@ function tryDirectConnectById(deviceId) {
                 deviceId,
                 error: String(error),
             });
+            const nativeError = error;
+            if (nativeError.nativeErrorCode === 14 && nativeError.nativeErrorDomain === 'CBErrorDomain') {
+                throw createNobleBleConnectionError(nativeError);
+            }
             directConnectCooldownUntil.set(deviceId, Date.now() + DIRECT_CONNECT_COOLDOWN_MS);
             return undefined;
         }
@@ -1272,7 +1275,6 @@ function tryDirectConnectById(deviceId) {
 function connectDevice(deviceId, webContents) {
     var _a, _b, _c;
     return index.__awaiter(this, void 0, void 0, function* () {
-        yield initializeNoble();
         logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Connect device request:', {
             deviceId,
             hasDiscovered: discoveredDevices.has(deviceId),
@@ -1286,6 +1288,9 @@ function connectDevice(deviceId, webContents) {
             peripheral = undefined;
         }
         if (!peripheral) {
+            if (!noble) {
+                yield initializeNoble();
+            }
             if (!noble) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Noble not available');
             }
@@ -1308,17 +1313,29 @@ function connectDevice(deviceId, webContents) {
                     return undefined;
                 }
             });
+            let staleBondError;
             const connectById = () => index.__awaiter(this, void 0, void 0, function* () {
-                const found = yield tryDirectConnectById(deviceId);
-                if (found) {
-                    discoveredDevices.set(deviceId, found);
+                try {
+                    const found = yield tryDirectConnectById(deviceId);
+                    if (found) {
+                        discoveredDevices.set(deviceId, found);
+                    }
+                    return found;
+                }
+                catch (error) {
+                    if (error.errorCode !== hdShared.HardwareErrorCode.BleBondInvalid) {
+                        throw error;
+                    }
+                    staleBondError = error;
+                    return undefined;
                 }
-                return found;
             });
             peripheral = byIdFirst ? yield connectById() : yield scanForPeripheral();
             if (!peripheral) {
                 peripheral = byIdFirst ? yield scanForPeripheral() : yield connectById();
             }
+            if (!peripheral && staleBondError)
+                throw staleBondError;
         }
         assertBleActive();
         if (!peripheral) {

package/dist/noble-ble-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"noble-ble-handler.d.ts","sourceRoot":"","sources":["../src/noble-ble-handler.ts"],"names":[],"mappings":"AAiCA,OAAO,KAAK,EAA+B,WAAW,EAAE,MAAM,UAAU,CAAC;AAEzE,OAAO,KAAK,EAAE,wBAAwB,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAiC1F,KAAK,mBAAmB,GAAG,KAAK,GAAG;IACjC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,mBAAmB,EAAE,aAAa,SAAK,+CAG3F;AAED,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,OAAO,GAAG,wBAAwB,CAgCvF;AA+KD,wBAAgB,+BAA+B,CAAC,OAAO,CAAC,EAAE,oBAAoB,UAI7E;AAkzDD,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAkOpE;AAOD,wBAAgB,sBAAsB,CACpC,YAAY,GAAE,CAAC,QAAQ,EAAE;IAAE,IAAI,IAAI,IAAI,CAAA;CAAE,KAAK,IAAkC,GAC/E,OAAO,CAAC,IAAI,CAAC,CAiEf"}
+{"version":3,"file":"noble-ble-handler.d.ts","sourceRoot":"","sources":["../src/noble-ble-handler.ts"],"names":[],"mappings":"AAkCA,OAAO,KAAK,EAA+B,WAAW,EAAE,MAAM,UAAU,CAAC;AAEzE,OAAO,KAAK,EAAE,wBAAwB,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAiC1F,KAAK,mBAAmB,GAAG,KAAK,GAAG;IACjC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,mBAAmB,EAAE,aAAa,SAAK,+CAgB3F;AAED,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,OAAO,GAAG,wBAAwB,CAgCvF;AA+KD,wBAAgB,+BAA+B,CAAC,OAAO,CAAC,EAAE,oBAAoB,UAI7E;AA2zDD,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAkOpE;AAOD,wBAAgB,sBAAsB,CACpC,YAAY,GAAE,CAAC,QAAQ,EAAE;IAAE,IAAI,IAAI,IAAI,CAAA;CAAE,KAAK,IAAkC,GAC/E,OAAO,CAAC,IAAI,CAAC,CAiEf"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-electron",
-  "version": "1.2.8-alpha.9",
+  "version": "1.2.8",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
   "license": "MIT",
@@ -25,9 +25,9 @@
     "electron-log": ">=4.0.0"
   },
   "dependencies": {
-    "@onekeyfe/hd-core": "1.2.8-alpha.9",
-    "@onekeyfe/hd-shared": "1.2.8-alpha.9",
-    "@onekeyfe/hd-transport": "1.2.8-alpha.9",
+    "@onekeyfe/hd-core": "1.2.8",
+    "@onekeyfe/hd-shared": "1.2.8",
+    "@onekeyfe/hd-transport": "1.2.8",
     "@stoprocent/noble": "2.3.16",
     "p-retry": "^4.6.2"
   },
@@ -36,5 +36,5 @@
     "electron": "^25.0.0",
     "typescript": "^5.3.3"
   },
-  "gitHead": "37659eef6ee06b7aa07faeb8f791f884b1b3e890"
+  "gitHead": "9f016278a7f395bf66b8502815dc63191e162fd3"
 }

package/src/__tests__/noble-ble-handler.test.ts

@@ -31,17 +31,22 @@ describe('Electron Noble BLE device discovery', () => {
     expect(NOBLE_BLE_SUBSCRIBE_TIMEOUT_MS).toBe(10_000);
   });
 
-  test('maps native macOS connection failures to the generic connection error', async () => {
+  test('maps structured macOS stale pairing failures without parsing localized text', async () => {
     const { createNobleBleConnectionError } = await import('../noble-ble-handler');
 
-    expect(
-      createNobleBleConnectionError(
-        Object.assign(new Error('Peer removed pairing information on the device side'), {
-          nativeErrorCode: 14,
-          nativeErrorDomain: 'CBErrorDomain',
-        })
-      )
-    ).toMatchObject({ errorCode: HardwareErrorCode.BleConnectedError });
+    const staleBondError = createNobleBleConnectionError(
+      Object.assign(new Error('Peer removed pairing information on the device side'), {
+        nativeErrorCode: 14,
+        nativeErrorDomain: 'CBErrorDomain',
+      })
+    );
+    expect(staleBondError).toMatchObject({
+      errorCode: HardwareErrorCode.BleBondInvalid,
+      params: {
+        nativeErrorMessage: 'Peer removed pairing information on the device side',
+      },
+    });
+    expect(staleBondError.message).toContain('Peer removed pairing information on the device side');
     expect(createNobleBleConnectionError(new Error('Encryption is insufficient'))).toMatchObject({
       errorCode: HardwareErrorCode.BleConnectedError,
     });
@@ -76,16 +81,18 @@ describe('Electron Noble BLE device discovery', () => {
     expect(
       createNobleBleIpcErrorResponse({
         name: 'HardwareError',
-        message: 'Bluetooth connection failed',
-        errorCode: HardwareErrorCode.BleConnectedError,
+        message: 'Bluetooth pairing information is no longer valid',
+        errorCode: HardwareErrorCode.BleBondInvalid,
+        params: { nativeErrorMessage: 'native message' },
       })
     ).toEqual({
       type: 'NobleBleIpcError',
       success: false,
       error: {
         name: 'HardwareError',
-        message: 'Bluetooth connection failed',
-        errorCode: HardwareErrorCode.BleConnectedError,
+        message: 'Bluetooth pairing information is no longer valid',
+        errorCode: HardwareErrorCode.BleBondInvalid,
+        params: { nativeErrorMessage: 'native message' },
       },
     });
 
@@ -128,14 +135,14 @@ describe('Electron Noble BLE device discovery', () => {
           success: false as const,
           error: {
             name: 'HardwareError',
-            message: 'Bluetooth connection failed',
-            errorCode: HardwareErrorCode.BleConnectedError,
+            message: 'Bluetooth pairing information is no longer valid',
+            errorCode: HardwareErrorCode.BleBondInvalid,
           },
         })
       )
     ).rejects.toMatchObject({
       name: 'HardwareError',
-      errorCode: HardwareErrorCode.BleConnectedError,
+      errorCode: HardwareErrorCode.BleBondInvalid,
     });
 
     await expect(invokeNobleBleIpc(Promise.resolve('connected'))).resolves.toBe('connected');
@@ -292,13 +299,9 @@ describe('Electron Noble BLE device discovery', () => {
     }
   );
 
-  test.each([
-    ['Pro A1B2', 'unavailable'],
-    ['Pro2 A1B2', 'unavailable'],
-    ['Pro2 A1B2', 'native error 14'],
-  ])(
-    'refreshes a retained disconnected %s peripheral before cold connecting (direct: %s)',
-    async (name, directConnectResult) => {
+  test.each(['Pro A1B2', 'Pro2 A1B2'])(
+    'refreshes a retained disconnected %s peripheral before cold connecting',
+    async name => {
       const handlers = new Map<string, IpcHandler>();
       const stalePeripheral = Object.assign(new EventEmitter(), createPeripheral('device', name), {
         connect: jest.fn(),
@@ -315,16 +318,7 @@ describe('Electron Noble BLE device discovery', () => {
           noble.emit('discover', freshPeripheral);
         }),
         stopScanning: jest.fn(callback => callback?.()),
-        connectAsync: jest.fn(() =>
-          directConnectResult === 'native error 14'
-            ? Promise.reject(
-                Object.assign(new Error('native direct connection failure'), {
-                  nativeErrorDomain: 'CBErrorDomain',
-                  nativeErrorCode: 14,
-                })
-              )
-            : Promise.resolve(undefined)
-        ),
+        connectAsync: jest.fn(() => Promise.resolve(undefined)),
       });
       jest.doMock('@stoprocent/noble', () => noble);
       jest.doMock('electron', () => ({
@@ -358,6 +352,87 @@ describe('Electron Noble BLE device discovery', () => {
     }
   );
 
+  test.each([
+    { rediscovered: false, expectedCode: HardwareErrorCode.BleBondInvalid },
+    { rediscovered: true, expectedCode: HardwareErrorCode.BleConnectedError },
+  ])(
+    'reports a macOS stale bond only when fallback scan misses (rediscovered=$rediscovered)',
+    async ({ rediscovered, expectedCode }) => {
+      jest.useFakeTimers({ doNotFake: ['performance'] });
+      const handlers = new Map<string, IpcHandler>();
+      const stalePeripheral = createPeripheral('device', 'Pro2 A1B2');
+      const freshPeripheral = Object.assign(
+        new EventEmitter(),
+        createPeripheral('device', 'Pro2 A1B2'),
+        {
+          connect: jest.fn((callback: (error?: Error) => void) => {
+            callback(new Error('fresh connection failed'));
+          }),
+        }
+      );
+      const staleBondError = Object.assign(new Error('Peer removed pairing information'), {
+        nativeErrorCode: 14,
+        nativeErrorDomain: 'CBErrorDomain',
+      });
+      let scanStarted: (() => void) | undefined;
+      const scanning = new Promise<void>(resolve => {
+        scanStarted = resolve;
+      });
+      const noble = Object.assign(new EventEmitter(), {
+        state: 'poweredOn',
+        startScanning: jest.fn((_services, _duplicates, callback) => {
+          callback?.();
+          if (rediscovered) noble.emit('discover', freshPeripheral);
+          scanStarted?.();
+        }),
+        stopScanning: jest.fn(callback => callback?.()),
+        connectAsync: jest.fn(() => Promise.reject(staleBondError)),
+      });
+      jest.doMock('@stoprocent/noble', () => noble);
+      jest.doMock('electron', () => ({
+        ipcMain: {
+          handle: (channel: string, handler: IpcHandler) => handlers.set(channel, handler),
+          removeHandler: (channel: string) => handlers.delete(channel),
+        },
+      }));
+      jest.doMock('electron-log', () => ({
+        info: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+      }));
+      const { setupNobleBleHandlers } = await import('../noble-ble-handler');
+      setupNobleBleHandlers({ on: jest.fn(), send: jest.fn() } as unknown as WebContents);
+      const availability = handlers.get(EOneKeyBleMessageKeys.BLE_AVAILABILITY_CHECK);
+      const connect = handlers.get(EOneKeyBleMessageKeys.NOBLE_BLE_CONNECT);
+      if (!availability || !connect) throw new Error('Noble handlers were not registered');
+      await availability();
+      noble.emit('discover', stalePeripheral);
+
+      const connecting = Promise.resolve(connect(undefined, stalePeripheral.id));
+      await scanning;
+      jest.advanceTimersByTime(1500);
+      await expect(connecting).resolves.toMatchObject({
+        success: false,
+        error: { errorCode: expectedCode },
+      });
+      if (!rediscovered) {
+        const secondScan = new Promise<void>(resolve => {
+          scanStarted = resolve;
+        });
+        const retry = Promise.resolve(connect(undefined, stalePeripheral.id));
+        await secondScan;
+        jest.advanceTimersByTime(1500);
+        await expect(retry).resolves.toMatchObject({
+          success: false,
+          error: { errorCode: HardwareErrorCode.BleBondInvalid },
+        });
+      }
+      expect(noble.connectAsync).toHaveBeenCalledTimes(rediscovered ? 1 : 2);
+      expect(noble.startScanning).toHaveBeenCalledTimes(rediscovered ? 1 : 2);
+      expect(freshPeripheral.connect).toHaveBeenCalledTimes(rediscovered ? 1 : 0);
+    }
+  );
+
   test('waits for a targeted scan to stop before connecting', async () => {
     jest.useFakeTimers({ doNotFake: ['performance'] });
 
@@ -931,59 +1006,6 @@ describe('Noble BLE process shutdown', () => {
     expect(handlers.size).toBe(0);
   });
 
-  test.each([
-    ['poweredOff', HardwareErrorCode.BlePoweredOff],
-    ['unauthorized', HardwareErrorCode.BleLocationError],
-    ['unsupported', HardwareErrorCode.BleUnsupported],
-  ])(
-    'preserves adapter state %s across repeated scans and connections',
-    async (state, errorCode) => {
-      jest.useFakeTimers({ doNotFake: ['performance'] });
-      const { sdk, native, handlers } = await setup(state);
-      for (let attempt = 0; attempt < 2; attempt += 1) {
-        for (const channel of [
-          EOneKeyBleMessageKeys.NOBLE_BLE_ENUMERATE,
-          EOneKeyBleMessageKeys.NOBLE_BLE_CONNECT,
-        ]) {
-          await expect(handlers.get(channel)?.({}, 'device')).resolves.toMatchObject({
-            success: false,
-            error: { errorCode },
-          });
-        }
-      }
-      expect(native.startScanning).not.toHaveBeenCalled();
-      expect(native.listenerCount('stateChange')).toBe(1);
-      expect(jest.getTimerCount()).toBe(0);
-      await sdk.disposeNobleBleSupport();
-    }
-  );
-
-  test.each([
-    ['poweredOff', HardwareErrorCode.BlePoweredOff],
-    ['unauthorized', HardwareErrorCode.BleLocationError],
-    ['unsupported', HardwareErrorCode.BleUnsupported],
-  ])('checks adapter state %s again after initialization', async (state, errorCode) => {
-    const { sdk, native, handlers } = await setup();
-    const checkAvailability = handlers.get(EOneKeyBleMessageKeys.BLE_AVAILABILITY_CHECK);
-    await expect(checkAvailability?.({})).resolves.toMatchObject({ available: true });
-    native.state = state;
-    native.emit('stateChange', state);
-    for (const channel of [
-      EOneKeyBleMessageKeys.NOBLE_BLE_ENUMERATE,
-      EOneKeyBleMessageKeys.NOBLE_BLE_CONNECT,
-    ]) {
-      await expect(handlers.get(channel)?.({}, 'device')).resolves.toMatchObject({
-        success: false,
-        error: { errorCode },
-      });
-    }
-    expect(native.startScanning).not.toHaveBeenCalled();
-    native.state = 'poweredOn';
-    native.emit('stateChange', native.state);
-    await expect(checkAvailability?.({})).resolves.toMatchObject({ available: true });
-    await sdk.disposeNobleBleSupport();
-  });
-
   test('cancels an active scan, ignores its late callback and releases native once', async () => {
     jest.useFakeTimers({ doNotFake: ['performance'] });
     const { sdk, native, handlers } = await setup();

package/src/noble-ble-handler.ts

@@ -16,6 +16,7 @@ import {
   ONEKEY_WRITE_CHARACTERISTIC_UUID,
   createKnownBleUuidAliases,
   hasOnekeyCommunicationService,
+  isBleStaleBondHardwareError,
   isOnekeyBluetoothDevice,
   isPro2FamilyBleName,
   matchesKnownBleUuid,
@@ -73,6 +74,19 @@ type NobleBleNativeError = Error & {
 
 export function createNobleBleConnectionError(error: NobleBleNativeError, messagePrefix = '') {
   const errorMessage = error.message;
+  const isInvalidMacOsBond =
+    error.nativeErrorCode === 14 && error.nativeErrorDomain === 'CBErrorDomain';
+  if (isInvalidMacOsBond) {
+    const nativeErrorMessage = `${messagePrefix}${errorMessage}`;
+    return ERRORS.TypedError(
+      HardwareErrorCode.BleBondInvalid,
+      `${HardwareErrorCodeMessage[HardwareErrorCode.BleBondInvalid]} (${nativeErrorMessage})`,
+      {
+        nativeErrorMessage,
+      }
+    );
+  }
+
   return ERRORS.TypedError(HardwareErrorCode.BleConnectedError, `${messagePrefix}${errorMessage}`);
 }
 
@@ -429,18 +443,7 @@ function updateBluetoothState(state: string): void {
 // Initialize Noble
 async function initializeNoble(): Promise<void> {
   assertBleActive();
-  if (noble) {
-    if (noble.state === 'poweredOff') {
-      throw ERRORS.TypedError(HardwareErrorCode.BlePoweredOff);
-    }
-    if (noble.state === 'unsupported') {
-      throw ERRORS.TypedError(HardwareErrorCode.BleUnsupported);
-    }
-    if (noble.state === 'unauthorized') {
-      throw ERRORS.TypedError(HardwareErrorCode.BleLocationError);
-    }
-    return;
-  }
+  if (noble) return;
 
   try {
     // eslint-disable-next-line @typescript-eslint/no-var-requires, global-require
@@ -493,7 +496,7 @@ async function initializeNoble(): Promise<void> {
           reject(ERRORS.TypedError(HardwareErrorCode.BlePoweredOff));
         } else if (state === 'unauthorized') {
           cleanup();
-          reject(ERRORS.TypedError(HardwareErrorCode.BleLocationError));
+          reject(ERRORS.TypedError(HardwareErrorCode.BlePermissionError));
         }
       };
 
@@ -505,7 +508,6 @@ async function initializeNoble(): Promise<void> {
       };
       pendingCancellations.add(cancel);
       noble.on('stateChange', onStateChange);
-      onStateChange(noble.state);
     });
 
     assertBleActive();
@@ -520,7 +522,7 @@ async function initializeNoble(): Promise<void> {
     logger?.info('[NobleBLE] Noble initialized successfully');
   } catch (error) {
     logger?.error('[NobleBLE] Failed to initialize Noble:', error);
-    bluetoothState.unsupported = noble?.state === 'unsupported';
+    bluetoothState.unsupported = true;
     bluetoothState.initialized = true;
     throw error;
   }
@@ -1149,7 +1151,9 @@ async function performTargetedScan(
 
 // Enumerate devices
 async function enumerateDevices(isWindowDestroyed: () => boolean): Promise<DeviceInfo[]> {
-  await initializeNoble();
+  if (!noble) {
+    await initializeNoble();
+  }
 
   if (!noble) {
     throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Noble not available');
@@ -1630,6 +1634,7 @@ async function setupConnectionAndDiscoverServices(
     await forceReconnectPeripheral(peripheral, deviceId);
   } catch (resetError) {
     if (
+      isBleStaleBondHardwareError(resetError) ||
       (resetError as { errorCode?: unknown })?.errorCode === HardwareErrorCode.BleDeviceDisconnected
     ) {
       throw resetError;
@@ -1740,6 +1745,10 @@ async function tryDirectConnectById(deviceId: string): Promise<Peripheral | unde
       deviceId,
       error: String(error),
     });
+    const nativeError = error as NobleBleNativeError;
+    if (nativeError.nativeErrorCode === 14 && nativeError.nativeErrorDomain === 'CBErrorDomain') {
+      throw createNobleBleConnectionError(nativeError);
+    }
     directConnectCooldownUntil.set(deviceId, Date.now() + DIRECT_CONNECT_COOLDOWN_MS);
     return undefined;
   } finally {
@@ -1750,7 +1759,6 @@ async function tryDirectConnectById(deviceId: string): Promise<Peripheral | unde
 
 // Connect to device - supports both discovered and direct connection modes
 async function connectDevice(deviceId: string, webContents: WebContents): Promise<void> {
-  await initializeNoble();
   logger?.info('[NobleBLE] Connect device request:', {
     deviceId,
     hasDiscovered: discoveredDevices.has(deviceId),
@@ -1768,6 +1776,11 @@ async function connectDevice(deviceId: string, webContents: WebContents): Promis
   }
 
   if (!peripheral) {
+    // Initialize Noble if not already done
+    if (!noble) {
+      await initializeNoble();
+    }
+
     if (!noble) {
       throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Noble not available');
     }
@@ -1799,12 +1812,21 @@ async function connectDevice(deviceId: string, webContents: WebContents): Promis
       }
     };
 
+    let staleBondError: Error | undefined;
     const connectById = async () => {
-      const found = await tryDirectConnectById(deviceId);
-      if (found) {
-        discoveredDevices.set(deviceId, found);
+      try {
+        const found = await tryDirectConnectById(deviceId);
+        if (found) {
+          discoveredDevices.set(deviceId, found);
+        }
+        return found;
+      } catch (error) {
+        if ((error as { errorCode?: number }).errorCode !== HardwareErrorCode.BleBondInvalid) {
+          throw error;
+        }
+        staleBondError = error as Error;
+        return undefined;
       }
-      return found;
     };
 
     peripheral = byIdFirst ? await connectById() : await scanForPeripheral();
@@ -1813,6 +1835,7 @@ async function connectDevice(deviceId: string, webContents: WebContents): Promis
       // silent), or not reachable by id. Try the other one before giving up.
       peripheral = byIdFirst ? await scanForPeripheral() : await connectById();
     }
+    if (!peripheral && staleBondError) throw staleBondError;
   }
 
   assertBleActive();