@onekeyfe/hwk-trezor-connector-electron-ble 1.2.2-alpha.8 → 1.2.2

package/dist/main.d.mts

@@ -14,6 +14,7 @@ interface NobleLike {
     removeListener(event: string, handler: (...args: any[]) => void): NobleLike;
     startScanningAsync(serviceUuids: string[], allowDuplicates: boolean): Promise<void>;
     stopScanningAsync(): Promise<void>;
+    stop?(): 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
@@ -22,6 +23,7 @@ interface NobleLike {
      * (lib/mac/src/ble_manager.mm). Optional so a stub noble can omit it.
      */
     connectAsync?(idOrAddress: string): Promise<NoblePeripheralLike | undefined>;
+    cancelConnect?(idOrAddress: string): void;
     reset?(): Promise<void>;
 }
 interface NoblePeripheralLike {
@@ -44,6 +46,7 @@ interface NoblePeripheralLike {
     rssi: number;
     state: string;
     connectAsync(): Promise<void>;
+    cancelConnect?(): void;
     disconnectAsync(): Promise<void>;
     discoverSomeServicesAndCharacteristicsAsync(serviceUuids: string[], characteristicUuids: string[]): Promise<{
         characteristics: NobleCharacteristicLike[];
@@ -89,13 +92,20 @@ declare class NobleBleHandler {
     private readonly _discovered;
     private readonly _lastSeen;
     private readonly _connected;
-    private _stateChangeHandler?;
     private _discoverHandler?;
     private _scanning;
     private _idleStopTimer?;
     private _onNotification?;
     private _onDeviceDisconnected?;
     private _initialized;
+    private _disposed;
+    private _disposePromise?;
+    private _releasePromise?;
+    private _initPromise?;
+    private readonly _nobleInstances;
+    private readonly _pendingCancellations;
+    private readonly _connectAttempts;
+    private _nativeReleased;
     private _lastNobleRecoverAt?;
     /** The connect currently in flight, so cancelPairing can abandon it. */
     private _activeConnect?;
@@ -220,8 +230,17 @@ declare class NobleBleHandler {
     subscribe(id: string): Promise<void>;
     unsubscribe(id: string): Promise<void>;
     write(id: string, hexData: string): Promise<void>;
-    /** Tear down all active connections — called on app quit. */
+    /** Retire a renderer's handler without stopping a process-wide native manager. */
     dispose(): Promise<void>;
+    /**
+     * Terminal native release, including instances replaced by adapter recovery.
+     * A host sharing Noble must defer stop() until all transports have disposed,
+     * and deduplicate instances passed to releaseNoble across those transports.
+     */
+    disposeForAppQuit(releaseNoble?: (instance: {
+        stop?(): void;
+    }) => void): Promise<void>;
+    private _assertActive;
     private _cleanupDevice;
     private _requireEntry;
     private _requireNoble;
@@ -247,13 +266,16 @@ interface InitTrezorBleSupportOptions extends NobleBleHandlerOptions {
 interface TrezorBleSupportHandle {
     handler: NobleBleHandler;
     dispose(): Promise<void>;
+    disposeForAppQuit(releaseNoble?: (instance: {
+        stop?(): void;
+    }) => void): Promise<void>;
 }
 /**
  * Wire a `NobleBleHandler` to Electron's IPC so the renderer can drive BLE
  * via `window.desktopApi.trezorBle`. Call once from the main process after
  * `BrowserWindow` is ready.
  *
- * Returns a disposer the caller should invoke on app quit.
+ * Call dispose() when retiring a renderer and disposeForAppQuit() before Node teardown.
  */
 declare function initTrezorBleSupport(webContents: WebContentsLike, options?: InitTrezorBleSupportOptions): TrezorBleSupportHandle;
 

package/dist/main.d.ts

@@ -14,6 +14,7 @@ interface NobleLike {
     removeListener(event: string, handler: (...args: any[]) => void): NobleLike;
     startScanningAsync(serviceUuids: string[], allowDuplicates: boolean): Promise<void>;
     stopScanningAsync(): Promise<void>;
+    stop?(): 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
@@ -22,6 +23,7 @@ interface NobleLike {
      * (lib/mac/src/ble_manager.mm). Optional so a stub noble can omit it.
      */
     connectAsync?(idOrAddress: string): Promise<NoblePeripheralLike | undefined>;
+    cancelConnect?(idOrAddress: string): void;
     reset?(): Promise<void>;
 }
 interface NoblePeripheralLike {
@@ -44,6 +46,7 @@ interface NoblePeripheralLike {
     rssi: number;
     state: string;
     connectAsync(): Promise<void>;
+    cancelConnect?(): void;
     disconnectAsync(): Promise<void>;
     discoverSomeServicesAndCharacteristicsAsync(serviceUuids: string[], characteristicUuids: string[]): Promise<{
         characteristics: NobleCharacteristicLike[];
@@ -89,13 +92,20 @@ declare class NobleBleHandler {
     private readonly _discovered;
     private readonly _lastSeen;
     private readonly _connected;
-    private _stateChangeHandler?;
     private _discoverHandler?;
     private _scanning;
     private _idleStopTimer?;
     private _onNotification?;
     private _onDeviceDisconnected?;
     private _initialized;
+    private _disposed;
+    private _disposePromise?;
+    private _releasePromise?;
+    private _initPromise?;
+    private readonly _nobleInstances;
+    private readonly _pendingCancellations;
+    private readonly _connectAttempts;
+    private _nativeReleased;
     private _lastNobleRecoverAt?;
     /** The connect currently in flight, so cancelPairing can abandon it. */
     private _activeConnect?;
@@ -220,8 +230,17 @@ declare class NobleBleHandler {
     subscribe(id: string): Promise<void>;
     unsubscribe(id: string): Promise<void>;
     write(id: string, hexData: string): Promise<void>;
-    /** Tear down all active connections — called on app quit. */
+    /** Retire a renderer's handler without stopping a process-wide native manager. */
     dispose(): Promise<void>;
+    /**
+     * Terminal native release, including instances replaced by adapter recovery.
+     * A host sharing Noble must defer stop() until all transports have disposed,
+     * and deduplicate instances passed to releaseNoble across those transports.
+     */
+    disposeForAppQuit(releaseNoble?: (instance: {
+        stop?(): void;
+    }) => void): Promise<void>;
+    private _assertActive;
     private _cleanupDevice;
     private _requireEntry;
     private _requireNoble;
@@ -247,13 +266,16 @@ interface InitTrezorBleSupportOptions extends NobleBleHandlerOptions {
 interface TrezorBleSupportHandle {
     handler: NobleBleHandler;
     dispose(): Promise<void>;
+    disposeForAppQuit(releaseNoble?: (instance: {
+        stop?(): void;
+    }) => void): Promise<void>;
 }
 /**
  * Wire a `NobleBleHandler` to Electron's IPC so the renderer can drive BLE
  * via `window.desktopApi.trezorBle`. Call once from the main process after
  * `BrowserWindow` is ready.
  *
- * Returns a disposer the caller should invoke on app quit.
+ * Call dispose() when retiring a renderer and disposeForAppQuit() before Node teardown.
  */
 declare function initTrezorBleSupport(webContents: WebContentsLike, options?: InitTrezorBleSupportOptions): TrezorBleSupportHandle;
 

package/dist/main.js

@@ -97,6 +97,11 @@ var NobleBleHandler = class {
     this._connected = /* @__PURE__ */ new Map();
     this._scanning = false;
     this._initialized = false;
+    this._disposed = false;
+    this._nobleInstances = /* @__PURE__ */ new Set();
+    this._pendingCancellations = /* @__PURE__ */ new Set();
+    this._connectAttempts = /* @__PURE__ */ new Set();
+    this._nativeReleased = false;
     this._factory = options.nobleFactory ?? DEFAULT_NOBLE_FACTORY;
     this._uuids = options.uuids ?? import_hwk_trezor_adapter.TREZOR_BLE_UUIDS;
     this._chunkSize = options.chunkSize ?? import_hwk_trezor_adapter.TREZOR_BLE_PACKET_SIZE;
@@ -110,20 +115,34 @@ var NobleBleHandler = class {
     this._onDeviceDisconnected = handler;
   }
   async init() {
+    this._assertActive();
     if (this._initialized) return;
-    this._noble = this._factory();
-    this._discoverHandler = (peripheral) => {
-      this._discovered.set(peripheral.id, peripheral);
-      this._lastSeen.set(peripheral.id, Date.now());
-    };
-    this._noble.on("discover", this._discoverHandler);
-    await this._waitForPoweredOn(TREZOR_BLE_POWER_ON_TIMEOUT_MS);
-    this._initialized = true;
+    if (this._initPromise) return this._initPromise;
+    this._initPromise = (async () => {
+      this._noble ?? (this._noble = this._factory());
+      this._nobleInstances.add(this._noble);
+      this._discoverHandler ?? (this._discoverHandler = (peripheral) => {
+        this._discovered.set(peripheral.id, peripheral);
+        this._lastSeen.set(peripheral.id, Date.now());
+      });
+      this._noble.removeListener("discover", this._discoverHandler);
+      this._noble.on("discover", this._discoverHandler);
+      await this._waitForPoweredOn(TREZOR_BLE_POWER_ON_TIMEOUT_MS);
+      this._assertActive();
+      this._initialized = true;
+    })();
+    try {
+      await this._initPromise;
+    } finally {
+      this._initPromise = void 0;
+    }
   }
   async checkAvailability() {
-    if (!this._initialized) {
+    this._assertActive();
+    if (!this._noble) {
       try {
         this._noble = this._factory();
+        this._nobleInstances.add(this._noble);
       } catch {
         return { available: false, state: "unsupported", initialized: false };
       }
@@ -164,6 +183,7 @@ var NobleBleHandler = class {
         await this._recoverNobleIfStuck(String(error));
       }
     }
+    this._assertActive();
     this._armIdleStop();
     const devices = this._snapshot();
     if (devices.length === 0) {
@@ -217,6 +237,7 @@ var NobleBleHandler = class {
    * app restart that is otherwise the only cure.
    */
   async _recoverNobleIfStuck(reason) {
+    if (this._disposed) return;
     const state = this._noble?.state;
     if (state === "poweredOn" || !this._initialized) return;
     if (this._connected.size > 0) {
@@ -240,6 +261,7 @@ var NobleBleHandler = class {
       }
       const fresh = this._createFreshNoble();
       this._noble = fresh;
+      this._nobleInstances.add(fresh);
       if (this._discoverHandler) {
         fresh.on("discover", this._discoverHandler);
       }
@@ -253,6 +275,7 @@ var NobleBleHandler = class {
     }
   }
   _armIdleStop() {
+    if (this._disposed) return;
     this._clearIdleStop();
     this._idleStopTimer = setTimeout(() => {
       void this._stopContinuousScan();
@@ -345,6 +368,7 @@ var NobleBleHandler = class {
       const finish = (p) => {
         if (done) return;
         done = true;
+        this._pendingCancellations.delete(cancel);
         clearTimeout(timer);
         noble.removeListener("discover", onDiscover);
         void noble.stopScanningAsync().catch(() => void 0);
@@ -355,8 +379,10 @@ var NobleBleHandler = class {
         if (peripheral.id === id) finish(peripheral);
       };
       const timer = setTimeout(() => finish(this._discovered.get(id)), timeoutMs);
+      const cancel = () => finish();
+      this._pendingCancellations.add(cancel);
       noble.on("discover", onDiscover);
-      void noble.startScanningAsync([], false);
+      void noble.startScanningAsync([], false).catch(() => finish());
     });
   }
   /**
@@ -416,10 +442,18 @@ var NobleBleHandler = class {
   // waits for a CoreBluetooth disconnect event that never comes); bound it so a
   // cleanup disconnect can't hang the connect flow.
   async _safeDisconnect(peripheral) {
-    await Promise.race([
-      peripheral.disconnectAsync().catch(() => void 0),
-      delay(BLE_DISCONNECT_TIMEOUT_MS)
-    ]);
+    if (this._nativeReleased) return;
+    let timeout;
+    try {
+      await Promise.race([
+        peripheral.disconnectAsync().catch(() => void 0),
+        new Promise((resolve) => {
+          timeout = setTimeout(resolve, BLE_DISCONNECT_TIMEOUT_MS);
+        })
+      ]);
+    } finally {
+      clearTimeout(timeout);
+    }
   }
   // noble has no connect timeout, so a stale bond hangs anywhere — connectAsync
   // OR the post-connect (encrypted) service discovery. One overall timeout
@@ -427,6 +461,7 @@ var NobleBleHandler = class {
   // out` reject (device unreachable) vs a connectAsync `connection failed`
   // reject (link refused / stale bond) — mapped to different error codes there.
   async connect(id) {
+    this._assertActive();
     const claim = { abandoned: false };
     let abandon;
     const abandoned = new Promise((_, reject) => {
@@ -439,23 +474,37 @@ var NobleBleHandler = class {
       () => abandon(new Error(`connect timed out after ${this._connectTimeoutMs}ms`)),
       this._connectTimeoutMs
     );
-    const attempt = { id, abandon };
+    const attempt = {
+      id,
+      abandon,
+      cancelNative: () => claim.cancelNative?.(),
+      settled: Promise.resolve(void 0)
+    };
     this._activeConnect = attempt;
-    try {
-      return await Promise.race([this._connectInner(id, claim), abandoned]);
-    } catch (error) {
-      const peripheral = this._discovered.get(id);
-      if (peripheral) await this._safeDisconnect(peripheral);
-      throw error;
-    } finally {
-      if (timer) clearTimeout(timer);
-      if (this._activeConnect === attempt) this._activeConnect = void 0;
-    }
+    this._connectAttempts.add(attempt);
+    const nativeOperation = this._connectInner(id, claim);
+    const caller = (async () => {
+      try {
+        return await Promise.race([nativeOperation, abandoned]);
+      } catch (error) {
+        const peripheral = this._discovered.get(id);
+        if (peripheral) await this._safeDisconnect(peripheral);
+        throw error;
+      } finally {
+        clearTimeout(timer);
+        if (this._activeConnect === attempt) this._activeConnect = void 0;
+      }
+    })();
+    attempt.settled = Promise.allSettled([nativeOperation, caller]).finally(() => {
+      this._connectAttempts.delete(attempt);
+    });
+    return caller;
   }
   async _connectInner(id, claim) {
     await this.init();
     await this._pauseScan();
     await delay(BLE_CONNECT_SETTLE_MS);
+    this._assertActive();
     let route = "cache";
     let peripheral = this._discovered.get(id);
     if (!peripheral) {
@@ -466,6 +515,8 @@ var NobleBleHandler = class {
       route = "direct";
     }
     if (!peripheral) {
+      const native2 = this._requireNoble();
+      claim.cancelNative = () => native2.cancelConnect?.(id);
       peripheral = await this._directConnect(id);
     }
     if (!peripheral) {
@@ -478,7 +529,7 @@ var NobleBleHandler = class {
       throw new Error(`Trezor BLE device not found: ${id}`);
     }
     const abortIfAbandoned = async (stage) => {
-      if (!claim.abandoned) return;
+      if (!claim.abandoned && !this._disposed) return;
       if (peripheral && peripheral.state === "connected" && !this._connected.has(id)) {
         await this._safeDisconnect(peripheral);
       }
@@ -487,6 +538,15 @@ var NobleBleHandler = class {
     };
     await abortIfAbandoned("resolve");
     const wasConnected = peripheral.state === "connected";
+    const connectingPeripheral = peripheral;
+    const native = this._requireNoble();
+    claim.cancelNative = () => {
+      if (connectingPeripheral.state === "connecting" && connectingPeripheral.cancelConnect) {
+        connectingPeripheral.cancelConnect();
+      } else {
+        native.cancelConnect?.(id);
+      }
+    };
     this._log("warn", "connect.route", {
       id,
       route,
@@ -572,6 +632,7 @@ var NobleBleHandler = class {
     if (!entry.writeChar) throw new Error(`Trezor BLE write char missing for ${id}`);
     const buffer = Buffer.from(hexData, "hex");
     for (let offset = 0; offset < buffer.length; offset += this._chunkSize) {
+      this._assertActive();
       const slice = buffer.subarray(offset, offset + this._chunkSize);
       const chunk = Buffer.alloc(this._chunkSize);
       slice.copy(chunk);
@@ -581,22 +642,98 @@ var NobleBleHandler = class {
       }
     }
   }
-  /** Tear down all active connections — called on app quit. */
-  async dispose() {
+  /** Retire a renderer's handler without stopping a process-wide native manager. */
+  dispose() {
+    if (this._disposePromise) return this._disposePromise;
+    this._disposed = true;
     this._clearIdleStop();
     this._scanning = false;
-    for (const id of Array.from(this._connected.keys())) {
-      await this.disconnect(id);
+    this._onNotification = void 0;
+    this._onDeviceDisconnected = void 0;
+    const connections = Array.from(this._connectAttempts);
+    for (const attempt of connections) {
+      attempt.abandon(new Error("Trezor BLE is shutting down"));
+      try {
+        attempt.cancelNative();
+      } catch (error) {
+        this._log("warn", "dispose.cancelConnect.error", { error: String(error) });
+      }
     }
+    for (const cancel of this._pendingCancellations) cancel();
     if (this._noble && this._discoverHandler) {
       this._noble.removeListener("discover", this._discoverHandler);
     }
-    if (this._noble && this._stateChangeHandler) {
-      this._noble.removeListener("stateChange", this._stateChangeHandler);
+    const entries = Array.from(this._connected.entries());
+    for (const [id, entry] of entries) {
+      if (entry.disconnectHandler) {
+        entry.peripheral.removeListener("disconnect", entry.disconnectHandler);
+      }
+      this._cleanupDevice(id, false);
     }
-    this._discovered.clear();
-    this._lastSeen.clear();
-    this._initialized = false;
+    let timeout;
+    this._disposePromise = (async () => {
+      try {
+        await Promise.race([
+          Promise.allSettled([
+            ...connections.map((attempt) => attempt.settled),
+            ...Array.from(this._nobleInstances, async (instance) => instance.stopScanningAsync()),
+            ...entries.map(async ([, entry]) => {
+              let unsubscribeTimeout;
+              try {
+                await Promise.race([
+                  entry.notifyChar?.unsubscribeAsync().catch(() => void 0),
+                  new Promise((resolve) => {
+                    unsubscribeTimeout = setTimeout(resolve, 250);
+                  })
+                ]);
+              } finally {
+                clearTimeout(unsubscribeTimeout);
+                await this._safeDisconnect(entry.peripheral);
+              }
+            })
+          ]),
+          new Promise((resolve) => {
+            timeout = setTimeout(() => {
+              this._log("warn", "dispose.timeout");
+              resolve();
+            }, 3500);
+          })
+        ]);
+      } finally {
+        clearTimeout(timeout);
+        this._discovered.clear();
+        this._lastSeen.clear();
+        this._initialized = false;
+      }
+    })();
+    return this._disposePromise;
+  }
+  /**
+   * Terminal native release, including instances replaced by adapter recovery.
+   * A host sharing Noble must defer stop() until all transports have disposed,
+   * and deduplicate instances passed to releaseNoble across those transports.
+   */
+  disposeForAppQuit(releaseNoble = (instance) => instance.stop?.()) {
+    if (!this._releasePromise) {
+      this._releasePromise = this.dispose().finally(() => {
+        this._nativeReleased = true;
+        let releaseError;
+        for (const instance of this._nobleInstances) {
+          try {
+            releaseNoble(instance);
+          } catch (error) {
+            releaseError = error instanceof Error ? error : new Error(String(error));
+          }
+        }
+        this._nobleInstances.clear();
+        if (releaseError) throw releaseError;
+        this._log("info", "dispose.native.done");
+      });
+    }
+    return this._releasePromise;
+  }
+  _assertActive() {
+    if (this._disposed) throw new Error("Trezor BLE is shutting down");
   }
   _cleanupDevice(id, unexpected) {
     const entry = this._connected.get(id);
@@ -611,11 +748,13 @@ var NobleBleHandler = class {
     }
   }
   _requireEntry(id) {
+    this._assertActive();
     const entry = this._connected.get(id);
     if (!entry) throw new Error(`Trezor BLE device is not connected: ${id}`);
     return entry;
   }
   _requireNoble() {
+    this._assertActive();
     if (!this._noble) throw new Error("Trezor BLE: noble was not initialized");
     return this._noble;
   }
@@ -623,8 +762,17 @@ var NobleBleHandler = class {
     const noble = this._requireNoble();
     if (noble.state === "poweredOn") return;
     await new Promise((resolve, reject) => {
+      const cleanup = () => {
+        clearTimeout(timer);
+        noble.removeListener("stateChange", handler);
+        this._pendingCancellations.delete(cancel);
+      };
+      const cancel = () => {
+        cleanup();
+        reject(new Error("Trezor BLE is shutting down"));
+      };
       const timer = setTimeout(() => {
-        if (this._stateChangeHandler) noble.removeListener("stateChange", this._stateChangeHandler);
+        cleanup();
         reject(
           new Error(
             `Trezor BLE: noble did not reach poweredOn within ${timeoutMs}ms (last state: ${noble.state})`
@@ -633,16 +781,14 @@ var NobleBleHandler = class {
       }, timeoutMs);
       const handler = (state) => {
         if (state === "poweredOn") {
-          clearTimeout(timer);
+          cleanup();
           resolve();
         } else if (state === "unsupported" || state === "unauthorized") {
-          clearTimeout(timer);
-          if (this._stateChangeHandler)
-            noble.removeListener("stateChange", this._stateChangeHandler);
+          cleanup();
           reject(new Error(`Trezor BLE: noble state ${state}`));
         }
       };
-      this._stateChangeHandler = handler;
+      this._pendingCancellations.add(cancel);
       noble.on("stateChange", handler);
     });
   }
@@ -661,6 +807,7 @@ var DEFAULT_IPC_MAIN = () => {
 function initTrezorBleSupport(webContents, options = {}) {
   const ipcMain = options.ipcMain ?? DEFAULT_IPC_MAIN();
   const handler = new NobleBleHandler(options);
+  let disposed = false;
   handler.setNotificationListener((id, hexData) => {
     webContents.send(TREZOR_BLE_CHANNELS.notification, id, hexData);
   });
@@ -668,7 +815,10 @@ function initTrezorBleSupport(webContents, options = {}) {
     webContents.send(TREZOR_BLE_CHANNELS.disconnected, id);
   });
   const handle = (channel, fn) => {
-    ipcMain.handle(channel, async (_event, ...args) => fn(...args));
+    ipcMain.handle(channel, async (_event, ...args) => {
+      if (disposed) throw new Error("Trezor BLE is shutting down");
+      return fn(...args);
+    });
   };
   handle(
     TREZOR_BLE_CHANNELS.scan,
@@ -684,13 +834,22 @@ function initTrezorBleSupport(webContents, options = {}) {
   handle(TREZOR_BLE_CHANNELS.getDevice, (id) => handler.getDevice(id));
   handle(TREZOR_BLE_CHANNELS.readRssi, (id) => handler.readRssi(id));
   handle(TREZOR_BLE_CHANNELS.cancelPairing, () => handler.cancelPairing());
+  const removeHandlers = () => {
+    if (disposed) return;
+    disposed = true;
+    for (const channel of Object.values(TREZOR_BLE_CHANNELS)) {
+      ipcMain.removeHandler(channel);
+    }
+  };
   return {
     handler,
-    dispose: async () => {
-      for (const channel of Object.values(TREZOR_BLE_CHANNELS)) {
-        ipcMain.removeHandler(channel);
-      }
-      await handler.dispose();
+    dispose: () => {
+      removeHandlers();
+      return handler.dispose();
+    },
+    disposeForAppQuit: (releaseNoble) => {
+      removeHandlers();
+      return handler.disposeForAppQuit(releaseNoble);
     }
   };
 }