@onekeyfe/hd-transport-web-device 1.2.8-alpha.14 → 1.2.8-alpha.16

package/__tests__/webusb-identity-probe.test.ts

@@ -1,7 +1,37 @@
+import { ERRORS, HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
+
 import WebUsbTransport from '../src/webusb';
+import { probeUsbDeviceIdentities } from '@onekeyfe/hd-common-connect-sdk/src';
 
 import type { MessageFromOneKey, TransportCallOptions } from '@onekeyfe/hd-transport';
 
+jest.mock('@onekeyfe/hd-core', () => jest.requireActual('../../core/src'));
+jest.mock('../../core/src/data/config', () => ({
+  getSDKVersion: () => '1.0.0-test',
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0-test/',
+}));
+jest.mock('@onekeyfe/hd-transport-web-device', () => ({
+  WebUsbTransport: jest.requireActual('../src/webusb').default,
+}));
+jest.mock('@onekeyfe/hd-transport-http', () => ({ __esModule: true, default: jest.fn() }));
+jest.mock('@onekeyfe/hd-transport-lowlevel', () => ({}));
+jest.mock('@onekeyfe/hd-transport-emulator', () => ({}));
+
+type PacketIoTransport = {
+  rotateProtocolV2UsbGeneration: () => Promise<void>;
+  detectProtocol: () => Promise<'V1'>;
+  transferInWithRetry: (path: string, length: number) => Promise<DataView>;
+  transferInOnce: (path: string, length: number) => Promise<DataView>;
+  transferOutWithRetry: (path: string, packet: Uint8Array) => Promise<void>;
+  transferOutOnce: (path: string, packet: Uint8Array) => Promise<void>;
+  reconnectForPacketIoRetry: (
+    path: string,
+    direction: 'in' | 'out',
+    attempt: number,
+    error: unknown
+  ) => Promise<void>;
+};
+
 describe('WebUSB identity probe ownership', () => {
   let originalNavigator: PropertyDescriptor | undefined;
   const device = {
@@ -21,7 +51,10 @@ describe('WebUSB identity probe ownership', () => {
   beforeEach(() => {
     originalNavigator = Object.getOwnPropertyDescriptor(globalThis, 'navigator');
     device.opened = false;
-    device.close.mockClear();
+    device.close.mockReset().mockImplementation(() => {
+      device.opened = false;
+      return Promise.resolve();
+    });
     usb.getDevices.mockResolvedValue([device]);
     usb.addEventListener.mockClear();
     Object.defineProperty(globalThis, 'navigator', { configurable: true, value: { usb } });
@@ -77,6 +110,7 @@ describe('WebUSB identity probe ownership', () => {
     expect(device.close).not.toHaveBeenCalled();
     finishOpen();
     await connecting;
+    await active.release('USB_PATH');
   });
 
   test('a normal connection cannot close an isolated probe handle and release closes the captured handle after re-enumeration', async () => {
@@ -102,8 +136,10 @@ describe('WebUSB identity probe ownership', () => {
     const replacement = { ...device, close: jest.fn() };
     usb.getDevices.mockResolvedValue([replacement]);
     await probe.getConnectedDevices();
-    await probe.release('USB_PATH');
-    expect(device.close).toHaveBeenCalledTimes(1);
+    device.close.mockRejectedValueOnce(new Error('native close failed'));
+    await expect(probe.release('USB_PATH')).rejects.toThrow('native close failed');
+    await probe.enumerate();
+    expect(device.close).toHaveBeenCalledTimes(2);
     expect(replacement.close).not.toHaveBeenCalled();
   });
 
@@ -119,6 +155,345 @@ describe('WebUSB identity probe ownership', () => {
     expect(probeDisconnect).not.toHaveBeenCalled();
   });
 
+  test.each(['release', 'acquire failure'])(
+    'keeps a probe handle protected after close fails during %s and recovers after cleanup',
+    async phase => {
+      Object.assign(device, {
+        open: jest.fn(() => {
+          device.opened = true;
+          return Promise.resolve();
+        }),
+        releaseInterface: jest.fn().mockResolvedValue(undefined),
+        reset: jest.fn(),
+        configurations: [],
+        configuration: { configurationValue: 1 },
+        selectConfiguration: jest.fn(),
+        claimInterface: jest.fn(),
+        clearHalt: jest.fn(),
+      });
+      const probe = new WebUsbTransport(true);
+      probe.init({ debug: jest.fn() });
+      const internals = probe as unknown as {
+        rotateProtocolV2UsbGeneration: () => Promise<void>;
+        detectProtocol: () => Promise<'V1'>;
+      };
+      jest.spyOn(internals, 'rotateProtocolV2UsbGeneration').mockResolvedValue(undefined);
+      jest.spyOn(internals, 'detectProtocol').mockResolvedValue('V1');
+      jest.spyOn(probe, 'connect').mockImplementation(() => {
+        device.opened = true;
+        if (phase === 'acquire failure') return Promise.reject(new Error('probe failed'));
+        return Promise.resolve();
+      });
+      const closeFailure = new Error('native close failed');
+      device.close.mockRejectedValueOnce(closeFailure);
+      if (phase === 'release') {
+        await probe.acquire({ path: 'USB_PATH' });
+        await expect(probe.release('USB_PATH')).rejects.toBe(closeFailure);
+      } else {
+        await expect(probe.acquire({ path: 'USB_PATH' })).rejects.toBe(closeFailure);
+      }
+      expect(device.opened).toBe(true);
+      const active = new WebUsbTransport();
+      active.init({ debug: jest.fn() });
+      await expect(active.connectToDevice('USB_PATH', true)).rejects.toThrow(
+        'USB device is already in use'
+      );
+      expect(device.close).toHaveBeenCalledTimes(1);
+
+      await probe.release('USB_PATH');
+      expect(device.opened).toBe(false);
+      await expect(active.connectToDevice('USB_PATH', true)).resolves.toBeUndefined();
+      expect(device.opened).toBe(true);
+      await active.release('USB_PATH');
+    }
+  );
+
+  test.each(['release', 'acquire failure'])(
+    'the public probe retries failed %s cleanup on its next call',
+    async phase => {
+      const internals = WebUsbTransport.prototype as unknown as {
+        rotateProtocolV2UsbGeneration: () => Promise<void>;
+        detectProtocol: () => Promise<'V1'>;
+      };
+      jest.spyOn(internals, 'rotateProtocolV2UsbGeneration').mockResolvedValue(undefined);
+      jest.spyOn(internals, 'detectProtocol').mockResolvedValue('V1');
+      jest.spyOn(WebUsbTransport.prototype, 'getProtocolType').mockReturnValue('V1');
+      jest.spyOn(WebUsbTransport.prototype, 'configure').mockImplementation(() => undefined);
+      jest
+        .spyOn(WebUsbTransport.prototype, 'configureProtocolV2')
+        .mockImplementation(() => undefined);
+      const connect = jest.spyOn(WebUsbTransport.prototype, 'connect').mockImplementation(() => {
+        device.opened = true;
+        return Promise.resolve();
+      });
+      if (phase === 'acquire failure') {
+        connect.mockImplementationOnce(() => {
+          device.opened = true;
+          return Promise.reject(new Error('probe failed'));
+        });
+      }
+      jest.spyOn(WebUsbTransport.prototype, 'call').mockResolvedValue({
+        type: 'Features',
+        message: { onekey_serial_no: 'PHYSICAL_SERIAL', onekey_device_type: 'CLASSIC1S' },
+      });
+      device.close.mockRejectedValueOnce(new Error('native close failed'));
+      try {
+        await expect(probeUsbDeviceIdentities({ commType: 'webusb' })).resolves.toEqual([]);
+        expect(device.opened).toBe(true);
+        const active = new WebUsbTransport();
+        active.init({ debug: jest.fn() });
+        await expect(active.connectToDevice('USB_PATH', true)).rejects.toThrow(
+          'USB device is already in use'
+        );
+        device.close.mockRejectedValueOnce(new Error('native close still failing'));
+        await expect(probeUsbDeviceIdentities({ commType: 'webusb' })).resolves.toEqual([]);
+        expect(device.opened).toBe(true);
+        expect(connect).toHaveBeenCalledTimes(1);
+        expect(device.close).toHaveBeenCalledTimes(2);
+        await expect(probeUsbDeviceIdentities({ commType: 'webusb' })).resolves.toMatchObject([
+          { path: 'USB_PATH', serialNo: 'PHYSICAL_SERIAL' },
+        ]);
+        expect(connect).toHaveBeenCalledTimes(2);
+        expect(device.opened).toBe(false);
+      } finally {
+        jest.restoreAllMocks();
+      }
+    }
+  );
+
+  test.each(['in', 'out'] as const)(
+    'the public probe cannot take over a first acquire while transfer%s recovery has closed the handle',
+    async direction => {
+      const closed = createDeferred<void>();
+      const resume = createDeferred<void>();
+      Object.assign(device, {
+        open: jest.fn(() => {
+          device.opened = true;
+          return Promise.resolve();
+        }),
+        releaseInterface: jest.fn(),
+        reset: jest.fn(),
+        configurations: [],
+        configuration: { configurationValue: 1 },
+        selectConfiguration: jest.fn(),
+        claimInterface: jest.fn(),
+        clearHalt: jest.fn(),
+        transferIn: jest
+          .fn()
+          .mockResolvedValue({ status: 'ok', data: new DataView(new ArrayBuffer(64)) }),
+        transferOut: jest.fn().mockResolvedValue({ status: 'ok' }),
+      });
+      const native = device as typeof device & { transferIn: jest.Mock; transferOut: jest.Mock };
+      native[direction === 'in' ? 'transferIn' : 'transferOut'].mockRejectedValueOnce(
+        new Error(`transfer${direction} NetworkError`)
+      );
+      device.close.mockImplementationOnce(async () => {
+        device.opened = false;
+        closed.resolve();
+        await resume.promise;
+      });
+      const active = new WebUsbTransport();
+      active.init({ debug: jest.fn() });
+      const internals = active as unknown as PacketIoTransport;
+      jest
+        .spyOn(
+          WebUsbTransport.prototype as unknown as PacketIoTransport,
+          'rotateProtocolV2UsbGeneration'
+        )
+        .mockResolvedValue(undefined);
+      jest
+        .spyOn(WebUsbTransport.prototype as unknown as PacketIoTransport, 'detectProtocol')
+        .mockImplementation(async function (this: WebUsbTransport) {
+          if (this !== active) return 'V1';
+          if (direction === 'in') await internals.transferInWithRetry('USB_PATH', 64);
+          else await internals.transferOutWithRetry('USB_PATH', new Uint8Array([1]));
+          return 'V1';
+        });
+      jest.spyOn(WebUsbTransport.prototype, 'getProtocolType').mockReturnValue('V1');
+      jest.spyOn(WebUsbTransport.prototype, 'configure').mockImplementation(() => undefined);
+      jest
+        .spyOn(WebUsbTransport.prototype, 'configureProtocolV2')
+        .mockImplementation(() => undefined);
+      jest
+        .spyOn(WebUsbTransport.prototype, 'connect')
+        .mockImplementation(async function (this: WebUsbTransport, path, first) {
+          if (this === active && !first) return this.connectToDevice(path, first);
+          device.opened = true;
+        });
+      jest.spyOn(WebUsbTransport.prototype, 'call').mockResolvedValue({
+        type: 'Features',
+        message: { onekey_serial_no: 'PHYSICAL_SERIAL', onekey_device_type: 'CLASSIC1S' },
+      });
+      try {
+        const acquiring = active.acquire({ path: 'USB_PATH' });
+        try {
+          await closed.promise;
+          await expect(probeUsbDeviceIdentities({ commType: 'webusb' })).resolves.toEqual([]);
+          resume.resolve();
+          await expect(acquiring).resolves.toBe('USB_PATH');
+        } finally {
+          resume.resolve();
+          await acquiring.catch(() => undefined);
+          await active.release('USB_PATH');
+        }
+        await expect(probeUsbDeviceIdentities({ commType: 'webusb' })).resolves.toMatchObject([
+          { serialNo: 'PHYSICAL_SERIAL' },
+        ]);
+      } finally {
+        jest.restoreAllMocks();
+      }
+    }
+  );
+
+  test('releases ownership after a failed normal acquire', async () => {
+    const active = new WebUsbTransport();
+    const probe = new WebUsbTransport(true);
+    active.init({ debug: jest.fn() });
+    probe.init({ debug: jest.fn() });
+    const state = active as unknown as PacketIoTransport;
+    jest.spyOn(state, 'rotateProtocolV2UsbGeneration').mockResolvedValue(undefined);
+    jest.spyOn(active, 'connect').mockImplementation(() => {
+      device.opened = true;
+      return Promise.resolve();
+    });
+    jest.spyOn(state, 'detectProtocol').mockRejectedValue(new Error('protocol failed'));
+    await expect(active.acquire({ path: 'USB_PATH' })).rejects.toThrow('protocol failed');
+    expect(device.opened).toBe(false);
+    const probeState = probe as unknown as PacketIoTransport;
+    jest.spyOn(probeState, 'rotateProtocolV2UsbGeneration').mockResolvedValue(undefined);
+    jest.spyOn(probeState, 'detectProtocol').mockResolvedValue('V1');
+    jest.spyOn(probe, 'connect').mockImplementation(() => {
+      device.opened = true;
+      return Promise.resolve();
+    });
+    try {
+      await expect(probe.acquire({ path: 'USB_PATH' })).resolves.toBe('USB_PATH');
+    } finally {
+      await probe.release('USB_PATH');
+    }
+  });
+
+  test('releasing one path preserves another closed handle owned by the same transport', async () => {
+    const other = {
+      ...device,
+      serialNumber: 'OTHER_PATH',
+      opened: false,
+      close: jest.fn(() => {
+        other.opened = false;
+        return Promise.resolve();
+      }),
+    };
+    usb.getDevices.mockResolvedValue([device, other]);
+    const active = new WebUsbTransport();
+    active.init({ debug: jest.fn() });
+    const state = active as unknown as PacketIoTransport;
+    jest.spyOn(state, 'rotateProtocolV2UsbGeneration').mockResolvedValue(undefined);
+    jest.spyOn(state, 'detectProtocol').mockResolvedValue('V1');
+    jest.spyOn(active, 'connect').mockImplementation(path => {
+      const target = path === 'USB_PATH' ? device : other;
+      target.opened = true;
+      return Promise.resolve();
+    });
+    await active.acquire({ path: 'USB_PATH' });
+    await active.acquire({ path: 'OTHER_PATH' });
+    await active.release('USB_PATH');
+    other.opened = false;
+    const probe = new WebUsbTransport(true);
+    probe.init({ debug: jest.fn() });
+    const probeState = probe as unknown as PacketIoTransport;
+    jest.spyOn(probeState, 'rotateProtocolV2UsbGeneration').mockResolvedValue(undefined);
+    jest.spyOn(probeState, 'detectProtocol').mockResolvedValue('V1');
+    jest.spyOn(probe, 'connect').mockImplementation(path => {
+      const target = path === 'USB_PATH' ? device : other;
+      target.opened = true;
+      return Promise.resolve();
+    });
+    try {
+      await expect(probe.acquire({ path: 'USB_PATH' })).resolves.toBe('USB_PATH');
+      await expect(probe.acquire({ path: 'OTHER_PATH' })).rejects.toThrow(
+        'USB device is already in use'
+      );
+    } finally {
+      await active.release('OTHER_PATH');
+      await probe.release('USB_PATH');
+    }
+  });
+
+  test.each(['read', 'read retry', 'write', 'write retry', 'retry cleanup'])(
+    'blocks native %s while an isolated probe owns the handle',
+    async operation => {
+      const probe = new WebUsbTransport(true);
+      probe.init({ debug: jest.fn() });
+      const probeState = probe as unknown as PacketIoTransport;
+      jest.spyOn(probeState, 'rotateProtocolV2UsbGeneration').mockResolvedValue(undefined);
+      jest.spyOn(probeState, 'detectProtocol').mockResolvedValue('V1');
+      jest.spyOn(probe, 'connect').mockImplementation(() => {
+        device.opened = true;
+        return Promise.resolve();
+      });
+      const native = Object.assign(device, {
+        releaseInterface: jest.fn(),
+        transferIn: jest
+          .fn()
+          .mockResolvedValue({ status: 'ok', data: new DataView(new ArrayBuffer(64)) }),
+        transferOut: jest.fn().mockResolvedValue({ status: 'ok' }),
+      });
+      await probe.acquire({ path: 'USB_PATH' });
+      const active = new WebUsbTransport();
+      active.init({ debug: jest.fn() });
+      const state = active as unknown as PacketIoTransport;
+      try {
+        let call: Promise<unknown>;
+        if (operation === 'read') call = state.transferInOnce('USB_PATH', 64);
+        else if (operation === 'read retry') call = state.transferInWithRetry('USB_PATH', 64);
+        else if (operation === 'write')
+          call = state.transferOutOnce('USB_PATH', new Uint8Array([1]));
+        else if (operation === 'write retry')
+          call = state.transferOutWithRetry('USB_PATH', new Uint8Array([1]));
+        else
+          call = state.reconnectForPacketIoRetry(
+            'USB_PATH',
+            'in',
+            0,
+            new Error('transferIn failed')
+          );
+        await expect(call).rejects.toThrow('USB device is already in use');
+        expect(native.transferIn).not.toHaveBeenCalled();
+        expect(native.transferOut).not.toHaveBeenCalled();
+        expect(native.releaseInterface).not.toHaveBeenCalled();
+        expect(device.close).not.toHaveBeenCalled();
+      } finally {
+        await probe.release('USB_PATH');
+      }
+    }
+  );
+
+  test.each(['in', 'out'] as const)(
+    'ends transfer%s immediately if reconnect reports an ownership conflict',
+    async direction => {
+      const active = new WebUsbTransport();
+      active.init({ debug: jest.fn() });
+      device.opened = true;
+      const native = Object.assign(device, {
+        transferIn: jest.fn().mockRejectedValue(new Error('transferIn NetworkError')),
+        transferOut: jest.fn().mockRejectedValue(new Error('transferOut NetworkError')),
+      });
+      const state = active as unknown as PacketIoTransport;
+      const conflict = ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'USB device is already in use'
+      );
+      const reconnect = jest.spyOn(state, 'reconnectForPacketIoRetry').mockRejectedValue(conflict);
+      const call =
+        direction === 'in'
+          ? state.transferInWithRetry('USB_PATH', 64)
+          : state.transferOutWithRetry('USB_PATH', new Uint8Array([1]));
+      await expect(call).rejects.toBe(conflict);
+      expect(reconnect).toHaveBeenCalledTimes(1);
+      expect(native[direction === 'in' ? 'transferIn' : 'transferOut']).toHaveBeenCalledTimes(1);
+    }
+  );
+
   test.each([false, true])(
     'uses a read-only V1 probe only for isolated discovery (%s)',
     async identityProbe => {

package/dist/index.d.ts

@@ -31,6 +31,8 @@ declare class WebUsbTransport extends ProtocolV2UsbTransportBase<string> {
     /** Paths currently acquired (between a successful acquire() and its release()). */
     private acquiredPaths;
     private identityProbeDevices;
+    private normalDevices;
+    private identityProbeCleanupPaths;
     /**
      * The exact USBDevice object each cached protocol was probed against. The
      * browser returns the same object identity for a device as long as it stays
@@ -132,6 +134,9 @@ declare class WebUsbTransport extends ProtocolV2UsbTransportBase<string> {
      */
     connectToDevice(path: string, first: boolean): Promise<undefined>;
     private assertHandleAvailable;
+    private claimNormalHandle;
+    private releaseNormalHandles;
+    private isHandleOwnershipError;
     private claimIdentityProbeHandle;
     private releaseIdentityProbeHandle;
     private closeOpenDevice;

package/dist/index.js

@@ -51,6 +51,7 @@ const REPORT_ID = transport.PROTOCOL_V1_REPORT_ID;
 const HEADER_LENGTH = transport.PROTOCOL_V1_MESSAGE_HEADER_SIZE;
 const PACKET_IO_MAX_RETRIES = 3;
 const PACKET_IO_RETRY_DELAY = 300;
+const USB_DEVICE_IN_USE = 'USB device is already in use';
 const PROTOCOL_V1_PROBE_TIMEOUT = 5000;
 const PROTOCOL_V2_PROBE_TIMEOUT = 1000;
 const EXPECTED_PROTOCOL_V2_PROBE_ATTEMPTS = 2;
@@ -58,6 +59,7 @@ let activeWebUsbTransport;
 let usbDisconnectListenerAttached = false;
 const identityProbeHandles = new WeakSet();
 const openingHandles = new WeakSet();
+const normalHandleOwners = new WeakMap();
 function registerActiveWebUsbTransport(instance, usb) {
     activeWebUsbTransport = instance;
     if (usbDisconnectListenerAttached)
@@ -87,6 +89,8 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
         this.staleProtocolPaths = new Set();
         this.acquiredPaths = new Set();
         this.identityProbeDevices = new Map();
+        this.normalDevices = new Map();
+        this.identityProbeCleanupPaths = new Set();
         this.probedDeviceObjects = new Map();
         this.deviceEndpoints = new Map();
         this.name = 'WebUsbTransport';
@@ -155,6 +159,13 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
     }
     enumerate() {
         return __awaiter(this, void 0, void 0, function* () {
+            for (const path of this.identityProbeCleanupPaths) {
+                try {
+                    yield this.release(path);
+                }
+                catch (_a) {
+                }
+            }
             yield this.getConnectedDevices();
             return this.deviceList;
         });
@@ -196,6 +207,9 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
                 yield this.getConnectedDevices();
                 this.claimIdentityProbeHandle(input.path, yield this.findDevice(input.path));
             }
+            else {
+                this.claimNormalHandle(input.path, yield this.findDevice(input.path));
+            }
             try {
                 yield this.rotateProtocolV2UsbGeneration(input.path, 'WebUSB transport acquired');
                 yield this.closeOpenDevice(input.path);
@@ -262,6 +276,7 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
                 }
                 finally {
                     this.releaseIdentityProbeHandle(input.path);
+                    this.releaseNormalHandles(input.path);
                 }
                 throw e;
             }
@@ -394,6 +409,8 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
                 this.releaseIdentityProbeHandle(path);
                 this.claimIdentityProbeHandle(path, device);
             }
+            if (!this.identityProbe)
+                this.claimNormalHandle(path, device);
             this.assertHandleAvailable(device);
             if (!device.opened) {
                 openingHandles.add(device);
@@ -422,6 +439,8 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
                 this.releaseIdentityProbeHandle(path);
                 this.claimIdentityProbeHandle(path, device);
             }
+            if (!this.identityProbe)
+                this.claimNormalHandle(path, device);
             this.assertHandleAvailable(device);
             if (!device.opened) {
                 openingHandles.add(device);
@@ -453,23 +472,51 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
         });
     }
     assertHandleAvailable(device) {
-        if (identityProbeHandles.has(device) &&
-            ![...this.identityProbeDevices.values()].includes(device)) {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'USB device is already in use');
+        const normalOwner = normalHandleOwners.get(device);
+        if ((normalOwner && normalOwner !== this) ||
+            (identityProbeHandles.has(device) &&
+                ![...this.identityProbeDevices.values()].includes(device))) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, USB_DEVICE_IN_USE);
+        }
+    }
+    claimNormalHandle(path, device) {
+        this.assertHandleAvailable(device);
+        normalHandleOwners.set(device, this);
+        this.normalDevices.set(device, path);
+    }
+    releaseNormalHandles(path) {
+        for (const [device, ownedPath] of this.normalDevices) {
+            if (ownedPath === path) {
+                normalHandleOwners.delete(device);
+                this.normalDevices.delete(device);
+            }
         }
     }
+    isHandleOwnershipError(error) {
+        return (error instanceof hdShared.HardwareError &&
+            error.errorCode === hdShared.HardwareErrorCode.RuntimeError &&
+            this.getErrorMessage(error).includes(USB_DEVICE_IN_USE));
+    }
     claimIdentityProbeHandle(path, device) {
-        if (device.opened || openingHandles.has(device) || identityProbeHandles.has(device)) {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'USB device is already in use');
+        if (device.opened ||
+            openingHandles.has(device) ||
+            identityProbeHandles.has(device) ||
+            normalHandleOwners.has(device)) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, USB_DEVICE_IN_USE);
         }
         identityProbeHandles.add(device);
         this.identityProbeDevices.set(path, device);
     }
     releaseIdentityProbeHandle(path) {
         const device = this.identityProbeDevices.get(path);
+        if (device === null || device === void 0 ? void 0 : device.opened) {
+            this.identityProbeCleanupPaths.add(path);
+            return;
+        }
         if (device)
             identityProbeHandles.delete(device);
         this.identityProbeDevices.delete(path);
+        this.identityProbeCleanupPaths.delete(path);
     }
     closeOpenDevice(path) {
         var _a, _b, _c, _d;
@@ -488,6 +535,7 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             catch (error) {
                 (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug('[WebUsbTransport] releaseInterface before reconnect failed:', error);
             }
+            this.assertHandleAvailable(current);
             try {
                 yield current.close();
             }
@@ -501,6 +549,7 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
     clearEndpointHalt(device, direction, endpointNumber) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            this.assertHandleAvailable(device);
             try {
                 yield device.clearHalt(direction, endpointNumber);
             }
@@ -566,7 +615,7 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
     throwWebUsbIoError(path, operation, error) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.isWebUsbIoHardwareError(error))
+            if (this.isHandleOwnershipError(error) || this.isWebUsbIoHardwareError(error))
                 throw error;
             if (error instanceof transport.ProtocolV2LinkError && error.code !== 'io')
                 throw error;
@@ -600,7 +649,7 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
         return /LIBUSB_ERROR_ACCESS|\b(?:access|permission) denied\b/i.test(message);
     }
     isRetryablePacketIoError(error) {
-        if (this.isWebUsbIoHardwareError(error))
+        if (this.isHandleOwnershipError(error) || this.isWebUsbIoHardwareError(error))
             return false;
         const message = this.getErrorMessage(error).toLowerCase();
         if (this.isWebUsbPermissionDeniedMessage(message))
@@ -621,6 +670,7 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             yield hdShared.wait(attempt * PACKET_IO_RETRY_DELAY);
             try {
                 const currentDevice = yield this.findDevice(path);
+                this.assertHandleAvailable(currentDevice);
                 if (currentDevice.opened) {
                     const endpoints = this.deviceEndpoints.get(path);
                     const ifaceNum = (_a = endpoints === null || endpoints === void 0 ? void 0 : endpoints.interfaceNumber) !== null && _a !== void 0 ? _a : this.interfaceId;
@@ -630,10 +680,13 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
                     catch (releaseError) {
                         this.Log.debug('[WebUsbTransport] releaseInterface before retry error:', releaseError);
                     }
+                    this.assertHandleAvailable(currentDevice);
                     yield currentDevice.close();
                 }
             }
             catch (closeError) {
+                if (this.isHandleOwnershipError(closeError))
+                    throw closeError;
                 this.Log.debug('[WebUsbTransport] close device before retry error:', closeError);
             }
             yield this.getConnectedDevices();
@@ -675,6 +728,8 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
                         yield this.reconnectForPacketIoRetry(path, 'out', attempt, error);
                     }
                     catch (reconnectError) {
+                        if (this.isHandleOwnershipError(reconnectError))
+                            throw reconnectError;
                         lastError = reconnectError;
                         this.Log.debug(`[WebUsbTransport] transferout reconnect failed on retry ${attempt}/${PACKET_IO_MAX_RETRIES}: ${this.getErrorMessage(reconnectError)}`);
                     }
@@ -693,6 +748,7 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             const endpoints = this.deviceEndpoints.get(path);
             const endpointOut = (_a = endpoints === null || endpoints === void 0 ? void 0 : endpoints.endpointOut) !== null && _a !== void 0 ? _a : this.endpointId;
             const transferBuffer = this.toArrayBuffer(packet.buffer.slice(packet.byteOffset, packet.byteOffset + packet.byteLength));
+            this.assertHandleAvailable(device);
             const result = yield device.transferOut(endpointOut, transferBuffer);
             if (result.status !== 'ok') {
                 return this.throwWebUsbIoError(path, 'transferOut', new Error(`transferOut status: ${String(result.status)}`));
@@ -714,6 +770,7 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
                     }
                     const endpoints = this.deviceEndpoints.get(path);
                     const endpointIn = (_a = endpoints === null || endpoints === void 0 ? void 0 : endpoints.endpointIn) !== null && _a !== void 0 ? _a : this.endpointId;
+                    this.assertHandleAvailable(device);
                     const result = yield device.transferIn(endpointIn, length);
                     return this.getTransferInData(result);
                 }
@@ -730,6 +787,8 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
                         yield this.reconnectForPacketIoRetry(path, 'in', attempt, error);
                     }
                     catch (reconnectError) {
+                        if (this.isHandleOwnershipError(reconnectError))
+                            throw reconnectError;
                         lastError = reconnectError;
                         this.Log.debug(`[WebUsbTransport] transferin reconnect failed on retry ${attempt}/${PACKET_IO_MAX_RETRIES}: ${this.getErrorMessage(reconnectError)}`);
                     }
@@ -747,6 +806,7 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             }
             const endpoints = this.deviceEndpoints.get(path);
             const endpointIn = (_a = endpoints === null || endpoints === void 0 ? void 0 : endpoints.endpointIn) !== null && _a !== void 0 ? _a : this.endpointId;
+            this.assertHandleAvailable(device);
             const result = yield device.transferIn(endpointIn, length);
             return this.getTransferInData(result);
         });
