@onekeyfe/hd-transport-electron 1.1.34-alpha.0 → 1.1.34-alpha.2

package/dist/{index-de36348d.js → index-b69f3b16.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-2e41f27c.js'); });
+        const { setupNobleBleHandlers } = yield Promise.resolve().then(function () { return require('./noble-ble-handler-4423b8bd.js'); });
         setupNobleBleHandlers(webContents);
     });
 }

package/dist/index.d.ts

@@ -17,6 +17,7 @@ interface NobleModule {
     stopScanning(callback?: () => void): void;
     on(event: 'stateChange', listener: (state: string) => void): void;
     on(event: 'discover', listener: (peripheral: Peripheral) => void): void;
+    connectAsync?(idOrAddress: string): Promise<Peripheral | undefined>;
     removeListener(event: 'stateChange', listener: (state: string) => void): void;
     removeListener(event: 'discover', listener: (peripheral: Peripheral) => void): void;
 }
@@ -36,6 +37,7 @@ interface NobleBleAPI {
         name: string;
     } | null>;
     connect: (uuid: string) => Promise<void>;
+    release?: (uuid: string) => Promise<void>;
     disconnect: (uuid: string) => Promise<void>;
     subscribe: (uuid: string) => Promise<void>;
     unsubscribe: (uuid: string) => Promise<void>;

package/dist/index.js

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

package/dist/{noble-ble-handler-2e41f27c.js → noble-ble-handler-4423b8bd.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./index-de36348d.js');
+var index = require('./index-b69f3b16.js');
 var hdShared = require('@onekeyfe/hd-shared');
 var hdTransport = require('@onekeyfe/hd-transport');
 var pRetry = require('p-retry');
@@ -78,6 +78,10 @@ const subscribedDevices = new Map();
 const subscriptionOperations = new Map();
 const devicePacketStates = new Map();
 const ONEKEY_SERVICE_UUIDS = [hdShared.ONEKEY_SERVICE_UUID];
+const uuid16Key = (uuid) => {
+    const stripped = (uuid !== null && uuid !== void 0 ? uuid : '').replace(/-/g, '').toLowerCase();
+    return stripped.length >= 8 ? stripped.substring(4, 8) : stripped;
+};
 const NORMALIZED_WRITE_UUID = '0002';
 const NORMALIZED_NOTIFY_UUID = '0003';
 const BLUETOOTH_INIT_TIMEOUT = 10000;
@@ -85,6 +89,9 @@ const DEVICE_SCAN_TIMEOUT = 5000;
 const FAST_SCAN_TIMEOUT = 1500;
 const DEVICE_CHECK_INTERVAL = 500;
 const CONNECTION_TIMEOUT = 3000;
+const BLE_IDLE_DISCONNECT_MS = 60000;
+const BLE_DISCONNECT_TIMEOUT_MS = 2000;
+const BLE_BUSY_BACKSTOP_MS = 10 * 60000;
 const SERVICE_DISCOVERY_TIMEOUT = 10000;
 const BLE_PACKET_SIZE = 192;
 const UNIFIED_WRITE_DELAY = 5;
@@ -244,6 +251,48 @@ function updateBluetoothState(state) {
         bluetoothState.initialized = true;
     }
 }
