@onekeyfe/hd-transport-electron 1.1.2-alpha.1 → 1.1.2-alpha.2

package/dist/{index-24388fe8.js → index-732ee055.js}

@@ -32,7 +32,7 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
 
 function initNobleBleSupport(webContents) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { setupNobleBleHandlers } = yield Promise.resolve().then(function () { return require('./noble-ble-handler-40f8fb32.js'); });
+        const { setupNobleBleHandlers } = yield Promise.resolve().then(function () { return require('./noble-ble-handler-bf2b2a66.js'); });
         setupNobleBleHandlers(webContents);
     });
 }

package/dist/index.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var index = require('./index-24388fe8.js');
+var index = require('./index-732ee055.js');
 
 
 

package/dist/{noble-ble-handler-40f8fb32.js → noble-ble-handler-bf2b2a66.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./index-24388fe8.js');
+var index = require('./index-732ee055.js');
 var hdShared = require('@onekeyfe/hd-shared');
 var hdTransport = require('@onekeyfe/hd-transport');
 
@@ -26,7 +26,6 @@ const connectedDevices = new Map();
 const deviceCharacteristics = new Map();
 const notificationCallbacks = new Map();
 const subscribedDevices = new Map();
-const subscriptionOperations = new Map();
 const devicePacketStates = new Map();
 const recentWriteOperations = new Map();
 const WRITE_DISCONNECT_THRESHOLD = 1000;
@@ -37,7 +36,7 @@ const BLUETOOTH_INIT_TIMEOUT = 10000;
 const DEVICE_SCAN_TIMEOUT = 5000;
 const FAST_SCAN_TIMEOUT = 1500;
 const DEVICE_CHECK_INTERVAL = 500;
-const CONNECTION_TIMEOUT = 3000;
+const CONNECTION_TIMEOUT = 15000;
 const CHUNK_WRITE_DELAY = 10;
 const BLE_PACKET_SIZE = 192;
 const MIN_HEADER_LENGTH = 9;
@@ -57,13 +56,7 @@ function processNotificationData(deviceId, data) {
             packetState.buffer = [...data.subarray(3)];
             packetState.packetCount = 1;
             packetState.messageId = messageId;
-            if (packetState.bufferLength < 0) {
-                logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Invalid negative packet length detected:', {
-                    length: packetState.bufferLength,
-                    dataLength: data.length,
-                    rawHeader: data.subarray(0, Math.min(16, data.length)).toString('hex'),
-                    lengthBytes: data.subarray(5, 9).toString('hex'),
-                });
+            if (packetState.bufferLength <= 0) {
                 resetPacketState(packetState);
                 return { isComplete: false, error: 'Invalid packet length in header' };
             }
@@ -212,19 +205,13 @@ function cleanupDeviceState(deviceId) {
     devicePacketStates.delete(deviceId);
     subscribedDevices.delete(deviceId);
     recentWriteOperations.delete(deviceId);
-    subscriptionOperations.delete(deviceId);
     logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device state cleaned up:', deviceId);
 }
 function handleDeviceDisconnect(deviceId, webContents) {
-    var _a, _b;
-    logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] ⚠️  DEVICE DISCONNECT DETECTED:', {
-        deviceId,
-        hasPeripheral: connectedDevices.has(deviceId),
-        hasCharacteristics: deviceCharacteristics.has(deviceId),
-        stackTrace: (_a = new Error().stack) === null || _a === void 0 ? void 0 : _a.split('\n').slice(1, 5),
-    });
+    var _a;
+    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device disconnected:', deviceId);
     const peripheral = connectedDevices.get(deviceId);