@@ -933,6 +993,7 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             }
             finally {
                 this.releaseIdentityProbeHandle(path);
+                this.releaseNormalHandles(path);
             }
             this.deviceEndpoints.delete(path);
         });

package/dist/webusb.d.ts

@@ -19,6 +19,8 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
     private staleProtocolPaths;
     private acquiredPaths;
     private identityProbeDevices;
+    private normalDevices;
+    private identityProbeCleanupPaths;
     private probedDeviceObjects;
     private deviceEndpoints;
     name: string;
@@ -50,6 +52,9 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
     private discoverEndpoints;
     connectToDevice(path: string, first: boolean): Promise<undefined>;
     private assertHandleAvailable;
+    private claimNormalHandle;
+    private releaseNormalHandles;
+    private isHandleOwnershipError;
     private claimIdentityProbeHandle;
     private releaseIdentityProbeHandle;
     private closeOpenDevice;

package/dist/webusb.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webusb.d.ts","sourceRoot":"","sources":["../src/webusb.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"webusb.d.ts","sourceRoot":"","sources":["../src/webusb.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-web-device",
-  "version": "1.2.8-alpha.14",
+  "version": "1.2.8-alpha.16",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
   "license": "MIT",
@@ -21,13 +21,13 @@
     "lint:fix": "eslint . --fix"
   },
   "dependencies": {
-    "@onekeyfe/hd-shared": "1.2.8-alpha.14",
-    "@onekeyfe/hd-transport": "1.2.8-alpha.14"
+    "@onekeyfe/hd-shared": "1.2.8-alpha.16",
+    "@onekeyfe/hd-transport": "1.2.8-alpha.16"
   },
   "devDependencies": {
-    "@onekeyfe/hd-transport-electron": "1.2.8-alpha.14",
+    "@onekeyfe/hd-transport-electron": "1.2.8-alpha.16",
     "@types/w3c-web-usb": "^1.0.6",
     "@types/web-bluetooth": "^0.0.17"
   },