+const idleDisconnectTimers = new Map();
+function clearIdleDisconnect(deviceId) {
+    const timer = idleDisconnectTimers.get(deviceId);
+    if (timer) {
+        clearTimeout(timer);
+        idleDisconnectTimers.delete(deviceId);
+    }
+}
+function armIdleDisconnect(deviceId, ms = BLE_IDLE_DISCONNECT_MS, reason = 'idle') {
+    clearIdleDisconnect(deviceId);
+    idleDisconnectTimers.set(deviceId, setTimeout(() => {
+        var _a;
+        idleDisconnectTimers.delete(deviceId);
+        if (!connectedDevices.has(deviceId))
+            return;
+        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';
+        disconnectDevice(deviceId)
+            .then(() => {
+            broadcastToAllWebContents(hdShared.EOneKeyBleMessageKeys.BLE_DEVICE_DISCONNECTED, {
+                id: deviceId,
+                name: deviceName,
+            });
+        })
+            .catch(error => {
+            logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Keep-alive disconnect failed:', error);
+        });
+    }, ms));
+}
+function broadcastToAllWebContents(channel, payload) {
+    try {
+        const { webContents: electronWebContents } = require('electron');
+        for (const wc of electronWebContents.getAllWebContents()) {
+            if (!wc.isDestroyed())
+                wc.send(channel, payload);
+        }
+    }
+    catch (error) {
+        logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] broadcast failed:', { channel, error: String(error) });
+    }
+}
 function initializeNoble() {
     return index.__awaiter(this, void 0, void 0, function* () {
         if (noble)
@@ -315,6 +364,7 @@ function cleanupDevice(deviceId, webContents, options = {}) {
         sendDisconnectEvent,
         cancelOperations,
     });
+    clearIdleDisconnect(deviceId);
     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';
     if (cleanupConnection) {
@@ -457,6 +507,7 @@ function transmitHexDataToDevice(deviceId, hexData) {
         if (!peripheral || !characteristics) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleCharacteristicNotFound, `Device ${deviceId} not connected or characteristics not available`);
         }
+        armIdleDisconnect(deviceId, BLE_BUSY_BACKSTOP_MS, 'busy-backstop');
         const toBuffer = Buffer.from(hexData, 'hex');
         logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Writing data:', {
             deviceId,
@@ -706,7 +757,7 @@ function discoverServicesAndCharacteristics(peripheral) {
         });
         const discoveryPromise = (() => index.__awaiter(this, void 0, void 0, function* () {
             const services = yield new Promise((resolve, reject) => {
-                peripheral.discoverServices(ONEKEY_SERVICE_UUIDS, (error, svc) => {
+                peripheral.discoverServices([], (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));
@@ -719,10 +770,14 @@ function discoverServicesAndCharacteristics(peripheral) {
             if (!services || services.length === 0) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleServiceNotFound, 'No OneKey services found');
             }
-            const service = services[0];
+            const wanted = ONEKEY_SERVICE_UUIDS.map(uuid16Key);
+            const service = services.find(svc => wanted.includes(uuid16Key(svc.uuid)));
+            if (!service) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleServiceNotFound, `No OneKey service in result set: ${services.map(svc => svc.uuid).join('|')}`);
+            }
             logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Found service:', service.uuid);
             const characteristics = yield new Promise((resolve, reject) => {
-                service.discoverCharacteristics([hdShared.ONEKEY_WRITE_CHARACTERISTIC_UUID, hdShared.ONEKEY_NOTIFY_CHARACTERISTIC_UUID], (error, chars) => {
+                service.discoverCharacteristics([], (error, chars) => {
                     if (error) {
                         logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Characteristic discovery failed:', error);
                         reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleCharacteristicNotFound, error.message));
@@ -801,8 +856,21 @@ function forceReconnectPeripheral(peripheral, deviceId) {
     });
 }
 function freshScanAndDiscover(deviceId, webContents) {
+    var _a;
     return index.__awaiter(this, void 0, void 0, function* () {
         logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Performing fresh scan to get new peripheral object for device:', deviceId);
+        const stalePeripheral = (_a = connectedDevices.get(deviceId)) !== null && _a !== void 0 ? _a : discoveredDevices.get(deviceId);
+        if (stalePeripheral && stalePeripheral.state === 'connected') {
+            stalePeripheral.removeAllListeners('disconnect');
+            yield new Promise(resolve => {
+                const timer = setTimeout(resolve, BLE_DISCONNECT_TIMEOUT_MS);
+                stalePeripheral.disconnect(() => {
+                    clearTimeout(timer);
+                    resolve();
+                });
+            });
+            connectedDevices.delete(deviceId);
+        }
         const freshPeripheral = yield performTargetedScan(deviceId);
         if (!freshPeripheral) {
             discoveredDevices.delete(deviceId);
@@ -827,7 +895,13 @@ function freshScanAndDiscover(deviceId, webContents) {
         setupDisconnectListener(freshPeripheral, deviceId, webContents);
         yield hdShared.wait(500);
         logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Attempting service discovery with fresh peripheral');
-        return discoverServicesAndCharacteristics(freshPeripheral);
+        try {
+            return yield discoverServicesAndCharacteristics(freshPeripheral);
+        }
+        catch (error) {
+            yield disconnectDevice(deviceId).catch(() => undefined);
+            throw error;
+        }
     });
 }
 function discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId) {
@@ -873,10 +947,22 @@ function discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId) {
 }
 function setupConnectionAndDiscoverServices(peripheral, deviceId, webContents) {
     return index.__awaiter(this, void 0, void 0, function* () {
-        yield forceReconnectPeripheral(peripheral, deviceId);
         setupDisconnectListener(peripheral, deviceId, webContents);
+        if (peripheral.state === 'connected') {
+            try {
+                const result = yield discoverServicesAndCharacteristics(peripheral);
+                connectedDevices.set(deviceId, peripheral);
+                return result;
+            }
+            catch (directError) {
+                logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Direct discovery miss, escalating:', String(directError));
+            }
+        }
         try {
-            return yield discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId);
+            yield forceReconnectPeripheral(peripheral, deviceId);
+            setupDisconnectListener(peripheral, deviceId, webContents);
+            const result = yield discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId);
+            return result;
         }
         catch (error) {
             logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Service discovery failed, attempting fresh scan...', error);
@@ -884,6 +970,51 @@ function setupConnectionAndDiscoverServices(peripheral, deviceId, webContents) {
         }
     });
 }
+const DIRECT_CONNECT_TIMEOUT_MS = 2000;
+const DIRECT_CONNECT_COOLDOWN_MS = 15000;
+const directConnectCooldownUntil = new Map();
+function tryDirectConnectById(deviceId) {
+    var _a;
+    return index.__awaiter(this, void 0, void 0, function* () {
+        if (!noble || typeof noble.connectAsync !== 'function')
+            return undefined;
+        if (((_a = directConnectCooldownUntil.get(deviceId)) !== null && _a !== void 0 ? _a : 0) > Date.now()) {
+            return undefined;
+        }
+        try {
+            const directPromise = noble.connectAsync(deviceId);
+            const raced = yield Promise.race([
+                directPromise,
+                new Promise(resolve => {
+                    setTimeout(() => resolve('timeout'), DIRECT_CONNECT_TIMEOUT_MS);
+                }),
+            ]);
+            if (raced === 'timeout') {
+                directConnectCooldownUntil.set(deviceId, Date.now() + DIRECT_CONNECT_COOLDOWN_MS);
+                directPromise
+                    .then(late => {
+                    const latePeripheral = late !== null && late !== void 0 ? late : discoveredDevices.get(deviceId);
+                    if (latePeripheral &&
+                        latePeripheral.state === 'connected' &&
+                        !connectedDevices.has(deviceId)) {
+                        latePeripheral.removeAllListeners('disconnect');
+                        latePeripheral.disconnect(() => { });
+                    }
+                })
+                    .catch(() => { });
+                return undefined;
+            }
+            const peripheral = raced !== null && raced !== void 0 ? raced : discoveredDevices.get(deviceId);
+            if (!peripheral || peripheral.state !== 'connected')
+                return undefined;
+            discoveredDevices.set(deviceId, peripheral);
+            return peripheral;
+        }
+        catch (error) {
+            return undefined;
+        }
+    });
+}
 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:', {
@@ -903,8 +1034,9 @@ function connectDevice(deviceId, webContents) {
             if (!noble) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Noble not available');
             }
+            peripheral = yield tryDirectConnectById(deviceId);
             try {
-                const foundPeripheral = yield performTargetedScan(deviceId);
+                const foundPeripheral = peripheral !== null && peripheral !== void 0 ? peripheral : (yield performTargetedScan(deviceId));
                 if (!foundPeripheral) {
                     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, `Device ${deviceId} not found even after targeted scan`);
                 }
@@ -953,12 +1085,21 @@ function connectDevice(deviceId, webContents) {
             return;
         }
         return new Promise((resolve, reject) => {
+            let timedOut = false;
             const timeout = setTimeout(() => {
+                timedOut = true;
                 reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, 'Connection timeout'));
             }, CONNECTION_TIMEOUT);
             const connectedPeripheral = peripheral;
             connectedPeripheral.connect((error) => index.__awaiter(this, void 0, void 0, function* () {
                 clearTimeout(timeout);
+                if (timedOut) {
+                    if (!error && connectedPeripheral.state === 'connected') {
+                        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Late connection after timeout, disconnecting:', deviceId);
+                        connectedPeripheral.disconnect(() => { });
+                    }
+                    return;
+                }
                 if (error) {
                     logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Connection failed:', error);
                     reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, error.message));
@@ -990,7 +1131,11 @@ function disconnectDevice(deviceId) {
         }
         return new Promise(resolve => {
             peripheral.removeAllListeners('disconnect');
-            peripheral.disconnect(() => {
+            let settled = false;
+            const finish = () => {
+                if (settled)
+                    return;
+                settled = true;
                 cleanupDevice(deviceId, undefined, {
                     cleanupConnection: true,
                     sendDisconnectEvent: false,
@@ -998,6 +1143,11 @@ function disconnectDevice(deviceId) {
                     reason: 'manual-disconnect',
                 });
                 resolve();
+            };
+            const timer = setTimeout(finish, BLE_DISCONNECT_TIMEOUT_MS);
+            peripheral.disconnect(() => {
+                clearTimeout(timer);
+                finish();
             });
         });
     });
@@ -1162,11 +1312,17 @@ function setupNobleBleHandlers(webContents) {
                 hasCharacteristics: deviceCharacteristics.has(deviceId),
                 totalConnectedDevices: connectedDevices.size,
             });
+            clearIdleDisconnect(deviceId);
             yield connectDevice(deviceId, webContents);
+            armIdleDisconnect(deviceId, BLE_BUSY_BACKSTOP_MS, 'busy-backstop');
         }));
         ipcMain.handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_DISCONNECT, (_event, deviceId) => index.__awaiter(this, void 0, void 0, function* () {
             yield disconnectDevice(deviceId);
         }));
+        ipcMain.handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_RELEASE, (_event, deviceId) => {
+            if (connectedDevices.has(deviceId))
+                armIdleDisconnect(deviceId);
+        });
         ipcMain.handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_WRITE, (_event, deviceId, hexData) => index.__awaiter(this, void 0, void 0, function* () {
             logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] IPC WRITE', { deviceId, len: hexData.length });
             yield transmitHexDataToDevice(deviceId, hexData);
@@ -1175,9 +1331,11 @@ function setupNobleBleHandlers(webContents) {
             yield subscribeNotifications(deviceId, (data) => {
                 webContents.send(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_NOTIFICATION, deviceId, data);
             });
+            armIdleDisconnect(deviceId, BLE_BUSY_BACKSTOP_MS, 'busy-backstop');
         }));
         ipcMain.handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_UNSUBSCRIBE, (_event, deviceId) => index.__awaiter(this, void 0, void 0, function* () {
             yield unsubscribeNotifications(deviceId);
+            armIdleDisconnect(deviceId);
         }));
         ipcMain.handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_CANCEL_PAIRING, () => index.__awaiter(this, void 0, void 0, function* () {
             const deviceIds = Array.from(connectedDevices.keys());
@@ -1215,12 +1373,19 @@ function setupNobleBleHandlers(webContents) {
             safeLog(logger, 'info', 'Cleaning up Noble BLE handlers');
             const deviceIds = Array.from(connectedDevices.keys());
             deviceIds.forEach(deviceId => {
+                const peripheral = connectedDevices.get(deviceId);
                 cleanupDevice(deviceId, undefined, {
                     cleanupConnection: true,
                     sendDisconnectEvent: false,
                     cancelOperations: true,
                     reason: 'app-quit',
                 });
+                if (peripheral && peripheral.state === 'connected') {
+                    peripheral.removeAllListeners('disconnect');
+                    peripheral.disconnect(() => {
+                        safeLog(logger, 'info', `Disconnected ${deviceId} on window teardown`);
+                    });
+                }
             });
             stopScanning();
             if (noble && persistentStateListener) {

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":"AAwBA,OAAO,KAAK,EAAsB,WAAW,EAAE,MAAM,UAAU,CAAC;AAshDhE,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAsKpE"}
+{"version":3,"file":"noble-ble-handler.d.ts","sourceRoot":"","sources":["../src/noble-ble-handler.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAsB,WAAW,EAAE,MAAM,UAAU,CAAC;AA8uDhE,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAmMpE"}

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

@@ -8,6 +8,7 @@ export interface NobleBleAPI {
         name: string;
     } | null>;
     connect: (uuid: string) => Promise<void>;
+    release?: (uuid: string) => Promise<void>;
     disconnect: (uuid: string) => Promise<void>;
     subscribe: (uuid: string) => Promise<void>;
     unsubscribe: (uuid: string) => Promise<void>;

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,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,CAAA;KAAE,GAAG,IAAI,CAAC,CAAC;IAC1E,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACzC,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,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACrD,cAAc,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,KAAK,MAAM,IAAI,CAAC;IACnF,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":"AAMA,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,CAAA;KAAE,GAAG,IAAI,CAAC,CAAC;IAC1E,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAEzC,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1C,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,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACrD,cAAc,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,KAAK,MAAM,IAAI,CAAC;IACnF,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"}

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

@@ -15,6 +15,7 @@ export interface NobleModule {
     stopScanning(callback?: () => void): void;
     on(event: 'stateChange', listener: (state: string) => void): void;
     on(event: 'discover', listener: (peripheral: Peripheral) => void): void;
+    connectAsync?(idOrAddress: string): Promise<Peripheral | undefined>;
     removeListener(event: 'stateChange', listener: (state: string) => void): void;
     removeListener(event: 'discover', listener: (peripheral: Peripheral) => void): 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;CACf;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;CACf;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;IASxE,YAAY,CAAC,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAAC;IACpE,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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-electron",
-  "version": "1.1.34-alpha.0",
+  "version": "1.1.34-alpha.2",
   "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.1.34-alpha.0",
-    "@onekeyfe/hd-shared": "1.1.34-alpha.0",
-    "@onekeyfe/hd-transport": "1.1.34-alpha.0",
+    "@onekeyfe/hd-core": "1.1.34-alpha.2",
+    "@onekeyfe/hd-shared": "1.1.34-alpha.2",
+    "@onekeyfe/hd-transport": "1.1.34-alpha.2",
     "@stoprocent/noble": "2.3.16",
     "p-retry": "^4.6.2"
   },
@@ -36,5 +36,5 @@
     "electron": "^25.0.0",
     "typescript": "^5.3.3"
   },
-  "gitHead": "178851631a3d06dd52c8dd9df24cbaaff7aa6390"
+  "gitHead": "dee167c35d191f3f4e02c4cb6228e1f926f929ec"
 }

package/src/noble-ble-handler.ts

@@ -9,9 +9,7 @@ import {
   EOneKeyBleMessageKeys,
   ERRORS,
   HardwareErrorCode,
-  ONEKEY_NOTIFY_CHARACTERISTIC_UUID,
   ONEKEY_SERVICE_UUID,
-  ONEKEY_WRITE_CHARACTERISTIC_UUID,
   isHeaderChunk,
   isOnekeyDevice,
   wait,
@@ -74,6 +72,13 @@ const devicePacketStates = new Map<string, PacketAssemblyState>();
 const ONEKEY_SERVICE_UUIDS = [ONEKEY_SERVICE_UUID];
 
 // Pre-normalized characteristic identifiers for fast comparison
+// Reduce any uuid form (long base-form with/without dashes, or short) to its
+// 16-bit key for comparisons — noble/mac reports base-UUIDs short-form.
+const uuid16Key = (uuid: string): string => {
+  const stripped = (uuid ?? '').replace(/-/g, '').toLowerCase();
+  return stripped.length >= 8 ? stripped.substring(4, 8) : stripped;
+};
+
 const NORMALIZED_WRITE_UUID = '0002';
 const NORMALIZED_NOTIFY_UUID = '0003';
 
@@ -83,6 +88,15 @@ 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; // 3 seconds for device connection
+// Idle window before a kept-alive link is dropped so other hosts (phone) can
+// connect; matches the device's 60s auto-lock default.
+const BLE_IDLE_DISCONNECT_MS = 60_000;
+// noble's disconnect callback can hang on a wedged peripheral — bound it.
+const BLE_DISCONNECT_TIMEOUT_MS = 2000;
+// Backstop while a request is outstanding: the idle clock must not run while
+// the user is on the device's confirm screen, but a dead call must not hold
+// the link forever either.
+const BLE_BUSY_BACKSTOP_MS = 10 * 60_000;
 const SERVICE_DISCOVERY_TIMEOUT = 10000; // 10 seconds for service discovery
 
 // Write-related constants
@@ -302,6 +316,64 @@ function updateBluetoothState(state: string): void {
   }
 }
 
+// ===== Keep-alive idle disconnect =====
+// One timer per device: a write swaps it for the busy backstop, a complete
+// response re-arms the 60s idle clock. Lives in the main process so a renderer
+// reload cannot orphan a held link.
+const idleDisconnectTimers = new Map<string, ReturnType<typeof setTimeout>>();
+
+function clearIdleDisconnect(deviceId: string): void {
+  const timer = idleDisconnectTimers.get(deviceId);
+  if (timer) {
+    clearTimeout(timer);
+    idleDisconnectTimers.delete(deviceId);
+  }
+}
+
+function armIdleDisconnect(
+  deviceId: string,
+  ms: number = BLE_IDLE_DISCONNECT_MS,
+  reason: 'idle' | 'busy-backstop' = 'idle'
+): void {
+  clearIdleDisconnect(deviceId);
+  idleDisconnectTimers.set(
+    deviceId,
+    setTimeout(() => {
+      idleDisconnectTimers.delete(deviceId);
+      if (!connectedDevices.has(deviceId)) return;
+      logger?.info('[NobleBLE] Keep-alive timeout, disconnecting device:', deviceId, reason);
+      const peripheral = connectedDevices.get(deviceId);
+      const deviceName = peripheral?.advertisement?.localName || 'Unknown Device';
+      disconnectDevice(deviceId)
+        .then(() => {
+          // Notify renderers: on the busy backstop a call is still in flight
+          // and must reject instead of hanging on a dead link.
+          broadcastToAllWebContents(EOneKeyBleMessageKeys.BLE_DEVICE_DISCONNECTED, {
+            id: deviceId,
+            name: deviceName,
+          });
+        })
+        .catch(error => {
+          logger?.error('[NobleBLE] Keep-alive disconnect failed:', error);
+        });
+    }, ms)
+  );
+}
+
+function broadcastToAllWebContents(channel: string, payload: unknown): void {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires, global-require
+    const { webContents: electronWebContents } = require('electron') as {
+      webContents: { getAllWebContents(): WebContents[] };
+    };
+    for (const wc of electronWebContents.getAllWebContents()) {
+      if (!wc.isDestroyed()) wc.send(channel, payload);
+    }
+  } catch (error) {
+    logger?.error('[NobleBLE] broadcast failed:', { channel, error: String(error) });
+  }
+}
+
 // Initialize Noble
 async function initializeNoble(): Promise<void> {
   if (noble) return;
@@ -418,6 +490,7 @@ function cleanupDevice(
     sendDisconnectEvent,
     cancelOperations,
   });
+  clearIdleDisconnect(deviceId);
 
   // Get device info before cleanup
   const peripheral = connectedDevices.get(deviceId);
@@ -616,6 +689,9 @@ async function transmitHexDataToDevice(deviceId: string, hexData: string): Promi
       `Device ${deviceId} not connected or characteristics not available`
     );
   }
+  // Request outstanding: swap the idle clock for the busy backstop; the
+  // complete-response handler re-arms the 60s idle clock.
+  armIdleDisconnect(deviceId, BLE_BUSY_BACKSTOP_MS, 'busy-backstop');
 
   const toBuffer = Buffer.from(hexData, 'hex');
   logger?.info('[NobleBLE] Writing data:', {
@@ -952,9 +1028,13 @@ async function discoverServicesAndCharacteristics(
 
   // Main discovery logic as async function
   const discoveryPromise = (async (): Promise<CharacteristicPair> => {
-    // Step 1: Discover services (promisified)
+    // Step 1: Discover services (promisified). In unfiltered mode we discover
+    // everything and pick the OneKey service in JS — field data (Classic,
+    // 2026-07-19) showed the UUID-filtered query returning empty on a link
+    // where an unfiltered probe saw 5 services, so the filter itself is under
+    // suspicion (same failure family as the Windows scan-filter issue).
     const services = await new Promise<Service[]>((resolve, reject) => {
-      peripheral.discoverServices(ONEKEY_SERVICE_UUIDS, (error, svc) => {
+      peripheral.discoverServices([], (error, svc) => {
         if (error) {
           logger?.error('[NobleBLE] Service discovery failed:', error);
           reject(ERRORS.TypedError(HardwareErrorCode.BleServiceNotFound, error.message));
@@ -968,22 +1048,28 @@ async function discoverServicesAndCharacteristics(
       throw ERRORS.TypedError(HardwareErrorCode.BleServiceNotFound, 'No OneKey services found');
     }
 
-    const service = services[0];
+    // Pick by 16-bit key: constants are long base-forms, noble/mac reports
+    // base-UUID services short-form ('0001').
+    const wanted = ONEKEY_SERVICE_UUIDS.map(uuid16Key);
+    const service = services.find(svc => wanted.includes(uuid16Key(svc.uuid)));
+    if (!service) {
+      // Carry the uuid list so the trace shows what the device exposed.
+      throw ERRORS.TypedError(
+        HardwareErrorCode.BleServiceNotFound,
+        `No OneKey service in result set: ${services.map(svc => svc.uuid).join('|')}`
+      );
+    }
     logger?.info('[NobleBLE] Found service:', service.uuid);
 
-    // Step 2: Discover characteristics (promisified)
     const characteristics = await new Promise<Characteristic[]>((resolve, reject) => {
-      service.discoverCharacteristics(
-        [ONEKEY_WRITE_CHARACTERISTIC_UUID, ONEKEY_NOTIFY_CHARACTERISTIC_UUID],
-        (error, chars) => {
-          if (error) {
-            logger?.error('[NobleBLE] Characteristic discovery failed:', error);
-            reject(ERRORS.TypedError(HardwareErrorCode.BleCharacteristicNotFound, error.message));
-          } else {
-            resolve(chars);
-          }
+      service.discoverCharacteristics([], (error, chars) => {
+        if (error) {
+          logger?.error('[NobleBLE] Characteristic discovery failed:', error);
+          reject(ERRORS.TypedError(HardwareErrorCode.BleCharacteristicNotFound, error.message));
+        } else {
+          resolve(chars);
         }
-      );
+      });
     });
 
     // Step 3: Find required characteristics
@@ -1086,7 +1172,6 @@ async function forceReconnectPeripheral(peripheral: Peripheral, deviceId: string
   // NOTE: Caller MUST call setupDisconnectListener() after this function returns
 }
 
-// Last resort: Fresh scan to get completely new peripheral object and discover services
 async function freshScanAndDiscover(
   deviceId: string,
   webContents: WebContents
@@ -1096,6 +1181,21 @@ async function freshScanAndDiscover(
     deviceId
   );
 
+  // The device does not advertise while we hold a link — drop the old one
+  // first (bounded) so it goes back on air before we scan.
+  const stalePeripheral = connectedDevices.get(deviceId) ?? discoveredDevices.get(deviceId);
+  if (stalePeripheral && stalePeripheral.state === 'connected') {
+    stalePeripheral.removeAllListeners('disconnect');
+    await new Promise<void>(resolve => {
+      const timer = setTimeout(resolve, BLE_DISCONNECT_TIMEOUT_MS);
+      stalePeripheral.disconnect(() => {
+        clearTimeout(timer);
+        resolve();
+      });
+    });
+    connectedDevices.delete(deviceId);
+  }
+
   const freshPeripheral = await performTargetedScan(deviceId);
   if (!freshPeripheral) {
     // Deep cleanup: fresh scan found no device, reset to initial state
@@ -1136,9 +1236,17 @@ async function freshScanAndDiscover(
   // Wait for connection to stabilize (fresh peripheral doesn't need GATT cache clearing)
   await wait(500);
 
-  // Attempt service discovery with fresh peripheral
+  // Attempt service discovery with fresh peripheral. On failure the fresh
+  // peripheral is already physically connected and registered in
+  // connectedDevices with no idle timer armed — keep-alive release() is
+  // logical-only and would never drop it — so tear it down before rethrowing.
   logger?.info('[NobleBLE] Attempting service discovery with fresh peripheral');
-  return discoverServicesAndCharacteristics(freshPeripheral);
+  try {
+    return await discoverServicesAndCharacteristics(freshPeripheral);
+  } catch (error) {
+    await disconnectDevice(deviceId).catch(() => undefined);
+    throw error;
+  }
 }
 
 // Enhanced service discovery with p-retry for robust BLE connection
@@ -1209,20 +1317,94 @@ async function setupConnectionAndDiscoverServices(
   deviceId: string,
   webContents: WebContents
 ): Promise<CharacteristicPair> {
-  // Force reconnect to clear GATT cache
-  await forceReconnectPeripheral(peripheral, deviceId);
   setupDisconnectListener(peripheral, deviceId, webContents);
 
-  // Discover services and characteristics with retry
+  // Optimistic direct discovery first; the force-reconnect fallback below only
+  // runs if it fails. Discovery is UNFILTERED with 16-bit-key matching in JS:
+  // the device answers only the 2-byte-encoded targeted query, so a uuid-
+  // filtered discovery is unreliable (macOS CoreBluetooth sends the 128-bit
+  // base form and misses). See uuid16Key.
+  if (peripheral.state === 'connected') {
+    try {
+      const result = await discoverServicesAndCharacteristics(peripheral);
+      connectedDevices.set(deviceId, peripheral);
+      return result;
+    } catch (directError) {
+      logger?.info('[NobleBLE] Direct discovery miss, escalating:', String(directError));
+    }
+  }
+
+  // Fallback ladder; a force-reconnect failure must also escalate to the
+  // fresh scan instead of propagating out.
   try {
-    return await discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId);
+    await forceReconnectPeripheral(peripheral, deviceId);
+    // forceReconnectPeripheral strips listeners — re-attach.
+    setupDisconnectListener(peripheral, deviceId, webContents);
+
+    const result = await discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId);
+    return result;
   } catch (error) {
     // Last resort: fresh scan to get new peripheral object
     logger?.error('[NobleBLE] Service discovery failed, attempting fresh scan...', error);
+    // Broken-OS-bond signature lands here.
     return freshScanAndDiscover(deviceId, webContents);
   }
 }
 
+// noble/mac never resolves connect-by-id for an unretrievable peripheral —
+// time-box it, and after a timeout skip direct for a while so the retry
+// ladder doesn't re-pay the 2s against an absent device.
+const DIRECT_CONNECT_TIMEOUT_MS = 2000;
+const DIRECT_CONNECT_COOLDOWN_MS = 15_000;
+const directConnectCooldownUntil = new Map<string, number>();
+
+/**
+ * Bounded connect-by-id with no scan; undefined -> caller falls back to the
+ * targeted scan. A late success after the timeout is dropped unless claimed.
+ */
+async function tryDirectConnectById(deviceId: string): Promise<Peripheral | undefined> {
+  if (!noble || typeof noble.connectAsync !== 'function') return undefined;
+  if ((directConnectCooldownUntil.get(deviceId) ?? 0) > Date.now()) {
+    return undefined;
+  }
+  try {
+    // The late-orphan guard must attach to THIS pending connect.
+    const directPromise = noble.connectAsync(deviceId);
+    const raced = await Promise.race([
+      directPromise,
+      new Promise<'timeout'>(resolve => {
+        setTimeout(() => resolve('timeout'), DIRECT_CONNECT_TIMEOUT_MS);
+      }),
+    ]);
+    if (raced === 'timeout') {
+      directConnectCooldownUntil.set(deviceId, Date.now() + DIRECT_CONNECT_COOLDOWN_MS);
+      // If the pending connect completes later, drop it unless someone claimed it.
+      directPromise
+        .then(late => {
+          const latePeripheral = late ?? discoveredDevices.get(deviceId);
+          if (
+            latePeripheral &&
+            latePeripheral.state === 'connected' &&
+            !connectedDevices.has(deviceId)
+          ) {
+            latePeripheral.removeAllListeners('disconnect');
+            latePeripheral.disconnect(() => {});
+          }
+        })
+        .catch(() => {});
+      return undefined;
+    }
+    // Backends emit a `discover` for the peripheral as a side effect, so the
+    // cache may hold it even when connectAsync resolves without a value.
+    const peripheral = raced ?? discoveredDevices.get(deviceId);
+    if (!peripheral || peripheral.state !== 'connected') return undefined;
+    discoveredDevices.set(deviceId, peripheral);
+    return peripheral;
+  } catch (error) {
+    return undefined;
+  }
+}
+
 // 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:', {
@@ -1249,9 +1431,13 @@ async function connectDevice(deviceId: string, webContents: WebContents): Promis
       throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Noble not available');
     }
 
+    // Bounded connect-by-id first: skips the ~650ms targeted scan and reaches
+    // a device that is not advertising; falls through to the scan on timeout.
+    peripheral = await tryDirectConnectById(deviceId);
+
     // Perform a targeted scan to find the specific device
     try {
-      const foundPeripheral = await performTargetedScan(deviceId);
+      const foundPeripheral = peripheral ?? (await performTargetedScan(deviceId));
       if (!foundPeripheral) {
         throw ERRORS.TypedError(
           HardwareErrorCode.DeviceNotFound,
@@ -1337,7 +1523,11 @@ async function connectDevice(deviceId: string, webContents: WebContents): Promis
   }
 
   return new Promise((resolve, reject) => {
+    // After the timeout rejects, a late successful connect would be an
+    // ownerless link with no idle timer — detect and drop it.
+    let timedOut = false;
     const timeout = setTimeout(() => {
+      timedOut = true;
       reject(ERRORS.TypedError(HardwareErrorCode.BleConnectedError, 'Connection timeout'));
     }, CONNECTION_TIMEOUT);
 
@@ -1346,6 +1536,14 @@ async function connectDevice(deviceId: string, webContents: WebContents): Promis
     connectedPeripheral.connect(async (error: Error | undefined) => {
       clearTimeout(timeout);
 
+      if (timedOut) {
+        if (!error && connectedPeripheral.state === 'connected') {
+          logger?.info('[NobleBLE] Late connection after timeout, disconnecting:', deviceId);
+          connectedPeripheral.disconnect(() => {});
+        }
+        return;
+      }
+
       if (error) {
         logger?.error('[NobleBLE] Connection failed:', error);
         reject(ERRORS.TypedError(HardwareErrorCode.BleConnectedError, error.message));
@@ -1386,7 +1584,13 @@ async function disconnectDevice(deviceId: string): Promise<void> {
     // Remove disconnect listener to avoid triggering handleDeviceDisconnect
     peripheral.removeAllListeners('disconnect');
 
-    peripheral.disconnect(() => {
+    // Time-box the disconnect: on a wedged peripheral CoreBluetooth may never
+    // invoke the callback, and callers (e.g. the idle/backstop timer) rely on
+    // this resolving so cleanup + the renderer-facing disconnect broadcast run.
+    let settled = false;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
       // Clean up device state using unified function
       cleanupDevice(deviceId, undefined, {
         cleanupConnection: true,
@@ -1395,6 +1599,11 @@ async function disconnectDevice(deviceId: string): Promise<void> {
         reason: 'manual-disconnect',
       });
       resolve();
+    };
+    const timer = setTimeout(finish, BLE_DISCONNECT_TIMEOUT_MS);
+    peripheral.disconnect(() => {
+      clearTimeout(timer);
+      finish();
     });
   });
 }
@@ -1564,6 +1773,11 @@ async function subscribeNotifications(
         return;
       }
       if (result.isComplete && result.completePacket) {
+        // A complete response does NOT mean the operation is over — the run
+        // may continue (further request/response, or an on-device prompt whose
+        // Ack the host writes after slow human input). Do NOT re-arm the 60s
+        // idle clock here; that starts only on logical release. The busy
+        // backstop remains the in-flight ceiling.
         const appCb = notificationCallbacks.get(deviceId);
         if (appCb) appCb(result.completePacket);
       }
@@ -1632,7 +1846,15 @@ export function setupNobleBleHandlers(webContents: WebContents): void {
           hasCharacteristics: deviceCharacteristics.has(deviceId),
           totalConnectedDevices: connectedDevices.size,
         });
+        // An armed idle timer must not fire mid-connect (pairing can take ~30s).
+        clearIdleDisconnect(deviceId);
         await connectDevice(deviceId, webContents);
+        // A logical operation is now in flight (acquire). Arm the long busy
+        // backstop, NOT the 60s idle clock — the 60s countdown starts only when
+        // the renderer signals logical release (NOBLE_BLE_RELEASE). This keeps
+        // the link up across slow on-device prompts (PIN/passphrase) that have
+        // no outstanding write.
+        armIdleDisconnect(deviceId, BLE_BUSY_BACKSTOP_MS, 'busy-backstop');
       }
     );
 
@@ -1644,6 +1866,16 @@ export function setupNobleBleHandlers(webContents: WebContents): void {
       }
     );
 
+    // Handle logical release: the operation is done, start the 60s idle
+    // countdown so an unused device is freed for other hosts. The physical
+    // link is kept (reused by the next call) unless the countdown elapses.
+    ipcMain.handle(
+      EOneKeyBleMessageKeys.NOBLE_BLE_RELEASE,
+      (_event: IpcMainInvokeEvent, deviceId: string) => {
+        if (connectedDevices.has(deviceId)) armIdleDisconnect(deviceId);
+      }
+    );
+
     // Handle write request
     ipcMain.handle(
       EOneKeyBleMessageKeys.NOBLE_BLE_WRITE,
@@ -1661,6 +1893,8 @@ export function setupNobleBleHandlers(webContents: WebContents): void {
           // Send data back to renderer process
           webContents.send(EOneKeyBleMessageKeys.NOBLE_BLE_NOTIFICATION, deviceId, data);
         });
+        // Still acquiring (in flight) — busy backstop, not the 60s idle clock.
+        armIdleDisconnect(deviceId, BLE_BUSY_BACKSTOP_MS, 'busy-backstop');
       }
     );
 
@@ -1669,6 +1903,7 @@ export function setupNobleBleHandlers(webContents: WebContents): void {
       EOneKeyBleMessageKeys.NOBLE_BLE_UNSUBSCRIBE,
       async (_event: IpcMainInvokeEvent, deviceId: string) => {
         await unsubscribeNotifications(deviceId);
+        armIdleDisconnect(deviceId);
       }
     );
 
@@ -1714,15 +1949,23 @@ export function setupNobleBleHandlers(webContents: WebContents): void {
     webContents.on('destroyed', () => {
       safeLog(logger, 'info', 'Cleaning up Noble BLE handlers');
 
-      // 1. Clean up all connected devices (unified cleanup, avoid duplicates)
+      // Physically disconnect too: the main process can outlive this window
+      // (tray) and a held link would block the device for every other host.
       const deviceIds = Array.from(connectedDevices.keys());
       deviceIds.forEach(deviceId => {
+        const peripheral = connectedDevices.get(deviceId);
         cleanupDevice(deviceId, undefined, {
           cleanupConnection: true,
           sendDisconnectEvent: false,
           cancelOperations: true,
           reason: 'app-quit',
         });
+        if (peripheral && peripheral.state === 'connected') {
+          peripheral.removeAllListeners('disconnect');
+          peripheral.disconnect(() => {
+            safeLog(logger, 'info', `Disconnected ${deviceId} on window teardown`);
+          });
+        }
       });
 
       // 2. Stop scanning

package/src/types/desktop-api.ts

@@ -8,6 +8,8 @@ export interface NobleBleAPI {
   enumerate: () => Promise<{ id: string; name: string }[]>;
   getDevice: (uuid: string) => Promise<{ id: string; name: string } | null>;
   connect: (uuid: string) => Promise<void>;
+  /** Logical end-of-operation (keep-alive): starts the idle-disconnect countdown. */
+  release?: (uuid: string) => Promise<void>;
   disconnect: (uuid: string) => Promise<void>;
   subscribe: (uuid: string) => Promise<void>;
   unsubscribe: (uuid: string) => Promise<void>;

package/src/types/noble-extended.ts

@@ -30,6 +30,15 @@ export interface NobleModule {
   stopScanning(callback?: () => void): void;
   on(event: 'stateChange', listener: (state: string) => void): void;
   on(event: 'discover', listener: (peripheral: Peripheral) => void): void;
+  /**
+   * Connect by id/address with NO scan. Both native backends support this and
+   * emit a `discover` for the peripheral as a side effect (Windows synthesizes
+   * one for an unknown address; macOS resolves via
+   * retrievePeripheralsWithIdentifiers). Optional so an old noble can omit it.
+   * CAUTION: on macOS this never resolves for an id CoreBluetooth cannot
+   * retrieve — callers must time-box it.
+   */
+  connectAsync?(idOrAddress: string): Promise<Peripheral | undefined>;
   removeListener(event: 'stateChange', listener: (state: string) => void): void;
   removeListener(event: 'discover', listener: (peripheral: Peripheral) => void): void;
 }