@onekeyfe/hd-transport-electron 1.2.0-alpha.73 → 1.2.0-alpha.75

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

package/dist/index.d.ts

@@ -45,6 +45,7 @@ interface NobleBleAPI {
         mtu?: number;
     } | null>;
     connect: (uuid: string) => Promise<void>;
+    release?: (uuid: string, keepSession?: boolean) => 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-4f7dc0a5.js');
+var index = require('./index-6da32f94.js');
 
 
 

package/dist/{noble-ble-handler-3bd9cd3e.js → noble-ble-handler-ce551d9a.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./index-4f7dc0a5.js');
+var index = require('./index-6da32f94.js');
 var hdShared = require('@onekeyfe/hd-shared');
 var pRetry = require('p-retry');
 
@@ -116,6 +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_BUSY_BACKSTOP_MS = 10 * 60000;
 const BLE_PACKET_SIZE_FALLBACK = 192;
 const BLE_PACKET_SIZE_MAXIMUM = 244;
 const DEFAULT_WRITE_PACING_DELAY_MS = 5;
@@ -296,6 +298,62 @@ function initializeNoble() {
         }
     });
 }
+const idleDisconnectTimers = new Map();
+const idleDisconnectInFlight = new Map();
+function clearIdleDisconnect(deviceId) {
+    const timer = idleDisconnectTimers.get(deviceId);
+    if (timer) {
+        clearTimeout(timer);
+        idleDisconnectTimers.delete(deviceId);
+    }
+}
+function awaitIdleDisconnect(deviceId) {
+    return index.__awaiter(this, void 0, void 0, function* () {
+        const pending = idleDisconnectInFlight.get(deviceId);
+        if (pending)
+            yield pending.catch(() => undefined);
+    });
+}
+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 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';
+        const pending = 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', { deviceId, error });
+        })
+            .finally(() => {
+            if (idleDisconnectInFlight.get(deviceId) === pending) {
+                idleDisconnectInFlight.delete(deviceId);
+            }
+        });
+        idleDisconnectInFlight.set(deviceId, pending);
+    }, ms));
+}
 function cleanupDevice(deviceId, webContents, options = {}) {
     var _a;
     const { cleanupConnection = true, cleanupDiscoveredCache = false, sendDisconnectEvent = false, cancelOperations = true, reason = 'unknown', } = options;
@@ -307,6 +365,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) {
@@ -330,8 +389,8 @@ function cleanupDevice(deviceId, webContents, options = {}) {
     if (cleanupDiscoveredCache) {
         discoveredDevices.delete(deviceId);
     }
-    if (sendDisconnectEvent && webContents) {
-        webContents.send(hdShared.EOneKeyBleMessageKeys.BLE_DEVICE_DISCONNECTED, {
+    if (sendDisconnectEvent) {
+        broadcastToAllWebContents(hdShared.EOneKeyBleMessageKeys.BLE_DEVICE_DISCONNECTED, {
             id: deviceId,
             name: deviceName,
         });
@@ -373,6 +432,8 @@ function setupMtuListener(peripheral, deviceId, webContents) {
     const listener = (mtu) => {
         if (!Number.isFinite(mtu) || mtu <= 0)
             return;
+        if (webContents.isDestroyed())
+            return;
         webContents.send(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_MTU_CHANGED, {
             id: deviceId,
             mtu,
@@ -479,6 +540,7 @@ function transmitHexDataToDevice(deviceId, hexData, options) {
         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');
         const doGetWriteCharacteristic = () => { var _a; return (_a = deviceCharacteristics.get(deviceId)) === null || _a === void 0 ? void 0 : _a.write; };
         const packetCapacity = resolveBlePacketCapacity(peripheral.mtu, BLE_PACKET_SIZE_MAXIMUM, BLE_PACKET_SIZE_FALLBACK);
@@ -636,21 +698,21 @@ function enumerateDevices() {
                     clearInterval(intervalId);
                 yield waitForNobleScanStop(nobleInstance);
             });
-            const checkDevices = () => {
-                discoveredDevices.forEach((peripheral, id) => {
-                    var _a;
-                    const existingDevice = devices.find(d => d.id === id);
-                    if (!existingDevice) {
-                        const deviceName = ((_a = peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.localName) || 'Unknown Device';
-                        devices.push({
-                            commType: 'electron-ble',
-                            id,
-                            name: deviceName,
-                            state: peripheral.state || 'disconnected',
-                        });
-                    }
+            const pushDevice = (peripheral, id) => {
+                var _a;
+                if (devices.some(d => d.id === id))
+                    return;
+                devices.push({
+                    commType: 'electron-ble',
+                    id,
+                    name: ((_a = peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.localName) || 'Unknown Device',
+                    state: peripheral.state || 'disconnected',
                 });
             };
+            const checkDevices = () => {
+                discoveredDevices.forEach(pushDevice);
+                connectedDevices.forEach(pushDevice);
+            };
             const timeoutId = setTimeout(() => index.__awaiter(this, void 0, void 0, function* () {
                 checkDevices();
                 yield cleanup();
@@ -923,7 +985,62 @@ 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* () {
+        const nobleInstance = noble;
+        if (!(nobleInstance === null || nobleInstance === void 0 ? void 0 : nobleInstance.connectAsync))
+            return undefined;
+        const cooldownUntil = (_a = directConnectCooldownUntil.get(deviceId)) !== null && _a !== void 0 ? _a : 0;
+        if (Date.now() < cooldownUntil)
+            return undefined;
+        try {
+            const directPromise = nobleInstance.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);
+                logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Direct connect-by-id timed out, falling back to scan', {
+                    deviceId,
+                });
+                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(() => undefined);
+                    }
+                })
+                    .catch(() => undefined);
+                return undefined;
+            }
+            const peripheral = raced !== null && raced !== void 0 ? raced : discoveredDevices.get(deviceId);
+            if (!peripheral || peripheral.state !== 'connected')
+                return undefined;
+            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Direct connect-by-id succeeded', { deviceId });
+            return peripheral;
+        }
+        catch (error) {
+            directConnectCooldownUntil.set(deviceId, Date.now() + DIRECT_CONNECT_COOLDOWN_MS);
+            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Direct connect-by-id failed, falling back to scan', {
+                deviceId,
+                error: String(error),
+            });
+            return undefined;
+        }
+    });
+}
 function connectDevice(deviceId, webContents) {
+    var _a;
     return index.__awaiter(this, void 0, void 0, function* () {
         logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Connect device request:', {
             deviceId,
@@ -933,7 +1050,7 @@ function connectDevice(deviceId, webContents) {
             totalDiscovered: discoveredDevices.size,
             totalConnected: connectedDevices.size,
         });
-        let peripheral = discoveredDevices.get(deviceId);
+        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) {
@@ -942,6 +1059,12 @@ function connectDevice(deviceId, webContents) {
             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) {
@@ -962,8 +1085,8 @@ function connectDevice(deviceId, webContents) {
             logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device already connected, skipping connection step');
             if (!connectedDevices.has(deviceId)) {
                 connectedDevices.set(deviceId, peripheral);
-                setupDisconnectListener(peripheral, deviceId, webContents);
             }
+            setupDisconnectListener(peripheral, deviceId, webContents);
             if (deviceCharacteristics.has(deviceId)) {
                 logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device characteristics already available');
                 const ongoingOperation = subscriptionOperations.get(deviceId);
@@ -985,9 +1108,16 @@ function connectDevice(deviceId, webContents) {
                 notificationCallbacks.delete(deviceId);
                 subscribedDevices.delete(deviceId);
             }
-            const characteristics = yield setupConnectionAndDiscoverServices(peripheral, deviceId, webContents);
-            deviceCharacteristics.set(deviceId, characteristics);
-            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device ready for communication:', deviceId);
+            try {
+                const characteristics = yield setupConnectionAndDiscoverServices(peripheral, deviceId, webContents);
+                deviceCharacteristics.set(deviceId, characteristics);
+                logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device ready for communication:', deviceId);
+            }
+            catch (setupError) {
+                logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Connection setup failed on kept-alive link:', setupError);
+                yield disconnectDevice(deviceId).catch(() => undefined);
+                throw setupError;
+            }
             return;
         }
         return new Promise((resolve, reject) => {
@@ -1152,8 +1282,12 @@ function setupNobleBleHandlers(webContents) {
     try {
         logger = require('electron-log');
         const { ipcMain } = require('electron');
+        const handle = (channel, listener) => {
+            ipcMain.removeHandler(channel);
+            ipcMain.handle(channel, listener);
+        };
         safeLog(logger, 'info', 'Setting up Noble BLE IPC handlers');
-        ipcMain.handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_ENUMERATE, () => index.__awaiter(this, void 0, void 0, function* () {
+        handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_ENUMERATE, () => index.__awaiter(this, void 0, void 0, function* () {
             try {
                 const devices = yield enumerateDevices();
                 safeLog(logger, 'debug', 'Enumeration completed', {
@@ -1167,34 +1301,54 @@ function setupNobleBleHandlers(webContents) {
                 throw error;
             }
         }));
-        ipcMain.handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_STOP_SCAN, () => index.__awaiter(this, void 0, void 0, function* () {
+        handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_STOP_SCAN, () => index.__awaiter(this, void 0, void 0, function* () {
             yield stopScanning();
         }));
-        ipcMain.handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_GET_DEVICE, (_event, deviceId) => getDevice(deviceId));
-        ipcMain.handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_CONNECT, (_event, deviceId) => index.__awaiter(this, void 0, void 0, function* () {
+        handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_GET_DEVICE, (_event, deviceId) => getDevice(deviceId));
+        handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_CONNECT, (_event, deviceId) => index.__awaiter(this, void 0, void 0, function* () {
             logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] IPC CONNECT request received:', {
                 deviceId,
                 hasPeripheral: connectedDevices.has(deviceId),
                 hasCharacteristics: deviceCharacteristics.has(deviceId),
                 totalConnectedDevices: connectedDevices.size,
             });
-            yield connectDevice(deviceId, webContents);
+            clearIdleDisconnect(deviceId);
+            yield awaitIdleDisconnect(deviceId);
+            try {
+                yield connectDevice(deviceId, webContents);
+            }
+            finally {
+                if (connectedDevices.has(deviceId)) {
+                    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* () {
+        handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_RELEASE, (_event, deviceId, keepSession) => {
+            if (!connectedDevices.has(deviceId))
+                return;
+            if (keepSession) {
+                armIdleDisconnect(deviceId, BLE_BUSY_BACKSTOP_MS, 'busy-backstop');
+                return;
+            }
+            armIdleDisconnect(deviceId);
+        });
+        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_WRITE, (_event, deviceId, hexData, options) => index.__awaiter(this, void 0, void 0, function* () {
+        handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_WRITE, (_event, deviceId, hexData, options) => index.__awaiter(this, void 0, void 0, function* () {
             yield transmitHexDataToDevice(deviceId, hexData, options);
         }));
-        ipcMain.handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_SUBSCRIBE, (_event, deviceId) => index.__awaiter(this, void 0, void 0, function* () {
+        handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_SUBSCRIBE, (_event, deviceId) => index.__awaiter(this, void 0, void 0, function* () {
             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* () {
+        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* () {
+        handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_CANCEL_PAIRING, () => index.__awaiter(this, void 0, void 0, function* () {
             const deviceIds = Array.from(connectedDevices.keys());
             logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Cancel pairing invoked', {
                 platform: process.platform,
@@ -1210,7 +1364,7 @@ function setupNobleBleHandlers(webContents) {
                 }
             }
         }));
-        ipcMain.handle(hdShared.EOneKeyBleMessageKeys.BLE_AVAILABILITY_CHECK, () => index.__awaiter(this, void 0, void 0, function* () {
+        handle(hdShared.EOneKeyBleMessageKeys.BLE_AVAILABILITY_CHECK, () => index.__awaiter(this, void 0, void 0, function* () {
             try {
                 const bluetoothStatus = yield checkBluetoothAvailability();
                 safeLog(logger, 'info', 'Bluetooth availability check completed:', bluetoothStatus);

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,EAAsB,WAAW,EAAE,MAAM,UAAU,CAAC;AAEhE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAsEhE,wBAAgB,+BAA+B,CAAC,OAAO,CAAC,EAAE,oBAAoB,UAI7E;AAw7CD,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CA8JpE"}
+{"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"}

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

@@ -12,6 +12,7 @@ export interface NobleBleAPI {
         mtu?: number;
     } | null>;
     connect: (uuid: string) => Promise<void>;
+    release?: (uuid: string, keepSession?: boolean) => 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,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;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,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":"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"}

package/package.json

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

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

@@ -47,6 +47,9 @@ describe('Electron Noble BLE device discovery', () => {
       handle: jest.fn((channel: string, handler: IpcHandler) => {
         handlers.set(channel, handler);
       }),
+      removeHandler: jest.fn((channel: string) => {
+        handlers.delete(channel);
+      }),
     };
     const noble = new EventEmitter() as EventEmitter & {
       state: string;
@@ -113,6 +116,9 @@ describe('Electron Noble BLE device discovery', () => {
       handle: jest.fn((channel: string, handler: IpcHandler) => {
         handlers.set(channel, handler);
       }),
+      removeHandler: jest.fn((channel: string) => {
+        handlers.delete(channel);
+      }),
     };
     const noble = new EventEmitter() as EventEmitter & {
       state: string;
@@ -181,6 +187,9 @@ describe('Electron Noble BLE device discovery', () => {
       handle: jest.fn((channel: string, handler: IpcHandler) => {
         handlers.set(channel, handler);
       }),
+      removeHandler: jest.fn((channel: string) => {
+        handlers.delete(channel);
+      }),
     };
     const noble = new EventEmitter() as EventEmitter & {
       state: string;
@@ -249,6 +258,9 @@ describe('Electron Noble BLE device discovery', () => {
       handle: jest.fn((channel: string, handler: IpcHandler) => {
         handlers.set(channel, handler);
       }),
+      removeHandler: jest.fn((channel: string) => {
+        handlers.delete(channel);
+      }),
     };
     const noble = new EventEmitter() as EventEmitter & {
       state: string;
@@ -307,6 +319,9 @@ describe('Electron Noble BLE device discovery', () => {
       handle: jest.fn((channel: string, handler: IpcHandler) => {
         handlers.set(channel, handler);
       }),
+      removeHandler: jest.fn((channel: string) => {
+        handlers.delete(channel);
+      }),
     };
     const noble = new EventEmitter() as EventEmitter & {
       state: string;

package/src/noble-ble-handler.ts

@@ -29,7 +29,7 @@ import {
   NOBLE_BLE_TARGETED_SCAN_TIMEOUT_MS,
 } from './noble-ble-timeouts';
 
-import type { IpcMainInvokeEvent, WebContents } from 'electron';
+import type { IpcMain, IpcMainInvokeEvent, WebContents } from 'electron';
 import type { Characteristic, Peripheral, Service } from '@stoprocent/noble';
 import type { NobleBleWriteOptions } from './types/desktop-api';
 import type { CharacteristicPair, DeviceInfo, Logger, NobleModule } from './types/noble-extended';
@@ -90,6 +90,10 @@ 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;
+// Renderer release is logical only; this timer physically frees the device.
+const BLE_IDLE_DISCONNECT_MS = 3 * 60_000;
+// Ceiling while a call is in flight: no outstanding write, but not forever.
+const BLE_BUSY_BACKSTOP_MS = 10 * 60_000;
 
 // Write-related constants
 const BLE_PACKET_SIZE_FALLBACK = 192;
@@ -341,6 +345,76 @@ interface DeviceCleanupOptions {
   reason?: string;
 }
 
+// One timer per device, in the main process so a reload cannot orphan a link.
+const idleDisconnectTimers = new Map<string, ReturnType<typeof setTimeout>>();
+
+// A fired timer cannot be cancelled; connect awaits its disconnect or the fast
+// path hands back a link torn down a moment later (BleTimeoutError 713).
+const idleDisconnectInFlight = new Map<string, Promise<void>>();
+
+function clearIdleDisconnect(deviceId: string): void {
+  const timer = idleDisconnectTimers.get(deviceId);
+  if (timer) {
+    clearTimeout(timer);
+    idleDisconnectTimers.delete(deviceId);
+  }
+}
+
+/** Settle any keep-alive disconnect already running for this device. */
+async function awaitIdleDisconnect(deviceId: string): Promise<void> {
+  const pending = idleDisconnectInFlight.get(deviceId);
+  if (pending) await pending.catch(() => undefined);
+}
+
+function broadcastToAllWebContents(channel: string, payload: unknown): void {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports, 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) });
+  }
+}
+
+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';
+      const pending = disconnectDevice(deviceId)
+        .then(() => {
+          // A call is still in flight here; it must reject, not hang.
+          broadcastToAllWebContents(EOneKeyBleMessageKeys.BLE_DEVICE_DISCONNECTED, {
+            id: deviceId,
+            name: deviceName,
+          });
+        })
+        .catch(error => {
+          logger?.error('[NobleBLE] Keep-alive disconnect failed', { deviceId, error });
+        })
+        .finally(() => {
+          if (idleDisconnectInFlight.get(deviceId) === pending) {
+            idleDisconnectInFlight.delete(deviceId);
+          }
+        });
+      idleDisconnectInFlight.set(deviceId, pending);
+    }, ms)
+  );
+}
+
 /**
  * Unified device cleanup function - single entry point for all cleanup operations
  */
@@ -366,6 +440,8 @@ function cleanupDevice(
     cancelOperations,
   });
 
+  clearIdleDisconnect(deviceId);
+
   // Get device info before cleanup
   const peripheral = connectedDevices.get(deviceId);
   const deviceName = peripheral?.advertisement?.localName || 'Unknown Device';
@@ -395,9 +471,11 @@ function cleanupDevice(
     discoveredDevices.delete(deviceId);
   }
 
-  // 3. Send disconnect event (if needed)
-  if (sendDisconnectEvent && webContents) {
-    webContents.send(EOneKeyBleMessageKeys.BLE_DEVICE_DISCONNECTED, {
+  // 3. Send disconnect event (if needed). Broadcast, not the captured
+  // webContents: a kept-alive link outlives a renderer soft restart, and the
+  // new renderer still needs to hear the device dropped (same as the idle path).
+  if (sendDisconnectEvent) {
+    broadcastToAllWebContents(EOneKeyBleMessageKeys.BLE_DEVICE_DISCONNECTED, {
       id: deviceId,
       name: deviceName,
     });
@@ -456,6 +534,8 @@ function setupMtuListener(
 
   const listener = (mtu: number) => {
     if (!Number.isFinite(mtu) || mtu <= 0) return;
+    // A kept-alive link can outlive the renderer this closure captured.
+    if (webContents.isDestroyed()) return;
     webContents.send(EOneKeyBleMessageKeys.NOBLE_BLE_MTU_CHANGED, {
       id: deviceId,
       mtu,
@@ -600,6 +680,8 @@ async function transmitHexDataToDevice(
       `Device ${deviceId} not connected or characteristics not available`
     );
   }
+  // Request outstanding: swap the idle clock for the busy backstop.
+  armIdleDisconnect(deviceId, BLE_BUSY_BACKSTOP_MS, 'busy-backstop');
 
   const toBuffer = Buffer.from(hexData, 'hex');
   const doGetWriteCharacteristic = () => deviceCharacteristics.get(deviceId)?.write;
@@ -808,20 +890,20 @@ async function enumerateDevices(): Promise<DeviceInfo[]> {
     };
 
     // Collect discovered devices into the devices array
-    const checkDevices = () => {
-      discoveredDevices.forEach((peripheral, id) => {
-        const existingDevice = devices.find(d => d.id === id);
-        if (!existingDevice) {
-          const deviceName = peripheral.advertisement?.localName || 'Unknown Device';
-          devices.push({
-            commType: 'electron-ble',
-            id,
-            name: deviceName,
-            state: peripheral.state || 'disconnected',
-          });
-        }
+    const pushDevice = (peripheral: Peripheral, id: string) => {
+      if (devices.some(d => d.id === id)) return;
+      devices.push({
+        commType: 'electron-ble',
+        id,
+        name: peripheral.advertisement?.localName || 'Unknown Device',
+        state: peripheral.state || 'disconnected',
       });
     };
+    const checkDevices = () => {
+      discoveredDevices.forEach(pushDevice);
+      // A linked device stops advertising, so the scan never rediscovers it.
+      connectedDevices.forEach(pushDevice);
+    };
 
     // Set timeout for scanning — use longer timeout to catch slow-advertising devices like Pro2
     const timeoutId = setTimeout(async () => {
@@ -1234,6 +1316,76 @@ async function setupConnectionAndDiscoverServices(
   }
 }
 
+// noble/mac never resolves for an id CoreBluetooth cannot retrieve.
+const DIRECT_CONNECT_TIMEOUT_MS = 2000;
+// Floor after a timeout: do not pay the probe on every attempt.
+const DIRECT_CONNECT_COOLDOWN_MS = 15_000;
+const directConnectCooldownUntil = new Map<string, number>();
+
+/**
+ * Connect straight by id, skipping the ~650ms targeted scan. Both native
+ * backends support it and emit a `discover` as a side effect: macOS resolves
+ * via `retrievePeripheralsWithIdentifiers`, Windows synthesizes one for an
+ * unknown address. Returns undefined when unavailable so the caller scans.
+ *
+ * Ported from the Trezor connector, where it is field-proven.
+ */
+async function tryDirectConnectById(deviceId: string): Promise<Peripheral | undefined> {
+  const nobleInstance = noble as
+    | (typeof noble & {
+        connectAsync?: (id: string) => Promise<Peripheral | undefined>;
+      })
+    | null;
+  if (!nobleInstance?.connectAsync) return undefined;
+
+  const cooldownUntil = directConnectCooldownUntil.get(deviceId) ?? 0;
+  if (Date.now() < cooldownUntil) return undefined;
+
+  try {
+    // The late-orphan guard must attach to THIS pending connect.
+    const directPromise = nobleInstance.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);
+      logger?.info('[NobleBLE] Direct connect-by-id timed out, falling back to scan', {
+        deviceId,
+      });
+      // Promise.race times out the caller only; a late success orphans the link.
+      directPromise
+        .then(late => {
+          const latePeripheral = late ?? discoveredDevices.get(deviceId);
+          if (
+            latePeripheral &&
+            latePeripheral.state === 'connected' &&
+            !connectedDevices.has(deviceId)
+          ) {
+            latePeripheral.removeAllListeners('disconnect');
+            latePeripheral.disconnect(() => undefined);
+          }
+        })
+        .catch(() => undefined);
+      return undefined;
+    }
+    // Backends emit `discover` as a side effect, so the cache may hold it.
+    const peripheral = raced ?? discoveredDevices.get(deviceId);
+    if (!peripheral || peripheral.state !== 'connected') return undefined;
+    logger?.info('[NobleBLE] Direct connect-by-id succeeded', { deviceId });
+    return peripheral;
+  } catch (error) {
+    directConnectCooldownUntil.set(deviceId, Date.now() + DIRECT_CONNECT_COOLDOWN_MS);
+    logger?.info('[NobleBLE] Direct connect-by-id failed, falling back to scan', {
+      deviceId,
+      error: String(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:', {
@@ -1245,7 +1397,8 @@ async function connectDevice(deviceId: string, webContents: WebContents): Promis
     totalConnected: connectedDevices.size,
   });
 
-  let peripheral = discoveredDevices.get(deviceId);
+  // 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) {
@@ -1260,6 +1413,14 @@ 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);
+    }
+  }
+
+  if (!peripheral) {
     // Perform a targeted scan to find the specific device
     try {
       const foundPeripheral = await performTargetedScan(deviceId);
@@ -1290,9 +1451,11 @@ async function connectDevice(deviceId: string, webContents: WebContents): Promis
     // If already connected but not in our connected devices map, add it
     if (!connectedDevices.has(deviceId)) {
       connectedDevices.set(deviceId, peripheral);
-      // Set up unified disconnect listener
-      setupDisconnectListener(peripheral, deviceId, webContents);
     }
+    // Re-bind unconditionally (idempotent): on a kept-alive link the disconnect
+    // and MTU listeners may still hold the webContents of a soft-restarted
+    // renderer, and the reuse fast path below returns before any other setup.
+    setupDisconnectListener(peripheral, deviceId, webContents);
 
     // Check if we already have characteristics for this device
     if (deviceCharacteristics.has(deviceId)) {
@@ -1336,13 +1499,20 @@ async function connectDevice(deviceId: string, webContents: WebContents): Promis
     }
 
     // Setup connection and discover services
-    const characteristics = await setupConnectionAndDiscoverServices(
-      peripheral,
-      deviceId,
-      webContents
-    );
-    deviceCharacteristics.set(deviceId, characteristics);
-    logger?.info('[NobleBLE] Device ready for communication:', deviceId);
+    try {
+      const characteristics = await setupConnectionAndDiscoverServices(
+        peripheral,
+        deviceId,
+        webContents
+      );
+      deviceCharacteristics.set(deviceId, characteristics);
+      logger?.info('[NobleBLE] Device ready for communication:', deviceId);
+    } catch (setupError) {
+      // The caller re-arms the timer only on success, so a left-up link strands.
+      logger?.error('[NobleBLE] Connection setup failed on kept-alive link:', setupError);
+      await disconnectDevice(deviceId).catch(() => undefined);
+      throw setupError;
+    }
     return;
   }
 
@@ -1577,12 +1747,18 @@ export function setupNobleBleHandlers(webContents: WebContents): void {
 
     // @ts-ignore – electron is only available at runtime
     // eslint-disable-next-line @typescript-eslint/no-var-requires, global-require
-    const { ipcMain } = require('electron');
+    const { ipcMain } = require('electron') as { ipcMain: IpcMain };
+
+    // Electron throws on duplicate channels and setup re-runs on soft restart.
+    const handle: IpcMain['handle'] = (channel, listener) => {
+      ipcMain.removeHandler(channel);
+      ipcMain.handle(channel, listener);
+    };
 
     safeLog(logger, 'info', 'Setting up Noble BLE IPC handlers');
 
     // Handle enumerate request
-    ipcMain.handle(EOneKeyBleMessageKeys.NOBLE_BLE_ENUMERATE, async () => {
+    handle(EOneKeyBleMessageKeys.NOBLE_BLE_ENUMERATE, async () => {
       try {
         const devices = await enumerateDevices();
         safeLog(logger, 'debug', 'Enumeration completed', {
@@ -1597,18 +1773,18 @@ export function setupNobleBleHandlers(webContents: WebContents): void {
     });
 
     // Handle stop scan request
-    ipcMain.handle(EOneKeyBleMessageKeys.NOBLE_BLE_STOP_SCAN, async () => {
+    handle(EOneKeyBleMessageKeys.NOBLE_BLE_STOP_SCAN, async () => {
       await stopScanning();
     });
 
     // Handle get device request
-    ipcMain.handle(
+    handle(
       EOneKeyBleMessageKeys.NOBLE_BLE_GET_DEVICE,
       (_event: IpcMainInvokeEvent, deviceId: string) => getDevice(deviceId)
     );
 
     // Handle connect request
-    ipcMain.handle(
+    handle(
       EOneKeyBleMessageKeys.NOBLE_BLE_CONNECT,
       async (_event: IpcMainInvokeEvent, deviceId: string) => {
         logger?.info('[NobleBLE] IPC CONNECT request received:', {
@@ -1617,12 +1793,37 @@ export function setupNobleBleHandlers(webContents: WebContents): void {
           hasCharacteristics: deviceCharacteristics.has(deviceId),
           totalConnectedDevices: connectedDevices.size,
         });
-        await connectDevice(deviceId, webContents);
+        // Must not fire mid-connect (pairing can take ~30s).
+        clearIdleDisconnect(deviceId);
+        // A fired timer must settle first, or the fast path returns a dying link.
+        await awaitIdleDisconnect(deviceId);
+        try {
+          await connectDevice(deviceId, webContents);
+        } finally {
+          // This timer is the only thing that frees a kept-alive link.
+          if (connectedDevices.has(deviceId)) {
+            armIdleDisconnect(deviceId, BLE_BUSY_BACKSTOP_MS, 'busy-backstop');
+          }
+        }
+      }
+    );
+
+    // Logical release: start the idle countdown, keep the link for the next call.
+    handle(
+      EOneKeyBleMessageKeys.NOBLE_BLE_RELEASE,
+      (_event: IpcMainInvokeEvent, deviceId: string, keepSession?: boolean) => {
+        if (!connectedDevices.has(deviceId)) return;
+        // Mid-flow caller will be back; the short window would cut an update.
+        if (keepSession) {
+          armIdleDisconnect(deviceId, BLE_BUSY_BACKSTOP_MS, 'busy-backstop');
+          return;
+        }
+        armIdleDisconnect(deviceId);
       }
     );
 
     // Handle disconnect request
-    ipcMain.handle(
+    handle(
       EOneKeyBleMessageKeys.NOBLE_BLE_DISCONNECT,
       async (_event: IpcMainInvokeEvent, deviceId: string) => {
         await disconnectDevice(deviceId);
@@ -1630,7 +1831,7 @@ export function setupNobleBleHandlers(webContents: WebContents): void {
     );
 
     // Handle write request
-    ipcMain.handle(
+    handle(
       EOneKeyBleMessageKeys.NOBLE_BLE_WRITE,
       async (
         _event: IpcMainInvokeEvent,
@@ -1643,26 +1844,29 @@ export function setupNobleBleHandlers(webContents: WebContents): void {
     );
 
     // Handle subscribe request
-    ipcMain.handle(
+    handle(
       EOneKeyBleMessageKeys.NOBLE_BLE_SUBSCRIBE,
       async (_event: IpcMainInvokeEvent, deviceId: string) => {
         await subscribeNotifications(deviceId, (data: string) => {
           // Send data back to renderer process
           webContents.send(EOneKeyBleMessageKeys.NOBLE_BLE_NOTIFICATION, deviceId, data);
         });
+        // Still acquiring (in flight) — busy backstop, not the idle clock.
+        armIdleDisconnect(deviceId, BLE_BUSY_BACKSTOP_MS, 'busy-backstop');
       }
     );
 
     // Handle unsubscribe request
-    ipcMain.handle(
+    handle(
       EOneKeyBleMessageKeys.NOBLE_BLE_UNSUBSCRIBE,
       async (_event: IpcMainInvokeEvent, deviceId: string) => {
         await unsubscribeNotifications(deviceId);
+        armIdleDisconnect(deviceId);
       }
     );
 
     // Handle cancel pairing: cleanup all connected devices
-    ipcMain.handle(EOneKeyBleMessageKeys.NOBLE_BLE_CANCEL_PAIRING, async () => {
+    handle(EOneKeyBleMessageKeys.NOBLE_BLE_CANCEL_PAIRING, async () => {
       const deviceIds = Array.from(connectedDevices.keys());
       logger?.info('[NobleBLE] Cancel pairing invoked', {
         platform: process.platform,
@@ -1683,7 +1887,7 @@ export function setupNobleBleHandlers(webContents: WebContents): void {
     });
 
     // Handle Bluetooth availability check request
-    ipcMain.handle(EOneKeyBleMessageKeys.BLE_AVAILABILITY_CHECK, async () => {
+    handle(EOneKeyBleMessageKeys.BLE_AVAILABILITY_CHECK, async () => {
       try {
         const bluetoothStatus = await checkBluetoothAvailability();
         safeLog(logger, 'info', 'Bluetooth availability check completed:', bluetoothStatus);

package/src/types/desktop-api.ts

@@ -12,6 +12,9 @@ export interface NobleBleAPI {
   enumerate: () => Promise<{ id: string; name: string }[]>;
   getDevice: (uuid: string) => Promise<{ id: string; name: string; mtu?: number } | null>;
   connect: (uuid: string) => Promise<void>;
+  // Logical end-of-operation: link stays up, idle countdown starts. Optional —
+  // older hosts do not bridge it, so the transport feature-detects.
+  release?: (uuid: string, keepSession?: boolean) => Promise<void>;
   disconnect: (uuid: string) => Promise<void>;
   subscribe: (uuid: string) => Promise<void>;
   unsubscribe: (uuid: string) => Promise<void>;