-  "gitHead": "f2784ca5eb21e4a3ebf167965f689e2ff2cb6249"
+  "gitHead": "7ccc3f507e2b536e6b5832e1cbb24a5fc1970ebe"
 }

package/src/webusb.ts

@@ -44,6 +44,7 @@ const REPORT_ID = PROTOCOL_V1_REPORT_ID;
 const HEADER_LENGTH = PROTOCOL_V1_MESSAGE_HEADER_SIZE;
 const PACKET_IO_MAX_RETRIES = 3;
 const PACKET_IO_RETRY_DELAY = 300;
+const USB_DEVICE_IN_USE = 'USB device is already in use';
 // Legacy devices can take longer to answer Initialize after a WebUSB reset.
 // Keep this aligned with Node USB so a slow Protocol V1 response is not
 // misreported as a protocol mismatch during acquire.
@@ -86,6 +87,8 @@ let usbDisconnectListenerAttached = false;
 // open them, including while native open() is still pending.
 const identityProbeHandles = new WeakSet<USBDevice>();
 const openingHandles = new WeakSet<USBDevice>();
+// A normal acquire keeps ownership even while recovery temporarily closes the handle.
+const normalHandleOwners = new WeakMap<USBDevice, WebUsbTransport>();
 
 function registerActiveWebUsbTransport(instance: WebUsbTransport, usb: USB) {
   activeWebUsbTransport = instance;
@@ -130,6 +133,10 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
 
   private identityProbeDevices = new Map<string, USBDevice>();
 
+  private normalDevices = new Map<USBDevice, string>();
+
+  private identityProbeCleanupPaths = new Set<string>();
+
   /**
    * The exact USBDevice object each cached protocol was probed against. The
    * browser returns the same object identity for a device as long as it stays
@@ -273,6 +280,14 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
    * It does NOT prompt the user to select a device
    */
   async enumerate() {
+    // Retry only our failed cleanup before Core skips already-open USB handles.
+    for (const path of this.identityProbeCleanupPaths) {
+      try {
+        await this.release(path);
+      } catch {
+        // Keep ownership while native close still fails; retry on the next probe.
+      }
+    }
     await this.getConnectedDevices();
     return this.deviceList;
   }
@@ -320,6 +335,8 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
     if (this.identityProbe) {
       await this.getConnectedDevices();
       this.claimIdentityProbeHandle(input.path, await this.findDevice(input.path));
+    } else {
+      this.claimNormalHandle(input.path, await this.findDevice(input.path));
     }
     try {
       await this.rotateProtocolV2UsbGeneration(input.path, 'WebUSB transport acquired');
@@ -408,6 +425,7 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
         await this.closeOpenDevice(input.path);
       } finally {
         this.releaseIdentityProbeHandle(input.path);
+        this.releaseNormalHandles(input.path);
       }
       throw e;
     }