-    const deviceName = ((_b = peripheral === null || peripheral === void 0 ? void 0 : peripheral.advertisement) === null || _b === void 0 ? void 0 : _b.localName) || 'Unknown Device';
+    const deviceName = ((_a = peripheral === null || peripheral === void 0 ? void 0 : peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.localName) || 'Unknown Device';
     const recentWriteTime = recentWriteOperations.get(deviceId);
     const now = Date.now();
     const isPairingRejection = recentWriteTime && now - recentWriteTime < WRITE_DISCONNECT_THRESHOLD;
@@ -245,12 +232,17 @@ function setupDisconnectListener(peripheral, deviceId, webContents) {
     });
 }
 function handleDeviceDiscovered(peripheral) {
-    var _a;
+    var _a, _b;
     const deviceName = ((_a = peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.localName) || 'Unknown Device';
     if (!hdShared.isOnekeyDevice(deviceName)) {
         return;
     }
-    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Discovered OneKey device:', deviceName);
+    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Discovered OneKey device:', {
+        id: peripheral.id,
+        name: deviceName,
+        rssi: peripheral.rssi,
+        serviceUuids: (_b = peripheral.advertisement) === null || _b === void 0 ? void 0 : _b.serviceUuids,
+    }, peripheral);
     discoveredDevices.set(peripheral.id, peripheral);
 }
 function performTargetedScan(targetDeviceId) {
@@ -453,14 +445,6 @@ function discoverServicesAndCharacteristics(peripheral) {
 }
 function connectDevice(deviceId, webContents) {
     return index.__awaiter(this, void 0, void 0, function* () {
-        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Connect device request:', {
-            deviceId,
-            hasDiscovered: discoveredDevices.has(deviceId),
-            hasConnected: connectedDevices.has(deviceId),
-            hasCharacteristics: deviceCharacteristics.has(deviceId),
-            totalDiscovered: discoveredDevices.size,
-            totalConnected: connectedDevices.size,
-        });
         let peripheral = discoveredDevices.get(deviceId);
         if (!peripheral) {
             logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device not discovered, attempting targeted scan for:', deviceId);
@@ -494,26 +478,18 @@ function connectDevice(deviceId, webContents) {
             }
             if (deviceCharacteristics.has(deviceId)) {
                 logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device characteristics already available');
-                const ongoingOperation = subscriptionOperations.get(deviceId);
-                if (ongoingOperation && ongoingOperation !== 'idle') {
-                    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device has ongoing subscription operation:', ongoingOperation, 'waiting...');
-                    yield hdShared.wait(100);
-                    return connectDevice(deviceId, webContents);
-                }
-                const hasActiveSubscription = subscribedDevices.has(deviceId);
-                const hasCallback = notificationCallbacks.has(deviceId);
-                if (hasActiveSubscription && hasCallback) {
-                    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device already has active notification subscription, reusing connection');
-                    return;
-                }
-                logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Found orphaned characteristics without active subscription, cleaning up');
-                const existingCharacteristics = deviceCharacteristics.get(deviceId);
-                if (existingCharacteristics) {
-                    existingCharacteristics.notify.removeAllListeners('data');
+                const existingCallback = notificationCallbacks.get(deviceId);
+                if (existingCallback) {
+                    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Cleaning up existing notification state');
+                    const existingCharacteristics = deviceCharacteristics.get(deviceId);
+                    if (existingCharacteristics) {
+                        existingCharacteristics.notify.removeAllListeners('data');
+                    }
+                    notificationCallbacks.delete(deviceId);
+                    devicePacketStates.delete(deviceId);
+                    subscribedDevices.delete(deviceId);
                 }
-                notificationCallbacks.delete(deviceId);
-                devicePacketStates.delete(deviceId);
-                subscribedDevices.delete(deviceId);
+                return;
             }
             try {
                 const characteristics = yield discoverServicesAndCharacteristics(peripheral);
@@ -649,7 +625,6 @@ function subscribeNotifications(deviceId, callback) {
         }
         const { notify: notifyCharacteristic } = characteristics;
         logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Subscribing to notifications for device:', deviceId);
-        subscriptionOperations.set(deviceId, 'subscribing');
         if (subscribedDevices.get(deviceId)) {
             logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device already subscribed to characteristic, updating callback only');
             notificationCallbacks.set(deviceId, callback);
@@ -659,7 +634,6 @@ function subscribeNotifications(deviceId, callback) {
                 packetCount: 0,
                 messageId: undefined,
             });
-            subscriptionOperations.set(deviceId, 'idle');
             return Promise.resolve();
         }
         if (notificationCallbacks.has(deviceId)) {
@@ -674,17 +648,14 @@ function subscribeNotifications(deviceId, callback) {
             messageId: undefined,
         });
         return new Promise((resolve, reject) => {
-            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] 🔄 Starting subscription process...', { deviceId });
             notifyCharacteristic.subscribe((error) => {
                 if (error) {
-                    logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] ❌ Notification subscription failed:', error);
-                    subscriptionOperations.set(deviceId, 'idle');
+                    logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Notification subscription failed:', error);
                     reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleCharacteristicNotifyError, error));
                     return;
                 }
-                logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] ✅ Notification subscription successful');
+                logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Notification subscription successful');
                 subscribedDevices.set(deviceId, true);
-                subscriptionOperations.set(deviceId, 'idle');
                 notifyCharacteristic.on('data', (data) => {
                     const result = processNotificationData(deviceId, data);
                     if (result.error) {
@@ -713,7 +684,6 @@ function unsubscribeNotifications(deviceId) {
         }
         const { notify: notifyCharacteristic } = characteristics;
         logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Unsubscribing from notifications for device:', deviceId);
-        subscriptionOperations.set(deviceId, 'unsubscribing');
         return new Promise(resolve => {
             notifyCharacteristic.unsubscribe((error) => {
                 if (error) {
@@ -726,7 +696,6 @@ function unsubscribeNotifications(deviceId) {
                 notificationCallbacks.delete(deviceId);
                 devicePacketStates.delete(deviceId);
                 subscribedDevices.delete(deviceId);
-                subscriptionOperations.set(deviceId, 'idle');
                 resolve();
             });
         });
@@ -753,12 +722,6 @@ function setupNobleBleHandlers(webContents) {
         }));
         ipcMain.handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_GET_DEVICE, (_event, deviceId) => getDevice(deviceId));
         ipcMain.handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_CONNECT, (_event, deviceId) => index.__awaiter(this, void 0, void 0, function* () {
-            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] IPC CONNECT request received:', {
-                deviceId,
-                hasPeripheral: connectedDevices.has(deviceId),
-                hasCharacteristics: deviceCharacteristics.has(deviceId),
-                totalConnectedDevices: connectedDevices.size,
-            });
             yield connectDevice(deviceId, webContents);
         }));
         ipcMain.handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_DISCONNECT, (_event, deviceId) => index.__awaiter(this, void 0, void 0, function* () {
@@ -807,7 +770,6 @@ function setupNobleBleHandlers(webContents) {
             notificationCallbacks.clear();
             devicePacketStates.clear();
             subscribedDevices.clear();
-            subscriptionOperations.clear();
         });
         safeLog(logger, 'info', 'Noble BLE IPC handlers setup completed');
     }

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":"AAmBA,OAAO,KAAK,EAAE,WAAW,EAAsB,MAAM,UAAU,CAAC;AA0gChE,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAuIpE"}
+{"version":3,"file":"noble-ble-handler.d.ts","sourceRoot":"","sources":["../src/noble-ble-handler.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,WAAW,EAAsB,MAAM,UAAU,CAAC;AA88BhE,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CA8HpE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-electron",
-  "version": "1.1.2-alpha.1",
+  "version": "1.1.2-alpha.2",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
   "license": "MIT",
@@ -26,12 +26,12 @@
     "electron-log": ">=4.0.0"
   },
   "dependencies": {
-    "@onekeyfe/hd-shared": "^1.1.2-alpha.1"
+    "@onekeyfe/hd-shared": "^1.1.2-alpha.2"
   },
   "devDependencies": {
     "@types/web-bluetooth": "^0.0.17",
     "electron": "^25.0.0",
     "typescript": "^5.3.3"
   },
-  "gitHead": "273e9a529100dff8cf896adaf4b7127cbecadf08"
+  "gitHead": "3d9a4eec5eddf20b1a01c41f5c80793446924c6e"
 }

package/src/noble-ble-handler.ts

@@ -14,7 +14,6 @@ import {
   isHeaderChunk,
   ERRORS,
   HardwareErrorCode,
-  wait,
 } from '@onekeyfe/hd-shared';
 import { COMMON_HEADER_SIZE } from '@onekeyfe/hd-transport';
 import type { WebContents, IpcMainInvokeEvent } from 'electron';
@@ -47,9 +46,6 @@ const deviceCharacteristics = new Map<string, CharacteristicPair>();
 const notificationCallbacks = new Map<string, (data: string) => void>();
 const subscribedDevices = new Map<string, boolean>(); // Track subscription status
 
-// 🔒 Add subscription operation state tracking to prevent race conditions
-const subscriptionOperations = new Map<string, 'subscribing' | 'unsubscribing' | 'idle'>();
-
 // Packet reassembly state for each device
 interface PacketAssemblyState {
   bufferLength: number;
@@ -75,7 +71,7 @@ const BLUETOOTH_INIT_TIMEOUT = 10000; // 10 seconds for Bluetooth initialization
 const DEVICE_SCAN_TIMEOUT = 5000; // 5 seconds for device scanning
 const FAST_SCAN_TIMEOUT = 1500; // 1.5 seconds for fast targeted scanning
 const DEVICE_CHECK_INTERVAL = 500; // 500ms interval for periodic device checks
-const CONNECTION_TIMEOUT = 3000; // 15 seconds for device connection
+const CONNECTION_TIMEOUT = 15000; // 15 seconds for device connection
 const CHUNK_WRITE_DELAY = 10; // 10ms delay between chunk writes
 
 // BLE packet size constants
@@ -116,14 +112,8 @@ function processNotificationData(deviceId: string, data: Buffer): PacketProcessR
       packetState.packetCount = 1;
       packetState.messageId = messageId;
 
-      // Only validate for negative lengths (which would be invalid)
-      if (packetState.bufferLength < 0) {
-        logger?.error('[NobleBLE] Invalid negative packet length detected:', {
-          length: packetState.bufferLength,
-          dataLength: data.length,
-          rawHeader: data.subarray(0, Math.min(16, data.length)).toString('hex'),
-          lengthBytes: data.subarray(5, 9).toString('hex'),
-        });
+      // Validate expected length is reasonable
+      if (packetState.bufferLength <= 0) {
         resetPacketState(packetState);
         return { isComplete: false, error: 'Invalid packet length in header' };
       }
@@ -309,19 +299,12 @@ function cleanupDeviceState(deviceId: string): void {
   devicePacketStates.delete(deviceId);
   subscribedDevices.delete(deviceId);
   recentWriteOperations.delete(deviceId);
-  // 🔒 Clear operation state
-  subscriptionOperations.delete(deviceId);
   logger?.info('[NobleBLE] Device state cleaned up:', deviceId);
 }
 
 // Handle device disconnection - unified handler for all disconnect scenarios
 function handleDeviceDisconnect(deviceId: string, webContents: WebContents): void {
-  logger?.error('[NobleBLE] ⚠️  DEVICE DISCONNECT DETECTED:', {
-    deviceId,
-    hasPeripheral: connectedDevices.has(deviceId),
-    hasCharacteristics: deviceCharacteristics.has(deviceId),
-    stackTrace: new Error().stack?.split('\n').slice(1, 5),
-  });
+  logger?.info('[NobleBLE] Device disconnected:', deviceId);
 
   // Get device info before cleanup
   const peripheral = connectedDevices.get(deviceId);
@@ -372,7 +355,16 @@ function handleDeviceDiscovered(peripheral: Peripheral): void {
     return;
   }
 
-  logger?.info('[NobleBLE] Discovered OneKey device:', deviceName);
+  logger?.info(
+    '[NobleBLE] Discovered OneKey device:',
+    {
+      id: peripheral.id,
+      name: deviceName,
+      rssi: peripheral.rssi,
+      serviceUuids: peripheral.advertisement?.serviceUuids,
+    },
+    peripheral
+  );
 
   // Cache the device in both maps
   discoveredDevices.set(peripheral.id, peripheral);
@@ -644,15 +636,6 @@ async function discoverServicesAndCharacteristics(
 
 // Connect to device - supports both discovered and direct connection modes
 async function connectDevice(deviceId: string, webContents: WebContents): Promise<void> {
-  logger?.info('[NobleBLE] Connect device request:', {
-    deviceId,
-    hasDiscovered: discoveredDevices.has(deviceId),
-    hasConnected: connectedDevices.has(deviceId),
-    hasCharacteristics: deviceCharacteristics.has(deviceId),
-    totalDiscovered: discoveredDevices.size,
-    totalConnected: connectedDevices.size,
-  });
-
   let peripheral = discoveredDevices.get(deviceId);
 
   // If device not discovered, try a targeted scan for this specific device
@@ -705,45 +688,19 @@ async function connectDevice(deviceId: string, webContents: WebContents): Promis
     // Check if we already have characteristics for this device
     if (deviceCharacteristics.has(deviceId)) {
       logger?.info('[NobleBLE] Device characteristics already available');
-
-      // ⚠️ CRITICAL FIX: Check for ongoing subscription operations to prevent race conditions
-      const ongoingOperation = subscriptionOperations.get(deviceId);
-      if (ongoingOperation && ongoingOperation !== 'idle') {
-        logger?.info(
-          '[NobleBLE] Device has ongoing subscription operation:',
-          ongoingOperation,
-          'waiting...'
-        );
-        // Wait for ongoing operation to complete
-        await wait(100);
-        // Retry connection after waiting
-        return connectDevice(deviceId, webContents);
-      }
-
-      // Don't clean up notification state if device is already properly connected
-      // The existing notification subscription is still valid and working
-      const hasActiveSubscription = subscribedDevices.has(deviceId);
-      const hasCallback = notificationCallbacks.has(deviceId);
-
-      if (hasActiveSubscription && hasCallback) {
-        logger?.info(
-          '[NobleBLE] Device already has active notification subscription, reusing connection'
-        );
-        return;
-      }
-
-      // Only clean up if subscription is broken
-      logger?.info(
-        '[NobleBLE] Found orphaned characteristics without active subscription, cleaning up'
-      );
-      const existingCharacteristics = deviceCharacteristics.get(deviceId);
-      if (existingCharacteristics) {
-        existingCharacteristics.notify.removeAllListeners('data');
+      // Clean up existing notification state to avoid conflicts
+      const existingCallback = notificationCallbacks.get(deviceId);
+      if (existingCallback) {
+        logger?.info('[NobleBLE] Cleaning up existing notification state');
+        const existingCharacteristics = deviceCharacteristics.get(deviceId);
+        if (existingCharacteristics) {
+          existingCharacteristics.notify.removeAllListeners('data');
+        }
+        notificationCallbacks.delete(deviceId);
+        devicePacketStates.delete(deviceId);
+        subscribedDevices.delete(deviceId);
       }
-      notificationCallbacks.delete(deviceId);
-      devicePacketStates.delete(deviceId);
-      subscribedDevices.delete(deviceId);
-      // Continue to re-setup the connection properly
+      return;
     }
 
     // Discover services and characteristics
@@ -931,9 +888,6 @@ async function subscribeNotifications(
 
   logger?.info('[NobleBLE] Subscribing to notifications for device:', deviceId);
 
-  // 🔒 Set operation state to prevent race conditions
-  subscriptionOperations.set(deviceId, 'subscribing');
-
   // Check if already subscribed at the characteristic level
   if (subscribedDevices.get(deviceId)) {
     logger?.info('[NobleBLE] Device already subscribed to characteristic, updating callback only');
@@ -949,8 +903,6 @@ async function subscribeNotifications(
       messageId: undefined,
     });
 
-    // 🔒 Clear operation state
-    subscriptionOperations.set(deviceId, 'idle');
     return Promise.resolve();
   }
 
@@ -973,23 +925,16 @@ async function subscribeNotifications(
 
   return new Promise((resolve, reject) => {
     // Subscribe to notifications only if not already subscribed
-    logger?.info('[NobleBLE] 🔄 Starting subscription process...', { deviceId });
-
     notifyCharacteristic.subscribe((error: string) => {
       if (error) {
-        logger?.error('[NobleBLE] ❌ Notification subscription failed:', error);
-        // 🔒 Clear operation state on error
-        subscriptionOperations.set(deviceId, 'idle');
+        logger?.error('[NobleBLE] Notification subscription failed:', error);
         reject(ERRORS.TypedError(HardwareErrorCode.BleCharacteristicNotifyError, error));
         return;
       }
 
-      logger?.info('[NobleBLE] ✅ Notification subscription successful');
+      logger?.info('[NobleBLE] Notification subscription successful');
       subscribedDevices.set(deviceId, true);
 
-      // 🔒 Clear operation state on success
-      subscriptionOperations.set(deviceId, 'idle');
-
       // Set up data handler with robust packet reassembly
       notifyCharacteristic.on('data', (data: Buffer) => {
         const result = processNotificationData(deviceId, data);
@@ -1026,9 +971,6 @@ async function unsubscribeNotifications(deviceId: string): Promise<void> {
 
   logger?.info('[NobleBLE] Unsubscribing from notifications for device:', deviceId);
 
-  // 🔒 Set operation state to prevent race conditions
-  subscriptionOperations.set(deviceId, 'unsubscribing');
-
   return new Promise<void>(resolve => {
     notifyCharacteristic.unsubscribe((error: string) => {
       if (error) {
@@ -1042,9 +984,6 @@ async function unsubscribeNotifications(deviceId: string): Promise<void> {
       notificationCallbacks.delete(deviceId);
       devicePacketStates.delete(deviceId);
       subscribedDevices.delete(deviceId);
-
-      // 🔒 Clear operation state
-      subscriptionOperations.set(deviceId, 'idle');
       resolve();
     });
   });
@@ -1089,12 +1028,6 @@ export function setupNobleBleHandlers(webContents: WebContents): void {
     ipcMain.handle(
       EOneKeyBleMessageKeys.NOBLE_BLE_CONNECT,
       async (_event: IpcMainInvokeEvent, deviceId: string) => {
-        logger?.info('[NobleBLE] IPC CONNECT request received:', {
-          deviceId,
-          hasPeripheral: connectedDevices.has(deviceId),
-          hasCharacteristics: deviceCharacteristics.has(deviceId),
-          totalConnectedDevices: connectedDevices.size,
-        });
         await connectDevice(deviceId, webContents);
       }
     );
@@ -1176,9 +1109,6 @@ export function setupNobleBleHandlers(webContents: WebContents): void {
       notificationCallbacks.clear();
       devicePacketStates.clear();
       subscribedDevices.clear();
-
-      // Clear operation states
-      subscriptionOperations.clear();
     });
 
     safeLog(logger, 'info', 'Noble BLE IPC handlers setup completed');