@onekeyfe/hd-transport-electron 1.2.0-alpha.98 → 1.2.0

package/dist/{index-6da32f94.js → index-a518d449.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-ce551d9a.js'); });
+        const { setupNobleBleHandlers } = yield Promise.resolve().then(function () { return require('./noble-ble-handler-56d2eab3.js'); });
         setupNobleBleHandlers(webContents);
     });
 }

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { WebContents } from 'electron';
 import { Characteristic, Peripheral } from '@stoprocent/noble';
 import { OneKeyDeviceInfoBase } from '@onekeyfe/hd-transport';
+import { EBleDisconnectReason } from '@onekeyfe/hd-shared';
 
 interface DeviceInfo extends OneKeyDeviceInfoBase {
     id: string;
@@ -24,6 +25,7 @@ interface NobleModule {
 interface Logger {
     info(message: string, ...args: any[]): void;
     debug(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
     error(message: string, ...args: any[]): void;
 }
 
@@ -31,6 +33,7 @@ interface Logger {
  * Desktop API types for Electron preload script
  * These types define the core interface for Noble BLE communication
  */
+
 interface NobleBleWriteOptions {
     pacingDelayMs?: number;
 }
@@ -55,9 +58,16 @@ interface NobleBleAPI {
         id: string;
         mtu: number;
     }) => void) => () => void;
+    /**
+     * Fires whenever a BLE link drops. `reason` distinguishes a real peripheral
+     * drop from the main process freeing an idle link on its keep-alive timer;
+     * it is optional so an older host bridge that omits it still type-checks
+     * (absent is treated as a real drop by consumers).
+     */
     onDeviceDisconnected: (callback: (device: {
         id: string;
         name: string;
+        reason?: EBleDisconnectReason;
     }) => void) => () => void;
     checkAvailability: () => Promise<{
         available: boolean;

package/dist/index.js

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

package/dist/{noble-ble-handler-ce551d9a.js → noble-ble-handler-56d2eab3.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./index-6da32f94.js');
+var index = require('./index-a518d449.js');
 var hdShared = require('@onekeyfe/hd-shared');
 var pRetry = require('p-retry');
 
@@ -116,7 +116,8 @@ const DEVICE_SCAN_TIMEOUT = 5000;
 const DEVICE_CHECK_INTERVAL = 500;
 const SERVICE_DISCOVERY_TIMEOUT = 10000;
 const BLE_CLEANUP_TIMEOUT = 250;
-const BLE_IDLE_DISCONNECT_MS = 3 * 60000;
+const BLE_DISCONNECT_CONFIRM_TIMEOUT_MS = 3000;
+const BLE_IDLE_DISCONNECT_MS = 20000;
 const BLE_BUSY_BACKSTOP_MS = 10 * 60000;
 const BLE_PACKET_SIZE_FALLBACK = 192;
 const BLE_PACKET_SIZE_MAXIMUM = 244;
@@ -135,7 +136,7 @@ function isOneKeyPeripheral(peripheral) {
     var _a, _b;
     const serviceUuids = (_a = peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.serviceUuids;
     const localName = (_b = peripheral.advertisement) === null || _b === void 0 ? void 0 : _b.localName;
-    if (!(localName === null || localName === void 0 ? void 0 : localName.trim()) || hdShared.isPro2FindMyAdvertisementName(localName)) {
+    if (!(localName === null || localName === void 0 ? void 0 : localName.trim())) {
         return false;
     }
     return (hdShared.hasOnekeyCommunicationService(serviceUuids) &&
@@ -242,6 +243,7 @@ function initializeNoble() {
         try {
             noble = require('@stoprocent/noble');
             logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Noble library loaded');
+            setupPersistentStateListener();
             yield new Promise((resolve, reject) => {
                 if (!noble) {
                     reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Noble not initialized'));
@@ -251,7 +253,6 @@ function initializeNoble() {
                     resolve();
                     return;
                 }
-                setupPersistentStateListener();
                 const timeout = setTimeout(() => {
                     reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Bluetooth initialization timeout'));
                 }, BLUETOOTH_INIT_TIMEOUT);
@@ -336,11 +337,19 @@ function armIdleDisconnect(deviceId, ms = BLE_IDLE_DISCONNECT_MS, reason = 'idle
         logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Keep-alive timeout, disconnecting device', { deviceId, reason });
         const peripheral = connectedDevices.get(deviceId);
         const deviceName = ((_a = peripheral === null || peripheral === void 0 ? void 0 : peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.localName) || 'Unknown Device';
-        const pending = disconnectDevice(deviceId)
+        const pending = unsubscribeNotifications(deviceId)
+            .catch(error => {
+            logger === null || logger === void 0 ? void 0 : logger.warn('[NobleBLE] Keep-alive unsubscribe failed, disconnecting anyway', {
+                deviceId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        })
+            .then(() => disconnectDevice(deviceId))
             .then(() => {
             broadcastToAllWebContents(hdShared.EOneKeyBleMessageKeys.BLE_DEVICE_DISCONNECTED, {
                 id: deviceId,
                 name: deviceName,
+                reason: hdShared.EBleDisconnectReason.IdleKeepAlive,
             });
         })
             .catch(error => {
@@ -356,7 +365,7 @@ function armIdleDisconnect(deviceId, ms = BLE_IDLE_DISCONNECT_MS, reason = 'idle
 }
 function cleanupDevice(deviceId, webContents, options = {}) {
     var _a;
-    const { cleanupConnection = true, cleanupDiscoveredCache = false, sendDisconnectEvent = false, cancelOperations = true, reason = 'unknown', } = options;
+    const { cleanupConnection = true, cleanupDiscoveredCache = false, sendDisconnectEvent = false, cancelOperations = true, reason = 'unknown', disconnectReason = hdShared.EBleDisconnectReason.DeviceDisconnected, } = options;
     logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Starting device cleanup', {
         deviceId,
         reason,
@@ -393,6 +402,7 @@ function cleanupDevice(deviceId, webContents, options = {}) {
         broadcastToAllWebContents(hdShared.EOneKeyBleMessageKeys.BLE_DEVICE_DISCONNECTED, {
             id: deviceId,
             name: deviceName,
+            reason: disconnectReason,
         });
     }
     logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device cleanup completed', { deviceId, reason });
@@ -407,6 +417,7 @@ function handleDeviceDisconnect(deviceId, webContents) {
     });
     cleanupDevice(deviceId, webContents, {
         cleanupConnection: true,
+        cleanupDiscoveredCache: true,
         sendDisconnectEvent: true,
         cancelOperations: true,
         reason: 'auto-disconnect',
@@ -588,18 +599,37 @@ function transmitHexDataToDevice(deviceId, hexData, options) {
         }
     });
 }
+const BLE_COLD_CONNECT_SCAN_TIMEOUT_MS = 1500;
+const SERVICE_DISCOVERY_MAX_ATTEMPTS = 2;
+const bleNamesById = new Map();
+function rememberBleName(deviceId, name) {
+    const trimmed = name === null || name === void 0 ? void 0 : name.trim();
+    if (trimmed) {
+        bleNamesById.set(deviceId, trimmed);
+    }
+}
+function resolveBleName(deviceId) {
+    var _a, _b, _c, _d, _e, _f;
+    const live = ((_c = (_b = (_a = connectedDevices.get(deviceId)) === null || _a === void 0 ? void 0 : _a.advertisement) === null || _b === void 0 ? void 0 : _b.localName) === null || _c === void 0 ? void 0 : _c.trim()) ||
+        ((_f = (_e = (_d = discoveredDevices.get(deviceId)) === null || _d === void 0 ? void 0 : _d.advertisement) === null || _e === void 0 ? void 0 : _e.localName) === null || _f === void 0 ? void 0 : _f.trim());
+    return live || bleNamesById.get(deviceId);
+}
+function shouldConnectByIdFirst(deviceId) {
+    return hdShared.isPro2FamilyBleName(resolveBleName(deviceId));
+}
 function handleDeviceDiscovered(peripheral) {
-    var _a, _b;
+    var _a, _b, _c;
     if (!isOneKeyPeripheral(peripheral)) {
         return;
     }
     const isNewDevice = !discoveredDevices.has(peripheral.id);
     discoveredDevices.set(peripheral.id, peripheral);
+    rememberBleName(peripheral.id, (_a = peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.localName);
     if (isNewDevice) {
         logger === null || logger === void 0 ? void 0 : logger.debug('[NobleBLE] OneKey BLE device discovered', {
             deviceId: peripheral.id,
-            name: ((_a = peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.localName) || 'Unknown Device',
-            serviceUUIDs: ((_b = peripheral.advertisement) === null || _b === void 0 ? void 0 : _b.serviceUuids) || [],
+            name: ((_b = peripheral.advertisement) === null || _b === void 0 ? void 0 : _b.localName) || 'Unknown Device',
+            serviceUUIDs: ((_c = peripheral.advertisement) === null || _c === void 0 ? void 0 : _c.serviceUuids) || [],
         });
     }
 }
@@ -625,7 +655,7 @@ function waitForNobleScanStop(nobleInstance) {
         });
     });
 }
-function performTargetedScan(targetDeviceId) {
+function performTargetedScan(targetDeviceId, timeoutMs = NOBLE_BLE_TARGETED_SCAN_TIMEOUT_MS) {
     return index.__awaiter(this, void 0, void 0, function* () {
         if (!noble) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Noble not available');
@@ -665,9 +695,9 @@ function performTargetedScan(targetDeviceId) {
             const timeoutId = setTimeout(() => {
                 logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Targeted scan timeout for device:', targetDeviceId);
                 finish(null).catch(reject);
-            }, NOBLE_BLE_TARGETED_SCAN_TIMEOUT_MS);
+            }, timeoutMs);
             nobleInstance.on('discover', onDiscover);
-            nobleInstance.startScanning([], false, (error) => {
+            nobleInstance.startScanning([], true, (error) => {
                 if (error) {
                     finish(null, error).catch(reject);
                     return;
@@ -720,7 +750,7 @@ function enumerateDevices() {
                 resolve(devices);
             }), DEVICE_SCAN_TIMEOUT);
             logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Scanning for OneKey BLE devices');
-            nobleInstance.startScanning([], false, (error) => index.__awaiter(this, void 0, void 0, function* () {
+            nobleInstance.startScanning([], true, (error) => index.__awaiter(this, void 0, void 0, function* () {
                 if (error) {
                     yield cleanup();
                     logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Failed to start scanning:', error);
@@ -800,7 +830,7 @@ function discoverServicesAndCharacteristics(peripheral) {
         });
         const discoveryPromise = (() => index.__awaiter(this, void 0, void 0, function* () {
             const services = yield new Promise((resolve, reject) => {
-                peripheral.discoverServices([], (error, svc) => {
+                peripheral.discoverServices(ONEKEY_SERVICE_UUIDS, (error, svc) => {
                     if (error) {
                         logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Service discovery failed:', error);
                         reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleServiceNotFound, error.message));
@@ -811,7 +841,7 @@ function discoverServicesAndCharacteristics(peripheral) {
                 });
             });
             if (!services || services.length === 0) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleServiceNotFound, 'No services found');
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleServiceNotFound, 'No OneKey services found');
             }
             logger === null || logger === void 0 ? void 0 : logger.debug('[NobleBLE] services discovered', {
                 deviceId: peripheral.id,
@@ -928,11 +958,11 @@ function discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId) {
                 deviceId,
                 peripheralState: peripheral.state,
                 attempt: attemptNumber,
-                maxRetries: 5,
+                maxRetries: SERVICE_DISCOVERY_MAX_ATTEMPTS,
                 targetUUIDs: ONEKEY_SERVICE_UUIDS,
             });
             if (attemptNumber > 1) {
-                logger === null || logger === void 0 ? void 0 : logger.info(`[NobleBLE] Service discovery retry attempt ${attemptNumber}/5`);
+                logger === null || logger === void 0 ? void 0 : logger.info(`[NobleBLE] Service discovery retry attempt ${attemptNumber}/${SERVICE_DISCOVERY_MAX_ATTEMPTS}`);
             }
             if (peripheral.state !== 'connected') {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, `Device not connected: ${peripheral.state}`);
@@ -941,16 +971,16 @@ function discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId) {
                 return yield discoverServicesAndCharacteristics(peripheral);
             }
             catch (error) {
-                logger === null || logger === void 0 ? void 0 : logger.error(`[NobleBLE] No services found (attempt ${attemptNumber}/5)`);
-                if (attemptNumber < 5) {
-                    logger === null || logger === void 0 ? void 0 : logger.error(`[NobleBLE] Will retry service discovery (attempt ${attemptNumber + 1}/5)`);
+                logger === null || logger === void 0 ? void 0 : logger.error(`[NobleBLE] No services found (attempt ${attemptNumber}/${SERVICE_DISCOVERY_MAX_ATTEMPTS})`);
+                if (attemptNumber < SERVICE_DISCOVERY_MAX_ATTEMPTS) {
+                    logger === null || logger === void 0 ? void 0 : logger.error(`[NobleBLE] Will retry service discovery (attempt ${attemptNumber + 1}/${SERVICE_DISCOVERY_MAX_ATTEMPTS})`);
                 }
                 throw error;
             }
         }), {
-            retries: 4,
+            retries: SERVICE_DISCOVERY_MAX_ATTEMPTS - 1,
             factor: 1.5,
-            minTimeout: 1000,
+            minTimeout: 500,
             maxTimeout: 3000,
             onFailedAttempt: error => {
                 logger === null || logger === void 0 ? void 0 : logger.error(`[NobleBLE] Service discovery attempt ${error.attemptNumber} failed:`, {
@@ -964,23 +994,24 @@ function discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId) {
 }
 function setupConnectionAndDiscoverServices(peripheral, deviceId, webContents) {
     return index.__awaiter(this, void 0, void 0, function* () {
-        setupDisconnectListener(peripheral, deviceId, webContents);
         try {
-            return yield discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId);
+            yield forceReconnectPeripheral(peripheral, deviceId);
         }
-        catch (initialError) {
-            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Direct service discovery failed, retrying after reconnect', {
-                deviceId,
-                error: initialError,
-            });
+        catch (resetError) {
+            logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Connection reset before discovery failed, continuing', resetError);
         }
-        yield forceReconnectPeripheral(peripheral, deviceId);
         setupDisconnectListener(peripheral, deviceId, webContents);
         try {
             return yield discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId);
         }
-        catch (reconnectError) {
-            logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Service discovery failed after reconnect, attempting fresh scan...', reconnectError);
+        catch (discoveryError) {
+            if (peripheral.state === 'connected') {
+                logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Service discovery failed on a live link, dropping it before the fresh scan', discoveryError);
+                yield disconnectDevice(deviceId).catch(() => undefined);
+            }
+            else {
+                logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Service discovery failed, attempting fresh scan...', discoveryError);
+            }
             return freshScanAndDiscover(deviceId, webContents);
         }
     });
@@ -1040,7 +1071,7 @@ function tryDirectConnectById(deviceId) {
     });
 }
 function connectDevice(deviceId, webContents) {
-    var _a;
+    var _a, _b, _c;
     return index.__awaiter(this, void 0, void 0, function* () {
         logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Connect device request:', {
             deviceId,
@@ -1052,34 +1083,47 @@ function connectDevice(deviceId, webContents) {
         });
         let peripheral = (_a = discoveredDevices.get(deviceId)) !== null && _a !== void 0 ? _a : connectedDevices.get(deviceId);
         if (!peripheral) {
-            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device not discovered, attempting targeted scan for:', deviceId);
             if (!noble) {
                 yield initializeNoble();
             }
             if (!noble) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Noble not available');
             }
-            peripheral = yield tryDirectConnectById(deviceId);
-            if (peripheral) {
-                discoveredDevices.set(deviceId, peripheral);
-            }
-        }
-        if (!peripheral) {
-            try {
-                const foundPeripheral = yield performTargetedScan(deviceId);
-                if (!foundPeripheral) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, `Device ${deviceId} not found even after targeted scan`);
+            const byIdFirst = shouldConnectByIdFirst(deviceId);
+            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Resolving device for cold connect', {
+                deviceId,
+                name: (_b = resolveBleName(deviceId)) !== null && _b !== void 0 ? _b : 'unknown',
+                strategy: byIdFirst ? 'connect-by-id-first' : 'scan-first',
+            });
+            const scanForPeripheral = () => index.__awaiter(this, void 0, void 0, function* () {
+                var _d;
+                try {
+                    return (_d = (yield performTargetedScan(deviceId, BLE_COLD_CONNECT_SCAN_TIMEOUT_MS))) !== null && _d !== void 0 ? _d : undefined;
                 }
-                peripheral = foundPeripheral;
-            }
-            catch (error) {
-                logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Targeted scan failed:', error);
-                throw error;
+                catch (scanError) {
+                    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Targeted scan failed', {
+                        deviceId,
+                        error: scanError instanceof Error ? scanError.message : String(scanError),
+                    });
+                    return undefined;
+                }
+            });
+            const connectById = () => index.__awaiter(this, void 0, void 0, function* () {
+                const found = yield tryDirectConnectById(deviceId);
+                if (found) {
+                    discoveredDevices.set(deviceId, found);
+                }
+                return found;
+            });
+            peripheral = byIdFirst ? yield connectById() : yield scanForPeripheral();
+            if (!peripheral) {
+                peripheral = byIdFirst ? yield scanForPeripheral() : yield connectById();
             }
         }
         if (!peripheral) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, `Device ${deviceId} not found`);
         }
+        rememberBleName(deviceId, (_c = peripheral.advertisement) === null || _c === void 0 ? void 0 : _c.localName);
         logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Connecting to device:', deviceId);
         if (peripheral.state === 'connected') {
             logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device already connected, skipping connection step');
@@ -1154,9 +1198,9 @@ function connectDevice(deviceId, webContents) {
                 }
                 catch (setupError) {
                     logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Connection setup failed:', setupError);
-                    connectedPeripheral.disconnect(() => {
-                        reject(setupError);
-                    });
+                    disconnectDevice(deviceId)
+                        .catch(() => undefined)
+                        .then(() => reject(setupError));
                 }
             }));
         });
@@ -1174,11 +1218,15 @@ function disconnectDevice(deviceId) {
             deviceDisconnectListeners.delete(deviceId);
         }
         yield runBleCallbackOperation(callback => peripheral.disconnect(() => callback()), {
-            timeoutMs: BLE_CLEANUP_TIMEOUT,
+            timeoutMs: BLE_DISCONNECT_CONFIRM_TIMEOUT_MS,
             timeoutBehavior: 'resolve',
         });
+        if (peripheral.state === 'connected') {
+            logger === null || logger === void 0 ? void 0 : logger.warn('[NobleBLE] Physical disconnect did not confirm in time', { deviceId });
+        }
         cleanupDevice(deviceId, undefined, {
             cleanupConnection: true,
+            cleanupDiscoveredCache: true,
             sendDisconnectEvent: false,
             cancelOperations: true,
             reason: 'manual-disconnect',
@@ -1269,9 +1317,14 @@ function subscribeNotifications(deviceId, callback) {
                 });
             });
         }
+        const subscribeStartedAt = Date.now();
         try {
             yield rebuildAppSubscription(deviceId, notifyCharacteristic);
             subscribedDevices.set(deviceId, true);
+            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Notification subscription active', {
+                deviceId,
+                ms: Date.now() - subscribeStartedAt,
+            });
         }
         finally {
             subscriptionOperations.set(deviceId, 'idle');
@@ -1389,10 +1442,6 @@ function setupNobleBleHandlers(webContents) {
                     yield disconnectDevice(deviceId).catch(() => undefined);
                 }
                 yield stopScanning().catch(() => undefined);
-                if (noble && persistentStateListener) {
-                    noble.removeListener('stateChange', persistentStateListener);
-                    persistentStateListener = null;
-                }
                 cleanupNobleListeners();
                 discoveredDevices.clear();
                 safeLog(logger, 'info', 'Noble BLE cleanup 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":"AA+BA,OAAO,KAAK,EAA+B,WAAW,EAAE,MAAM,UAAU,CAAC;AAEzE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AA0EhE,wBAAgB,+BAA+B,CAAC,OAAO,CAAC,EAAE,oBAAoB,UAI7E;AA8lDD,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAgMpE"}
+{"version":3,"file":"noble-ble-handler.d.ts","sourceRoot":"","sources":["../src/noble-ble-handler.ts"],"names":[],"mappings":"AAgCA,OAAO,KAAK,EAA+B,WAAW,EAAE,MAAM,UAAU,CAAC;AAEzE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAoFhE,wBAAgB,+BAA+B,CAAC,OAAO,CAAC,EAAE,oBAAoB,UAI7E;AAsvDD,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAkMpE"}

package/dist/types/desktop-api.d.ts

@@ -1,3 +1,4 @@
+import type { EBleDisconnectReason } from '@onekeyfe/hd-shared';
 export interface NobleBleWriteOptions {
     pacingDelayMs?: number;
 }
@@ -25,6 +26,7 @@ export interface NobleBleAPI {
     onDeviceDisconnected: (callback: (device: {
         id: string;
         name: string;
+        reason?: EBleDisconnectReason;
     }) => void) => () => void;
     checkAvailability: () => Promise<{
         available: boolean;

package/dist/types/desktop-api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"desktop-api.d.ts","sourceRoot":"","sources":["../../src/types/desktop-api.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,oBAAoB;IACnC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,MAAM,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC,CAAC;IACzD,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC,CAAC;IACxF,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAGzC,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACjE,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3C,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACrF,cAAc,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,KAAK,MAAM,IAAI,CAAC;IACnF,YAAY,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,KAAK,MAAM,IAAI,CAAC;IACvF,oBAAoB,EAAE,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,KAAK,MAAM,IAAI,CAAC;IAC/F,iBAAiB,EAAE,MAAM,OAAO,CAAC;QAC/B,SAAS,EAAE,OAAO,CAAC;QACnB,KAAK,EAAE,MAAM,CAAC;QACd,WAAW,EAAE,OAAO,CAAC;QACrB,WAAW,EAAE,OAAO,CAAC;KACtB,CAAC,CAAC;CACJ;AAGD,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,WAAW,CAAC;CACxB"}
+{"version":3,"file":"desktop-api.d.ts","sourceRoot":"","sources":["../../src/types/desktop-api.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAGhE,MAAM,WAAW,oBAAoB;IACnC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,MAAM,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC,CAAC;IACzD,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC,CAAC;IACxF,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAGzC,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACjE,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3C,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACrF,cAAc,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,KAAK,MAAM,IAAI,CAAC;IACnF,YAAY,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,KAAK,MAAM,IAAI,CAAC;IAOvF,oBAAoB,EAAE,CACpB,QAAQ,EAAE,CAAC,MAAM,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,oBAAoB,CAAA;KAAE,KAAK,IAAI,KACpF,MAAM,IAAI,CAAC;IAChB,iBAAiB,EAAE,MAAM,OAAO,CAAC;QAC/B,SAAS,EAAE,OAAO,CAAC;QACnB,KAAK,EAAE,MAAM,CAAC;QACd,WAAW,EAAE,OAAO,CAAC;QACrB,WAAW,EAAE,OAAO,CAAC;KACtB,CAAC,CAAC;CACJ;AAGD,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,WAAW,CAAC;CACxB"}

package/dist/types/noble-extended.d.ts

@@ -22,6 +22,7 @@ export interface NobleModule {
 export interface Logger {
     info(message: string, ...args: any[]): void;
     debug(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
     error(message: string, ...args: any[]): void;
 }
 export declare function safeLog(logger: Logger | null, level: 'info' | 'debug' | 'error', message: string, ...args: any[]): void;

package/dist/types/noble-extended.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"noble-extended.d.ts","sourceRoot":"","sources":["../../src/types/noble-extended.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAGnE,MAAM,WAAW,UAAW,SAAQ,oBAAoB;IACtD,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAGD,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,cAAc,CAAC;IACtB,MAAM,EAAE,cAAc,CAAC;CACxB;AAGD,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,CACX,YAAY,EAAE,MAAM,EAAE,EACtB,eAAe,EAAE,OAAO,EACxB,QAAQ,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,KAAK,IAAI,GACjC,IAAI,CAAC;IACR,YAAY,CAAC,QAAQ,CAAC,EAAE,MAAM,IAAI,GAAG,IAAI,CAAC;IAC1C,EAAE,CAAC,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAAC;IAClE,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI,GAAG,IAAI,CAAC;IACxE,cAAc,CAAC,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAAC;IAC9E,cAAc,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI,GAAG,IAAI,CAAC;CACrF;AAGD,MAAM,WAAW,MAAM;IACrB,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAC5C,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAC7C,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;CAC9C;AAGD,wBAAgB,OAAO,CACrB,MAAM,EAAE,MAAM,GAAG,IAAI,EACrB,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,EACjC,OAAO,EAAE,MAAM,EACf,GAAG,IAAI,EAAE,GAAG,EAAE,GACb,IAAI,CAMN"}
+{"version":3,"file":"noble-extended.d.ts","sourceRoot":"","sources":["../../src/types/noble-extended.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAGnE,MAAM,WAAW,UAAW,SAAQ,oBAAoB;IACtD,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAGD,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,cAAc,CAAC;IACtB,MAAM,EAAE,cAAc,CAAC;CACxB;AAGD,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,CACX,YAAY,EAAE,MAAM,EAAE,EACtB,eAAe,EAAE,OAAO,EACxB,QAAQ,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,KAAK,IAAI,GACjC,IAAI,CAAC;IACR,YAAY,CAAC,QAAQ,CAAC,EAAE,MAAM,IAAI,GAAG,IAAI,CAAC;IAC1C,EAAE,CAAC,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAAC;IAClE,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI,GAAG,IAAI,CAAC;IACxE,cAAc,CAAC,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAAC;IAC9E,cAAc,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI,GAAG,IAAI,CAAC;CACrF;AAGD,MAAM,WAAW,MAAM;IACrB,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAC5C,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAC7C,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAC5C,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;CAC9C;AAGD,wBAAgB,OAAO,CACrB,MAAM,EAAE,MAAM,GAAG,IAAI,EACrB,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,EACjC,OAAO,EAAE,MAAM,EACf,GAAG,IAAI,EAAE,GAAG,EAAE,GACb,IAAI,CAMN"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-electron",
-  "version": "1.2.0-alpha.98",
+  "version": "1.2.0",
   "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.0-alpha.98",
-    "@onekeyfe/hd-shared": "1.2.0-alpha.98",
-    "@onekeyfe/hd-transport": "1.2.0-alpha.98",
+    "@onekeyfe/hd-core": "1.2.0",
+    "@onekeyfe/hd-shared": "1.2.0",
+    "@onekeyfe/hd-transport": "1.2.0",
     "@stoprocent/noble": "2.3.16",
     "p-retry": "^4.6.2"
   },
@@ -36,5 +36,5 @@
     "electron": "^25.0.0",
     "typescript": "^5.3.3"
   },
-  "gitHead": "10f2dcaecec17a629216c2402cc9ab8801987297"
+  "gitHead": "cc51df0a415bead21304ad1d8bc92b5312c91344"
 }

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

@@ -10,12 +10,12 @@ import type { WebContents } from 'electron';
 
 type IpcHandler = (...args: unknown[]) => Promise<unknown> | unknown;
 
-const createPeripheral = (id: string, localName?: string) => ({
+const createPeripheral = (id: string, localName?: string, serviceUuids = ['0001', 'fffd']) => ({
   id,
   state: 'disconnected',
   advertisement: {
     localName,
-    serviceUuids: ['0001', 'fffd'],
+    serviceUuids,
   },
 });
 
@@ -171,6 +171,7 @@ describe('Electron Noble BLE device discovery', () => {
     const connectPromise = Promise.resolve(connect(undefined, 'target-device'));
     await scanStarted;
 
+    expect(noble.startScanning).toHaveBeenCalledWith([], true, expect.any(Function));
     expect(noble.stopScanning).toHaveBeenCalledTimes(1);
     expect(peripheral.connect).not.toHaveBeenCalled();
 
@@ -250,7 +251,7 @@ describe('Electron Noble BLE device discovery', () => {
     expect(peripheral.disconnect).toHaveBeenCalledTimes(1);
   });
 
-  test('does not enumerate a Pro2 Find My advertisement with the communication service', async () => {
+  test('enumerates a Pro2 communication advertisement after Find My changes its name', async () => {
     jest.useFakeTimers({ doNotFake: ['performance'] });
 
     const handlers = new Map<string, IpcHandler>();
@@ -274,8 +275,8 @@ describe('Electron Noble BLE device discovery', () => {
     noble.state = 'poweredOn';
     noble.startScanning = jest.fn((_services, _duplicates, callback) => {
       callback?.();
-      noble.emit('discover', createPeripheral('find-my-device', 'Pro2 A1B2 - Find My'));
-      noble.emit('discover', createPeripheral('onekey-device', 'Pro2 A1B2'));
+      noble.emit('discover', createPeripheral('find-my-device', 'Pro2 A1B2 - Find My', ['fffd']));
+      noble.emit('discover', createPeripheral('onekey-device', 'Pro2 A1B2 - Find My'));
       resolveScanStarted();
     });
     noble.stopScanning = jest.fn(callback => callback?.());
@@ -301,17 +302,18 @@ describe('Electron Noble BLE device discovery', () => {
 
     const devicesPromise = Promise.resolve(enumerate());
     await scanStarted;
+    expect(noble.startScanning).toHaveBeenCalledWith([], true, expect.any(Function));
     jest.advanceTimersByTime(5000);
 
     await expect(devicesPromise).resolves.toEqual([
       expect.objectContaining({
         id: 'onekey-device',
-        name: 'Pro2 A1B2',
+        name: 'Pro2 A1B2 - Find My',
       }),
     ]);
   });
 
-  test('does not enumerate a Find My peripheral first discovered without a name', async () => {
+  test('accepts a communication peripheral after its scan response gains a name', async () => {
     jest.useFakeTimers({ doNotFake: ['performance'] });
 
     const handlers = new Map<string, IpcHandler>();
@@ -368,6 +370,10 @@ describe('Electron Noble BLE device discovery', () => {
     jest.advanceTimersByTime(5000);
 
     await expect(devicesPromise).resolves.toEqual([
+      expect.objectContaining({
+        id: 'find-my-device',
+        name: 'Pro2 A1B2 - Find My',
+      }),
       expect.objectContaining({
         id: 'onekey-device',
         name: 'Pro2 A1B2',

package/src/noble-ble-handler.ts

@@ -6,6 +6,7 @@
 /* eslint-disable @typescript-eslint/no-var-requires, import/no-extraneous-dependencies */
 
 import {
+  EBleDisconnectReason,
   EOneKeyBleMessageKeys,
   ERRORS,
   HardwareErrorCode,
@@ -15,7 +16,7 @@ import {
   createKnownBleUuidAliases,
   hasOnekeyCommunicationService,
   isOnekeyBluetoothDevice,
-  isPro2FindMyAdvertisementName,
+  isPro2FamilyBleName,
   matchesKnownBleUuid,
   wait,
 } from '@onekeyfe/hd-shared';
@@ -90,8 +91,18 @@ const DEVICE_SCAN_TIMEOUT = 5000; // 5 seconds for device scanning
 const DEVICE_CHECK_INTERVAL = 500; // 500ms interval for periodic device checks
 const SERVICE_DISCOVERY_TIMEOUT = 10000; // 10 seconds for service discovery
 const BLE_CLEANUP_TIMEOUT = 250;
+// A physical teardown must actually reach the OS before the device can return
+// to a clean state; 250ms routinely declared success while CoreBluetooth was
+// still disconnecting, leaving no trace when the teardown never completed.
+const BLE_DISCONNECT_CONFIRM_TIMEOUT_MS = 3000;
 // Renderer release is logical only; this timer physically frees the device.
-const BLE_IDLE_DISCONNECT_MS = 3 * 60_000;
+// Keep it SHORT: the Classic 1S goes protocol-deaf when a link is dropped
+// after sitting idle for minutes (field logs 2026-08-19: every deaf window
+// followed a 3-minute-idle disconnect, while disconnects right after traffic
+// have never produced one across 6.5.0's per-call teardown history). A hot
+// disconnect ~20s after the last operation stays inside the proven-safe
+// pattern and also shrinks the window in which phones cannot see the device.
+const BLE_IDLE_DISCONNECT_MS = 20_000;
 // Ceiling while a call is in flight: no outstanding write, but not forever.
 const BLE_BUSY_BACKSTOP_MS = 10 * 60_000;
 
@@ -115,9 +126,7 @@ function isOneKeyPeripheral(peripheral: Peripheral) {
   const serviceUuids = peripheral.advertisement?.serviceUuids;
   const localName = peripheral.advertisement?.localName;
 
-  // Noble localName is the current advertisement name, so reject the Pro2
-  // Find My endpoint before the communication-service fast path accepts it.
-  if (!localName?.trim() || isPro2FindMyAdvertisementName(localName)) {
+  if (!localName?.trim()) {
     return false;
   }
 
@@ -259,6 +268,11 @@ async function initializeNoble(): Promise<void> {
     noble = require('@stoprocent/noble') as NobleModule;
     logger?.info('[NobleBLE] Noble library loaded');
 
+    // Register the process-lifetime state listener before any early return:
+    // the poweredOn fast path below would otherwise skip it for the whole
+    // session, leaving poweredOff cache/state reconciliation dead.
+    setupPersistentStateListener();
+
     // Wait for Bluetooth to be ready
     await new Promise<void>((resolve, reject) => {
       if (!noble) {
@@ -271,9 +285,6 @@ async function initializeNoble(): Promise<void> {
         return;
       }
 
-      // Setup persistent state listener before initialization
-      setupPersistentStateListener();
-
       const timeout = setTimeout(() => {
         reject(
           ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Bluetooth initialization timeout')
@@ -339,6 +350,12 @@ interface DeviceCleanupOptions {
   cleanupDiscoveredCache?: boolean;
   /** Whether to send disconnect event */
   sendDisconnectEvent?: boolean;
+  /**
+   * Why the link went down, forwarded to renderers on BLE_DEVICE_DISCONNECTED.
+   * Defaults to a real peripheral drop; the keep-alive path overrides it so
+   * consumers can tell an internal idle release from a device that left.
+   */
+  disconnectReason?: EBleDisconnectReason;
   /** Whether to cancel ongoing operations */
   cancelOperations?: boolean;
   /** Cleanup reason (for logging) */
@@ -394,12 +411,31 @@ function armIdleDisconnect(
       logger?.info('[NobleBLE] Keep-alive timeout, disconnecting device', { deviceId, reason });
       const peripheral = connectedDevices.get(deviceId);
       const deviceName = peripheral?.advertisement?.localName || 'Unknown Device';
-      const pending = disconnectDevice(deviceId)
+      // Unsubscribe CCCD before dropping the link, matching every other
+      // teardown path: the 1S leaves its notify session half-open when the
+      // link drops without an unsubscribe and then ignores application
+      // protocol traffic on NEW links for tens of minutes (field log
+      // 2026-08-19: the lone unsubscribe-skipping idle teardown caused a
+      // 6-attempt reconnect loop; unsubscribe-first teardowns reconnected
+      // instantly).
+      const pending = unsubscribeNotifications(deviceId)
+        .catch(error => {
+          logger?.warn('[NobleBLE] Keep-alive unsubscribe failed, disconnecting anyway', {
+            deviceId,
+            error: error instanceof Error ? error.message : String(error),
+          });
+        })
+        .then(() => disconnectDevice(deviceId))
         .then(() => {
           // A call is still in flight here; it must reject, not hang.
+          // Both 'idle' and 'busy-backstop' report IdleKeepAlive on purpose:
+          // we reclaimed the link ourselves and have no evidence the device
+          // left, so consumers must not mark it disconnected. The in-flight
+          // call still fails, via the renderer dropping its device state.
           broadcastToAllWebContents(EOneKeyBleMessageKeys.BLE_DEVICE_DISCONNECTED, {
             id: deviceId,
             name: deviceName,
+            reason: EBleDisconnectReason.IdleKeepAlive,
           });
         })
         .catch(error => {
@@ -429,6 +465,7 @@ function cleanupDevice(
     sendDisconnectEvent = false,
     cancelOperations = true,
     reason = 'unknown',
+    disconnectReason = EBleDisconnectReason.DeviceDisconnected,
   } = options;
 
   logger?.info('[NobleBLE] Starting device cleanup', {
@@ -478,6 +515,7 @@ function cleanupDevice(
     broadcastToAllWebContents(EOneKeyBleMessageKeys.BLE_DEVICE_DISCONNECTED, {
       id: deviceId,
       name: deviceName,
+      reason: disconnectReason,
     });
   }
 
@@ -497,6 +535,9 @@ function handleDeviceDisconnect(deviceId: string, webContents: WebContents): voi
 
   cleanupDevice(deviceId, webContents, {
     cleanupConnection: true,
+    // Same stale-object hazard as manual disconnect: an externally dropped
+    // link invalidates the cached peripheral for the next reconnect.
+    cleanupDiscoveredCache: true,
     sendDisconnectEvent: true,
     cancelOperations: true,
     reason: 'auto-disconnect',
@@ -750,6 +791,44 @@ async function transmitHexDataToDevice(
 }
 
 // Handle discovered device (for general enumeration only)
+// A scan that finds nothing costs this much before the direct-connect
+// fallback runs. Every advertisement in the 6.5.0 control logs arrived within
+// 631ms, so this leaves ~2x headroom while keeping a miss cheap.
+const BLE_COLD_CONNECT_SCAN_TIMEOUT_MS = 1500;
+
+// Attempts before a link is written off as unable to serve the OneKey service.
+const SERVICE_DISCOVERY_MAX_ATTEMPTS = 2;
+
+// Advertised names, kept for the life of the process: device caches are purged
+// on every disconnect, but the family a device belongs to never changes and
+// decides which connection strategy is safe for it.
+const bleNamesById = new Map<string, string>();
+
+function rememberBleName(deviceId: string, name?: string | null): void {
+  const trimmed = name?.trim();
+  if (trimmed) {
+    bleNamesById.set(deviceId, trimmed);
+  }
+}
+
+function resolveBleName(deviceId: string): string | undefined {
+  const live =
+    connectedDevices.get(deviceId)?.advertisement?.localName?.trim() ||
+    discoveredDevices.get(deviceId)?.advertisement?.localName?.trim();
+  return live || bleNamesById.get(deviceId);
+}
+
+/**
+ * Pro2/Neo connect by id first: they are unaffected by the stale-session
+ * problem and advertise under Find My names a OneKey-filtered scan cannot
+ * match. Everything else — Classic family, and any device whose name is not
+ * known yet — scans first, because connecting by id can resolve a session the
+ * device no longer serves (see setupConnectionAndDiscoverServices).
+ */
+function shouldConnectByIdFirst(deviceId: string): boolean {
+  return isPro2FamilyBleName(resolveBleName(deviceId));
+}
+
 function handleDeviceDiscovered(peripheral: Peripheral): void {
   // Only process OneKey candidates for general discovery. Avoid logging every
   // ambient BLE peripheral; it makes Pro2 debugging hard to read.
@@ -759,6 +838,7 @@ function handleDeviceDiscovered(peripheral: Peripheral): void {
 
   const isNewDevice = !discoveredDevices.has(peripheral.id);
   discoveredDevices.set(peripheral.id, peripheral);
+  rememberBleName(peripheral.id, peripheral.advertisement?.localName);
   if (isNewDevice) {
     logger?.debug('[NobleBLE] OneKey BLE device discovered', {
       deviceId: peripheral.id,
@@ -793,7 +873,10 @@ async function waitForNobleScanStop(nobleInstance: NobleModule): Promise<void> {
 
 // Perform targeted scan for a specific device ID
 // Uses self-contained local listener pattern - no global state needed
-async function performTargetedScan(targetDeviceId: string): Promise<Peripheral | null> {
+async function performTargetedScan(
+  targetDeviceId: string,
+  timeoutMs: number = NOBLE_BLE_TARGETED_SCAN_TIMEOUT_MS
+): Promise<Peripheral | null> {
   if (!noble) {
     throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Noble not available');
   }
@@ -838,13 +921,14 @@ async function performTargetedScan(targetDeviceId: string): Promise<Peripheral |
     const timeoutId = setTimeout(() => {
       logger?.info('[NobleBLE] Targeted scan timeout for device:', targetDeviceId);
       finish(null).catch(reject);
-    }, NOBLE_BLE_TARGETED_SCAN_TIMEOUT_MS);
+    }, timeoutMs);
 
     // Add local listener for this scan
     nobleInstance.on('discover', onDiscover);
 
-    // Start scanning — no service UUID filter (Pro2 may use different service UUID)
-    nobleInstance.startScanning([], false, (error?: Error) => {
+    // Allow repeated advertisements so a service-only packet can be followed by
+    // the named scan response needed to validate the target peripheral.
+    nobleInstance.startScanning([], true, (error?: Error) => {
       if (error) {
         finish(null, error).catch(reject);
         return;
@@ -915,9 +999,10 @@ async function enumerateDevices(): Promise<DeviceInfo[]> {
     }, DEVICE_SCAN_TIMEOUT);
 
     // Start scanning without a service UUID filter so Pro2 advertisements with
-    // short vendor UUIDs can be found, but only OneKey candidates are logged/returned.
+    // short vendor UUIDs can be found. Repeated advertisements are required when
+    // the local name arrives in a later scan response; discoveredDevices handles deduplication.
     logger?.info('[NobleBLE] Scanning for OneKey BLE devices');
-    nobleInstance.startScanning([], false, async (error?: Error) => {
+    nobleInstance.startScanning([], true, async (error?: Error) => {
       if (error) {
         await cleanup();
         logger?.error('[NobleBLE] Failed to start scanning:', error);
@@ -1038,9 +1123,17 @@ async function discoverServicesAndCharacteristics(
 
   // Main discovery logic as async function
   const discoveryPromise = (async (): Promise<CharacteristicPair> => {
-    // Step 1: Discover ALL services (no filter — Pro2 may use different service UUID)
+    // Step 1: Discover the OneKey service by UUID. Filtering is not just a
+    // narrowing: an unfiltered discovery is answered from the OS GATT cache, so
+    // a device whose stack still advertises and accepts links but no longer
+    // serves its application layer still looks healthy — the link comes up, the
+    // cached services resolve, the protocol frame goes out and nothing ever
+    // answers. A targeted query returns nothing in that state, which is what
+    // 6.5.0 relied on to trip the recovery path below (retry, reset, fresh
+    // scan) — the sequence that brings such a device back. Pro2/Neo expose the
+    // same service UUID, and the selection below only ever accepts that one.
     const services = await new Promise<Service[]>((resolve, reject) => {
-      peripheral.discoverServices([], (error, svc) => {
+      peripheral.discoverServices(ONEKEY_SERVICE_UUIDS, (error, svc) => {
         if (error) {
           logger?.error('[NobleBLE] Service discovery failed:', error);
           reject(ERRORS.TypedError(HardwareErrorCode.BleServiceNotFound, error.message));
@@ -1051,7 +1144,7 @@ async function discoverServicesAndCharacteristics(
     });
 
     if (!services || services.length === 0) {
-      throw ERRORS.TypedError(HardwareErrorCode.BleServiceNotFound, 'No services found');
+      throw ERRORS.TypedError(HardwareErrorCode.BleServiceNotFound, 'No OneKey services found');
     }
 
     logger?.debug('[NobleBLE] services discovered', {
@@ -1235,12 +1328,14 @@ async function discoverServicesAndCharacteristicsWithRetry(
         deviceId,
         peripheralState: peripheral.state,
         attempt: attemptNumber,
-        maxRetries: 5,
+        maxRetries: SERVICE_DISCOVERY_MAX_ATTEMPTS,
         targetUUIDs: ONEKEY_SERVICE_UUIDS,
       });
 
       if (attemptNumber > 1) {
-        logger?.info(`[NobleBLE] Service discovery retry attempt ${attemptNumber}/5`);
+        logger?.info(
+          `[NobleBLE] Service discovery retry attempt ${attemptNumber}/${SERVICE_DISCOVERY_MAX_ATTEMPTS}`
+        );
       }
 
       // Verify connection state before attempting service discovery
@@ -1254,20 +1349,32 @@ async function discoverServicesAndCharacteristicsWithRetry(
       try {
         return await discoverServicesAndCharacteristics(peripheral);
       } catch (error) {
-        logger?.error(`[NobleBLE] No services found (attempt ${attemptNumber}/5)`);
+        logger?.error(
+          `[NobleBLE] No services found (attempt ${attemptNumber}/${SERVICE_DISCOVERY_MAX_ATTEMPTS})`
+        );
 
-        if (attemptNumber < 5) {
-          logger?.error(`[NobleBLE] Will retry service discovery (attempt ${attemptNumber + 1}/5)`);
+        if (attemptNumber < SERVICE_DISCOVERY_MAX_ATTEMPTS) {
+          logger?.error(
+            `[NobleBLE] Will retry service discovery (attempt ${
+              attemptNumber + 1
+            }/${SERVICE_DISCOVERY_MAX_ATTEMPTS})`
+          );
         }
 
         throw error; // p-retry will handle the retry logic
       }
     },
     {
-      retries: 4, // Total 5 attempts (initial + 4 retries)
-      factor: 1.5, // Exponential backoff: 1000ms → 1500ms → 2250ms → 3000ms
-      minTimeout: 1000, // Start with 1 second delay
-      maxTimeout: 3000, // Maximum 3 seconds delay
+      // One retry, not four. An empty result here is the signature of a device
+      // whose stack no longer serves its application layer, and retrying the
+      // same link has never recovered it — every observed run failed all the
+      // way through. The recovery is the teardown and cold reconnect the caller
+      // performs afterwards, so reaching it sooner is what shortens the wait.
+      // The single retry stays for a genuinely transient miss.
+      retries: SERVICE_DISCOVERY_MAX_ATTEMPTS - 1,
+      factor: 1.5,
+      minTimeout: 500,
+      maxTimeout: 3000,
       onFailedAttempt: error => {
         // This runs after each failed attempt
         logger?.error(`[NobleBLE] Service discovery attempt ${error.attemptNumber} failed:`, {
@@ -1292,26 +1399,45 @@ async function setupConnectionAndDiscoverServices(
   deviceId: string,
   webContents: WebContents
 ): Promise<CharacteristicPair> {
-  setupDisconnectListener(peripheral, deviceId, webContents);
-
+  // Reset the link before any protocol traffic reaches the device. 6.5.0 did
+  // this on every cold setup and never produced a protocol-deaf Classic 1S
+  // (control log 2026-08-20: 16/16 links answered within ~1s, including after
+  // a 15-minute idle). Demoting it to a discovery-failure fallback removed the
+  // reset entirely for this device, because discovery always succeeds: the link
+  // comes up, GATT resolves from cache, and the device then answers nothing on
+  // a session it no longer serves. Costs ~1.3s per cold setup; a kept-alive
+  // link with an intact subscription returns before reaching here, so reuse
+  // inside a workflow is unaffected.
   try {
-    return await discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId);
-  } catch (initialError) {
-    logger?.info('[NobleBLE] Direct service discovery failed, retrying after reconnect', {
-      deviceId,
-      error: initialError,
-    });
+    await forceReconnectPeripheral(peripheral, deviceId);
+  } catch (resetError) {
+    // A failed reset must not abort the attempt: discovery on the existing
+    // link, then the fresh-scan fallback, still have a chance to recover.
+    logger?.error('[NobleBLE] Connection reset before discovery failed, continuing', resetError);
   }
-
-  await forceReconnectPeripheral(peripheral, deviceId);
   setupDisconnectListener(peripheral, deviceId, webContents);
+
   try {
     return await discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId);
-  } catch (reconnectError) {
-    logger?.error(
-      '[NobleBLE] Service discovery failed after reconnect, attempting fresh scan...',
-      reconnectError
-    );
+  } catch (discoveryError) {
+    // A connected peripheral does not advertise, so the fresh scan below would
+    // only run out its timeout. Drop the link first, then rescan: the cold
+    // reconnect is what recovers a device whose stack stopped serving its
+    // application layer. Recover here rather than throwing to the caller —
+    // one acquire pays ~2s for the rescan, while a thrown error costs the
+    // renderer a full retry round trip.
+    if (peripheral.state === 'connected') {
+      logger?.error(
+        '[NobleBLE] Service discovery failed on a live link, dropping it before the fresh scan',
+        discoveryError
+      );
+      await disconnectDevice(deviceId).catch(() => undefined);
+    } else {
+      logger?.error(
+        '[NobleBLE] Service discovery failed, attempting fresh scan...',
+        discoveryError
+      );
+    }
     return freshScanAndDiscover(deviceId, webContents);
   }
 }
@@ -1400,10 +1526,7 @@ async function connectDevice(deviceId: string, webContents: WebContents): Promis
   // enumerate clears the discovery map; a kept-alive link outlives it.
   let peripheral = discoveredDevices.get(deviceId) ?? connectedDevices.get(deviceId);
 
-  // If device not discovered, try a targeted scan for this specific device
   if (!peripheral) {
-    logger?.info('[NobleBLE] Device not discovered, attempting targeted scan for:', deviceId);
-
     // Initialize Noble if not already done
     if (!noble) {
       await initializeNoble();
@@ -1413,27 +1536,46 @@ async function connectDevice(deviceId: string, webContents: WebContents): Promis
       throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Noble not available');
     }
 
-    // Reaches a bonded device that is not advertising; else falls to the scan.
-    peripheral = await tryDirectConnectById(deviceId);
-    if (peripheral) {
-      discoveredDevices.set(deviceId, peripheral);
-    }
-  }
+    // A live advertisement proves the device holds no link and will open a
+    // fresh session; connecting by id resolves through the OS cache instead
+    // and can hand back a session the device no longer serves (see
+    // setupConnectionAndDiscoverServices). Scanning is also the faster of the
+    // two when the device does advertise: ~96ms median against ~784ms for
+    // connect-by-id across the field logs. Pro2/Neo keep connect-by-id first
+    // because they are unaffected and may advertise under an unmatchable Find
+    // My name.
+    const byIdFirst = shouldConnectByIdFirst(deviceId);
+    logger?.info('[NobleBLE] Resolving device for cold connect', {
+      deviceId,
+      name: resolveBleName(deviceId) ?? 'unknown',
+      strategy: byIdFirst ? 'connect-by-id-first' : 'scan-first',
+    });
 
-  if (!peripheral) {
-    // Perform a targeted scan to find the specific device
-    try {
-      const foundPeripheral = await performTargetedScan(deviceId);
-      if (!foundPeripheral) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.DeviceNotFound,
-          `Device ${deviceId} not found even after targeted scan`
-        );
+    const scanForPeripheral = async () => {
+      try {
+        return (await performTargetedScan(deviceId, BLE_COLD_CONNECT_SCAN_TIMEOUT_MS)) ?? undefined;
+      } catch (scanError) {
+        logger?.info('[NobleBLE] Targeted scan failed', {
+          deviceId,
+          error: scanError instanceof Error ? scanError.message : String(scanError),
+        });
+        return undefined;
+      }
+    };
+
+    const connectById = async () => {
+      const found = await tryDirectConnectById(deviceId);
+      if (found) {
+        discoveredDevices.set(deviceId, found);
       }
-      peripheral = foundPeripheral;
-    } catch (error) {
-      logger?.error('[NobleBLE] Targeted scan failed:', error);
-      throw error;
+      return found;
+    };
+
+    peripheral = byIdFirst ? await connectById() : await scanForPeripheral();
+    if (!peripheral) {
+      // The preferred route came up empty: not advertising (held elsewhere, or
+      // silent), or not reachable by id. Try the other one before giving up.
+      peripheral = byIdFirst ? await scanForPeripheral() : await connectById();
     }
   }
 
@@ -1442,6 +1584,10 @@ async function connectDevice(deviceId: string, webContents: WebContents): Promis
     throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound, `Device ${deviceId} not found`);
   }
 
+  // Also covers the connect-by-id route, whose simulated discovery carries no
+  // service UUIDs and therefore never reaches handleDeviceDiscovered.
+  rememberBleName(deviceId, peripheral.advertisement?.localName);
+
   logger?.info('[NobleBLE] Connecting to device:', deviceId);
 
   // Check if device is already connected
@@ -1562,9 +1708,14 @@ async function connectDevice(deviceId: string, webContents: WebContents): Promis
         resolve();
       } catch (setupError) {
         logger?.error('[NobleBLE] Connection setup failed:', setupError);
-        connectedPeripheral.disconnect(() => {
-          reject(setupError);
-        });
+        // Never reject from inside a raw disconnect callback: noble only fires
+        // it on a real 'disconnect' event, so a peripheral that is already
+        // down leaves this promise — and the renderer acquire awaiting it —
+        // pending forever. disconnectDevice always settles (it no-ops on an
+        // unknown peripheral and caps the confirm wait).
+        disconnectDevice(deviceId)
+          .catch(() => undefined)
+          .then(() => reject(setupError));
       }
     });
   });
@@ -1584,11 +1735,18 @@ async function disconnectDevice(deviceId: string): Promise<void> {
   }
 
   await runBleCallbackOperation(callback => peripheral.disconnect(() => callback()), {
-    timeoutMs: BLE_CLEANUP_TIMEOUT,
+    timeoutMs: BLE_DISCONNECT_CONFIRM_TIMEOUT_MS,
     timeoutBehavior: 'resolve',
   });
+  if (peripheral.state === 'connected') {
+    logger?.warn('[NobleBLE] Physical disconnect did not confirm in time', { deviceId });
+  }
   cleanupDevice(deviceId, undefined, {
     cleanupConnection: true,
+    // macOS returns zero GATT services when a previously-disconnected
+    // peripheral object is reconnected; drop the discovery cache so the next
+    // connect resolves a fresh peripheral (direct connect by id, or scan).
+    cleanupDiscoveredCache: true,
     sendDisconnectEvent: false,
     cancelOperations: true,
     reason: 'manual-disconnect',
@@ -1729,9 +1887,14 @@ async function subscribeNotifications(
     });
   }
 
+  const subscribeStartedAt = Date.now();
   try {
     await rebuildAppSubscription(deviceId, notifyCharacteristic);
     subscribedDevices.set(deviceId, true);
+    logger?.info('[NobleBLE] Notification subscription active', {
+      deviceId,
+      ms: Date.now() - subscribeStartedAt,
+    });
   } finally {
     // 🔒 CRITICAL: Always clear operation state (even on error)
     subscriptionOperations.set(deviceId, 'idle');
@@ -1914,10 +2077,12 @@ export function setupNobleBleHandlers(webContents: WebContents): void {
         }
 
         await stopScanning().catch(() => undefined);
-        if (noble && persistentStateListener) {
-          noble.removeListener('stateChange', persistentStateListener);
-          persistentStateListener = null;
-        }
+        // persistentStateListener is process-lifetime, NOT per-window: this
+        // destroy handler also fires on a renderer soft restart, and removing
+        // the listener here permanently killed poweredOff/poweredOn
+        // reconciliation for the rest of the process (nothing re-registers it:
+        // initializeNoble early-returns once noble is loaded). The null-guard
+        // in setupPersistentStateListener keeps it deduped to one instance.
         cleanupNobleListeners();
         discoveredDevices.clear();
         safeLog(logger, 'info', 'Noble BLE cleanup completed');

package/src/types/desktop-api.ts

@@ -3,6 +3,8 @@
  * These types define the core interface for Noble BLE communication
  */
 
+import type { EBleDisconnectReason } from '@onekeyfe/hd-shared';
+
 // Noble BLE API interface - core BLE functionality
 export interface NobleBleWriteOptions {
   pacingDelayMs?: number;
@@ -21,7 +23,15 @@ export interface NobleBleAPI {
   write: (uuid: string, data: string, options?: NobleBleWriteOptions) => Promise<void>;
   onNotification: (callback: (deviceId: string, data: string) => void) => () => void;
   onMtuChanged?: (callback: (device: { id: string; mtu: number }) => void) => () => void;
-  onDeviceDisconnected: (callback: (device: { id: string; name: string }) => void) => () => void;
+  /**
+   * Fires whenever a BLE link drops. `reason` distinguishes a real peripheral
+   * drop from the main process freeing an idle link on its keep-alive timer;
+   * it is optional so an older host bridge that omits it still type-checks
+   * (absent is treated as a real drop by consumers).
+   */
+  onDeviceDisconnected: (
+    callback: (device: { id: string; name: string; reason?: EBleDisconnectReason }) => void
+  ) => () => void;
   checkAvailability: () => Promise<{
     available: boolean;
     state: string;

package/src/types/noble-extended.ts

@@ -39,6 +39,7 @@ export interface NobleModule {
 export interface Logger {
   info(message: string, ...args: any[]): void;
   debug(message: string, ...args: any[]): void;
+  warn(message: string, ...args: any[]): void;
   error(message: string, ...args: any[]): void;
 }