@@ -588,6 +606,7 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
       this.releaseIdentityProbeHandle(path);
       this.claimIdentityProbeHandle(path, device);
     }
+    if (!this.identityProbe) this.claimNormalHandle(path, device);
     this.assertHandleAvailable(device);
     if (!device.opened) {
       openingHandles.add(device);
@@ -615,6 +634,7 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
       this.releaseIdentityProbeHandle(path);
       this.claimIdentityProbeHandle(path, device);
     }
+    if (!this.identityProbe) this.claimNormalHandle(path, device);
     this.assertHandleAvailable(device);
     if (!device.opened) {
       openingHandles.add(device);
@@ -648,17 +668,47 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
   }
 
   private assertHandleAvailable(device: USBDevice) {
+    const normalOwner = normalHandleOwners.get(device);
     if (
-      identityProbeHandles.has(device) &&
-      ![...this.identityProbeDevices.values()].includes(device)
+      (normalOwner && normalOwner !== this) ||
+      (identityProbeHandles.has(device) &&
+        ![...this.identityProbeDevices.values()].includes(device))
     ) {
-      throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'USB device is already in use');
+      throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, USB_DEVICE_IN_USE);
     }
   }
 
+  private claimNormalHandle(path: string, device: USBDevice) {
+    this.assertHandleAvailable(device);
+    normalHandleOwners.set(device, this);
+    this.normalDevices.set(device, path);
+  }
+
+  private releaseNormalHandles(path: string) {
+    for (const [device, ownedPath] of this.normalDevices) {
+      if (ownedPath === path) {
+        normalHandleOwners.delete(device);
+        this.normalDevices.delete(device);
+      }
+    }
+  }
+
+  private isHandleOwnershipError(error: unknown): error is HardwareError {
+    return (
+      error instanceof HardwareError &&
+      error.errorCode === HardwareErrorCode.RuntimeError &&
+      this.getErrorMessage(error).includes(USB_DEVICE_IN_USE)
+    );
+  }
+
   private claimIdentityProbeHandle(path: string, device: USBDevice) {
-    if (device.opened || openingHandles.has(device) || identityProbeHandles.has(device)) {
-      throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'USB device is already in use');
+    if (
+      device.opened ||
+      openingHandles.has(device) ||
+      identityProbeHandles.has(device) ||
+      normalHandleOwners.has(device)
+    ) {
+      throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, USB_DEVICE_IN_USE);
     }
     identityProbeHandles.add(device);
     this.identityProbeDevices.set(path, device);
@@ -666,8 +716,14 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
 
   private releaseIdentityProbeHandle(path: string) {
     const device = this.identityProbeDevices.get(path);
+    // A failed native close must not make an open probe handle available to other callers.
+    if (device?.opened) {
+      this.identityProbeCleanupPaths.add(path);
+      return;
+    }
     if (device) identityProbeHandles.delete(device);
     this.identityProbeDevices.delete(path);
+    this.identityProbeCleanupPaths.delete(path);
   }
 
   private async closeOpenDevice(path: string) {
@@ -684,6 +740,7 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
     } catch (error) {
       this.Log?.debug('[WebUsbTransport] releaseInterface before reconnect failed:', error);
     }
+    this.assertHandleAvailable(current);
     try {
       await current.close();
     } catch (error) {
@@ -697,6 +754,7 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
     direction: USBDirection,
     endpointNumber: number
   ) {
+    this.assertHandleAvailable(device);
     try {
       await device.clearHalt(direction, endpointNumber);
     } catch (error) {
@@ -772,7 +830,7 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
     operation: WebUsbOperation,
     error: unknown
   ): Promise<never> {
-    if (this.isWebUsbIoHardwareError(error)) throw error;
+    if (this.isHandleOwnershipError(error) || this.isWebUsbIoHardwareError(error)) throw error;
     if (error instanceof ProtocolV2LinkError && error.code !== 'io') throw error;
 
     const nativeError = error instanceof ProtocolV2LinkError ? error.cause ?? error : error;
@@ -812,7 +870,7 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
   }
 
   private isRetryablePacketIoError(error: unknown) {
-    if (this.isWebUsbIoHardwareError(error)) return false;
+    if (this.isHandleOwnershipError(error) || this.isWebUsbIoHardwareError(error)) return false;
     const message = this.getErrorMessage(error).toLowerCase();
     if (this.isWebUsbPermissionDeniedMessage(message)) return false;
     return (
@@ -846,6 +904,7 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
 
     try {
       const currentDevice = await this.findDevice(path);
+      this.assertHandleAvailable(currentDevice);
       if (currentDevice.opened) {
         const endpoints = this.deviceEndpoints.get(path);
         const ifaceNum = endpoints?.interfaceNumber ?? this.interfaceId;
@@ -854,9 +913,11 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
         } catch (releaseError) {
           this.Log.debug('[WebUsbTransport] releaseInterface before retry error:', releaseError);
         }
+        this.assertHandleAvailable(currentDevice);
         await currentDevice.close();
       }
     } catch (closeError) {
+      if (this.isHandleOwnershipError(closeError)) throw closeError;
       this.Log.debug('[WebUsbTransport] close device before retry error:', closeError);
     }
 
@@ -898,6 +959,7 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
         try {
           await this.reconnectForPacketIoRetry(path, 'out', attempt, error);
         } catch (reconnectError) {
+          if (this.isHandleOwnershipError(reconnectError)) throw reconnectError;
           lastError = reconnectError;
           this.Log.debug(
             `[WebUsbTransport] transferout reconnect failed on retry ${attempt}/${PACKET_IO_MAX_RETRIES}: ${this.getErrorMessage(
@@ -920,6 +982,7 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
     const transferBuffer = this.toArrayBuffer(
       packet.buffer.slice(packet.byteOffset, packet.byteOffset + packet.byteLength)
     );
+    this.assertHandleAvailable(device);
     const result = await device.transferOut(endpointOut, transferBuffer);
     if (result.status !== 'ok') {
       return this.throwWebUsbIoError(
@@ -947,6 +1010,7 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
         }
         const endpoints = this.deviceEndpoints.get(path);
         const endpointIn = endpoints?.endpointIn ?? this.endpointId;
+        this.assertHandleAvailable(device);
         const result = await device.transferIn(endpointIn, length);
         return this.getTransferInData(result);
       } catch (error) {
@@ -961,6 +1025,7 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
         try {
           await this.reconnectForPacketIoRetry(path, 'in', attempt, error);
         } catch (reconnectError) {
+          if (this.isHandleOwnershipError(reconnectError)) throw reconnectError;
           lastError = reconnectError;
           this.Log.debug(
             `[WebUsbTransport] transferin reconnect failed on retry ${attempt}/${PACKET_IO_MAX_RETRIES}: ${this.getErrorMessage(
@@ -980,6 +1045,7 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
     }
     const endpoints = this.deviceEndpoints.get(path);
     const endpointIn = endpoints?.endpointIn ?? this.endpointId;
+    this.assertHandleAvailable(device);
     const result = await device.transferIn(endpointIn, length);
     return this.getTransferInData(result);
   }
@@ -1213,6 +1279,7 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
       await this.closeOpenDevice(path);
     } finally {
       this.releaseIdentityProbeHandle(path);
+      this.releaseNormalHandles(path);
     }
     // Keep deviceProtocol/deviceProtocolHints across release: the probe result is a
     // physical-device property, so the next acquire can skip the wire-level probe.