@onekeyfe/hd-transport-web-device 1.2.8-alpha.5 → 1.2.8-alpha.51

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

@@ -0,0 +1,268 @@
+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', () => ({}));
+
+describe('WebUSB identity probe ownership', () => {
+  let originalNavigator: PropertyDescriptor | undefined;
+  const device = {
+    vendorId: 0x1209,
+    productId: 0x53c1,
+    serialNumber: 'USB_PATH',
+    opened: false,
+    close: jest.fn(),
+  };
+  let disconnectListener: (event: { device: typeof device }) => void;
+  const usb = {
+    getDevices: jest.fn(),
+    addEventListener: jest.fn((_type, callback) => {
+      disconnectListener = callback;
+    }),
+  };
+  beforeEach(() => {
+    originalNavigator = Object.getOwnPropertyDescriptor(globalThis, 'navigator');
+    device.opened = false;
+    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 } });
+  });
+  afterEach(() => {
+    if (originalNavigator) Object.defineProperty(globalThis, 'navigator', originalNavigator);
+    else delete (globalThis as { navigator?: Navigator }).navigator;
+  });
+
+  test('does not close a handle already opened by another operation', async () => {
+    const probe = new WebUsbTransport(true);
+    probe.init({ debug: jest.fn() });
+    device.opened = true;
+    await expect(probe.acquire({ path: 'USB_PATH' })).rejects.toThrow(
+      'USB device is already in use'
+    );
+    expect(device.close).not.toHaveBeenCalled();
+    expect(usb.addEventListener).not.toHaveBeenCalled();
+  });
+
+  test('does not borrow a handle while a normal native open is pending', async () => {
+    const active = new WebUsbTransport();
+    const probe = new WebUsbTransport(true);
+    active.init({ debug: jest.fn() });
+    probe.init({ debug: jest.fn() });
+    let finishOpen!: () => void;
+    let started!: () => void;
+    const opening = new Promise<void>(resolve => {
+      finishOpen = resolve;
+    });
+    const entered = new Promise<void>(resolve => {
+      started = resolve;
+    });
+    const native = Object.assign(device, {
+      open: jest.fn(async () => {
+        started();
+        await opening;
+        device.opened = true;
+      }),
+      reset: jest.fn(),
+      configurations: [],
+      configuration: { configurationValue: 1 },
+      selectConfiguration: jest.fn(),
+      claimInterface: jest.fn(),
+      clearHalt: jest.fn(),
+    });
+    jest.spyOn(active, 'findDevice').mockResolvedValue(native as unknown as USBDevice);
+    const connecting = active.connectToDevice('USB_PATH', true);
+    await entered;
+    await expect(probe.acquire({ path: 'USB_PATH' })).rejects.toThrow(
+      'USB device is already in use'
+    );
+    expect(device.close).not.toHaveBeenCalled();
+    finishOpen();
+    await connecting;
+  });
+
+  test('a normal connection cannot close an isolated probe handle and release closes the captured handle after re-enumeration', async () => {
+    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;
+      return Promise.resolve();
+    });
+    await probe.acquire({ path: 'USB_PATH' });
+    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).not.toHaveBeenCalled();
+    const replacement = { ...device, close: jest.fn() };
+    usb.getDevices.mockResolvedValue([replacement]);
+    await probe.getConnectedDevices();
+    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();
+  });
+
+  test('does not replace the active SDK disconnect observer', () => {
+    const active = new WebUsbTransport();
+    active.init({ debug: jest.fn() });
+    const probe = new WebUsbTransport(true);
+    probe.init({ debug: jest.fn() });
+    const activeDisconnect = jest.spyOn(active, 'markProtocolStale');
+    const probeDisconnect = jest.spyOn(probe, 'markProtocolStale');
+    disconnectListener({ device });
+    expect(activeDisconnect).toHaveBeenCalledWith('USB_PATH');
+    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([false, true])(
+    'uses a read-only V1 probe only for isolated discovery (%s)',
+    async identityProbe => {
+      const probe = new WebUsbTransport(identityProbe);
+      const internals = probe as unknown as {
+        messages: object;
+        callProtocolV1: (
+          path: string,
+          name: string,
+          data: object,
+          options: TransportCallOptions
+        ) => Promise<MessageFromOneKey>;
+        probeProtocolV1: (path: string) => Promise<boolean>;
+      };
+      internals.messages = {};
+      const call = jest
+        .spyOn(internals, 'callProtocolV1')
+        .mockResolvedValue({ type: 'Features', message: {} });
+      await expect(internals.probeProtocolV1('USB_PATH')).resolves.toBe(true);
+      expect(call.mock.calls[0][1]).toBe(identityProbe ? 'GetFeatures' : 'Initialize');
+    }
+  );
+});

package/dist/index.d.ts

@@ -13,6 +13,7 @@ interface DeviceInfo extends OneKeyDeviceInfoBase {
     protocolType?: ProtocolType;
 }
 declare class WebUsbTransport extends ProtocolV2UsbTransportBase<string> {
+    private readonly identityProbe;
     messages: ReturnType<typeof _onekeyfe_hd_transport__default.parseConfigure> | undefined;
     /** Protobuf schema for Protocol V2 transports. */
     messagesV2: ReturnType<typeof _onekeyfe_hd_transport__default.parseConfigure> | undefined;
@@ -29,6 +30,8 @@ declare class WebUsbTransport extends ProtocolV2UsbTransportBase<string> {
     private staleProtocolPaths;
     /** Paths currently acquired (between a successful acquire() and its release()). */
     private acquiredPaths;
+    private identityProbeDevices;
+    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
@@ -53,7 +56,7 @@ declare class WebUsbTransport extends ProtocolV2UsbTransportBase<string> {
     configurationId: number;
     endpointId: number;
     interfaceId: number;
-    constructor();
+    constructor(identityProbe?: boolean);
     /**
      * Initialize WebUSB transport
      */
@@ -129,6 +132,9 @@ declare class WebUsbTransport extends ProtocolV2UsbTransportBase<string> {
      * Discovers interface/endpoint numbers from USB descriptors on first connection.
      */
     connectToDevice(path: string, first: boolean): Promise<undefined>;
+    private assertHandleAvailable;
+    private claimIdentityProbeHandle;
+    private releaseIdentityProbeHandle;
     private closeOpenDevice;
     private clearEndpointHalt;
     /**

package/dist/index.js

@@ -56,6 +56,8 @@ const PROTOCOL_V2_PROBE_TIMEOUT = 1000;
 const EXPECTED_PROTOCOL_V2_PROBE_ATTEMPTS = 2;
 let activeWebUsbTransport;
 let usbDisconnectListenerAttached = false;
+const identityProbeHandles = new WeakSet();
+const openingHandles = new WeakSet();
 function registerActiveWebUsbTransport(instance, usb) {
     activeWebUsbTransport = instance;
     if (usbDisconnectListenerAttached)
@@ -72,17 +74,20 @@ function registerActiveWebUsbTransport(instance, usb) {
     });
 }
 class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
-    constructor() {
+    constructor(identityProbe = false) {
         super({
             router: transport.PROTOCOL_V2_CHANNEL_USB,
             maxFrameBytes: transport.PROTOCOL_V2_FRAME_MAX_BYTES,
             logPrefix: 'ProtocolV2 WebUSB',
         });
+        this.identityProbe = identityProbe;
         this.deviceProtocol = new Map();
         this.confirmedDeviceProtocols = new Map();
         this.deviceProtocolHints = new Map();
         this.staleProtocolPaths = new Set();
         this.acquiredPaths = new Set();
+        this.identityProbeDevices = new Map();
+        this.identityProbeCleanupPaths = new Set();
         this.probedDeviceObjects = new Map();
         this.deviceEndpoints = new Map();
         this.name = 'WebUsbTransport';
@@ -101,7 +106,8 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'WebUSB is not supported by current browsers');
         }
         this.usb = usb;
-        registerActiveWebUsbTransport(this, usb);
+        if (!this.identityProbe)
+            registerActiveWebUsbTransport(this, usb);
     }
     emitDeviceDisconnect(path, device) {
         var _a, _b;
@@ -150,6 +156,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;
         });
@@ -187,6 +200,10 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
         return __awaiter(this, void 0, void 0, function* () {
             if (!input.path)
                 return;
+            if (this.identityProbe) {
+                yield this.getConnectedDevices();
+                this.claimIdentityProbeHandle(input.path, yield this.findDevice(input.path));
+            }
             try {
                 yield this.rotateProtocolV2UsbGeneration(input.path, 'WebUSB transport acquired');
                 yield this.closeOpenDevice(input.path);
@@ -248,7 +265,12 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             catch (e) {
                 this.Log.debug('acquire error: ', e instanceof Error ? `${e.name}: ${e.message}` : String(e));
                 this.acquiredPaths.delete(input.path);
-                yield this.closeOpenDevice(input.path);
+                try {
+                    yield this.closeOpenDevice(input.path);
+                }
+                finally {
+                    this.releaseIdentityProbeHandle(input.path);
+                }
                 throw e;
             }
         });
@@ -375,12 +397,22 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             let device = yield this.findDevice(path);
+            if (this.identityProbe && this.identityProbeDevices.get(path) !== device) {
+                yield this.closeOpenDevice(path);
+                this.releaseIdentityProbeHandle(path);
+                this.claimIdentityProbeHandle(path, device);
+            }
+            this.assertHandleAvailable(device);
             if (!device.opened) {
+                openingHandles.add(device);
                 try {
                     yield device.open();
                 }
                 catch (error) {
-                    return this.throwWebUsbIoError(path, 'open', error);
+                    return yield this.throwWebUsbIoError(path, 'open', error);
+                }
+                finally {
+                    openingHandles.delete(device);
                 }
             }
             if (first || this.deviceProtocol.get(path) !== 'V1') {
@@ -393,12 +425,22 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             }
             yield this.getConnectedDevices();
             device = yield this.findDevice(path);
+            if (this.identityProbe && this.identityProbeDevices.get(path) !== device) {
+                yield this.closeOpenDevice(path);
+                this.releaseIdentityProbeHandle(path);
+                this.claimIdentityProbeHandle(path, device);
+            }
+            this.assertHandleAvailable(device);
             if (!device.opened) {
+                openingHandles.add(device);
                 try {
                     yield device.open();
                 }
                 catch (error) {
-                    return this.throwWebUsbIoError(path, 'open', error);
+                    return yield this.throwWebUsbIoError(path, 'open', error);
+                }
+                finally {
+                    openingHandles.delete(device);
                 }
             }
             if (first ||
@@ -418,12 +460,39 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             yield this.clearEndpointHalt(device, 'out', endpoints.endpointOut);
         });
     }
+    assertHandleAvailable(device) {
+        if (identityProbeHandles.has(device) &&
+            ![...this.identityProbeDevices.values()].includes(device)) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'USB device is already 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');
+        }
+        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;
         return __awaiter(this, void 0, void 0, function* () {
-            const current = (_a = this.deviceList.find(device => device.path === path)) === null || _a === void 0 ? void 0 : _a.device;
+            const current = this.identityProbe
+                ? this.identityProbeDevices.get(path)
+                : (_a = this.deviceList.find(device => device.path === path)) === null || _a === void 0 ? void 0 : _a.device;
             if (!(current === null || current === void 0 ? void 0 : current.opened))
                 return;
+            this.assertHandleAvailable(current);
             const endpoints = this.deviceEndpoints.get(path);
             const ifaceNum = (_b = endpoints === null || endpoints === void 0 ? void 0 : endpoints.interfaceNumber) !== null && _b !== void 0 ? _b : this.interfaceId;
             try {
@@ -437,6 +506,8 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             }
             catch (error) {
                 (_d = this.Log) === null || _d === void 0 ? void 0 : _d.debug('[WebUsbTransport] close before reconnect failed:', error);
+                if (this.identityProbe)
+                    throw error;
             }
         });
     }
@@ -749,10 +820,10 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
                 return false;
             }
             try {
-                yield this.callProtocolV1(path, 'Initialize', {}, {
+                const response = yield this.callProtocolV1(path, this.identityProbe ? 'GetFeatures' : 'Initialize', {}, {
                     timeoutMs: PROTOCOL_V1_PROBE_TIMEOUT,
                 });
-                return true;
+                return !this.identityProbe || response.type === 'Features';
             }
             catch (error) {
                 if (this.isWebUsbIoHardwareError(error))
@@ -869,8 +940,13 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
     release(path) {
         return __awaiter(this, void 0, void 0, function* () {
             this.acquiredPaths.delete(path);
-            yield this.invalidateProtocolV2UsbLink(path, 'WebUSB transport released');
-            yield this.closeOpenDevice(path);
+            try {
+                yield this.invalidateProtocolV2UsbLink(path, 'WebUSB transport released');
+                yield this.closeOpenDevice(path);
+            }
+            finally {
+                this.releaseIdentityProbeHandle(path);
+            }
             this.deviceEndpoints.delete(path);
         });
     }

package/dist/webusb.d.ts

@@ -9,6 +9,7 @@ export interface DeviceInfo extends OneKeyDeviceInfoBase {
     protocolType?: ProtocolType;
 }
 export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string> {
+    private readonly identityProbe;
     messages: ReturnType<typeof transport.parseConfigure> | undefined;
     messagesV2: ReturnType<typeof transport.parseConfigure> | undefined;
     private protocolV2SchemaSource;
@@ -17,6 +18,8 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
     private deviceProtocolHints;
     private staleProtocolPaths;
     private acquiredPaths;
+    private identityProbeDevices;
+    private identityProbeCleanupPaths;
     private probedDeviceObjects;
     private deviceEndpoints;
     name: string;
@@ -29,7 +32,7 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
     configurationId: number;
     endpointId: number;
     interfaceId: number;
-    constructor();
+    constructor(identityProbe?: boolean);
     init(logger: any, emitter?: EventEmitter): void;
     emitDeviceDisconnect(path: string, device?: USBDevice): void;
     markProtocolStale(path: string): void;
@@ -47,6 +50,9 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
     connect(path: string, first: boolean): Promise<undefined>;
     private discoverEndpoints;
     connectToDevice(path: string, first: boolean): Promise<undefined>;
+    private assertHandleAvailable;
+    private claimIdentityProbeHandle;
+    private releaseIdentityProbeHandle;
     private closeOpenDevice;
     private clearEndpointHalt;
     private assertAcquired;

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.5",
+  "version": "1.2.8-alpha.51",
   "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.5",
-    "@onekeyfe/hd-transport": "1.2.8-alpha.5"
+    "@onekeyfe/hd-shared": "1.2.8-alpha.51",
+    "@onekeyfe/hd-transport": "1.2.8-alpha.51"
   },
   "devDependencies": {
-    "@onekeyfe/hd-transport-electron": "1.2.8-alpha.5",
+    "@onekeyfe/hd-transport-electron": "1.2.8-alpha.51",
     "@types/w3c-web-usb": "^1.0.6",
     "@types/web-bluetooth": "^0.0.17"
   },
-  "gitHead": "c1f24dc0a59d0c02fe05594a9c4ae7652ec9cc32"
+  "gitHead": "0ccbc08199c62e96f6084e864e558055100b66ed"
 }

package/src/webusb.ts

@@ -82,6 +82,10 @@ type WebUsbOperation = 'open' | 'claimInterface' | 'transferIn' | 'transferOut';
  */
 let activeWebUsbTransport: WebUsbTransport | undefined;
 let usbDisconnectListenerAttached = false;
+// Only isolated discovery owns these handles. Normal calls must never close or
+// open them, including while native open() is still pending.
+const identityProbeHandles = new WeakSet<USBDevice>();
+const openingHandles = new WeakSet<USBDevice>();
 
 function registerActiveWebUsbTransport(instance: WebUsbTransport, usb: USB) {
   activeWebUsbTransport = instance;
@@ -124,6 +128,10 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
   /** Paths currently acquired (between a successful acquire() and its release()). */
   private acquiredPaths: Set<string> = new Set();
 
+  private identityProbeDevices = new Map<string, USBDevice>();
+
+  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
@@ -160,7 +168,7 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
 
   interfaceId = INTERFACE_ID;
 
-  constructor() {
+  constructor(private readonly identityProbe = false) {
     super({
       router: PROTOCOL_V2_CHANNEL_USB,
       maxFrameBytes: PROTOCOL_V2_FRAME_MAX_BYTES,
@@ -183,7 +191,7 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
       );
     }
     this.usb = usb;
-    registerActiveWebUsbTransport(this, usb);
+    if (!this.identityProbe) registerActiveWebUsbTransport(this, usb);
   }
 
   /**
@@ -267,6 +275,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;
   }
@@ -311,6 +327,10 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
    */
   async acquire(input: AcquireInput) {
     if (!input.path) return;
+    if (this.identityProbe) {
+      await this.getConnectedDevices();
+      this.claimIdentityProbeHandle(input.path, await this.findDevice(input.path));
+    }
     try {
       await this.rotateProtocolV2UsbGeneration(input.path, 'WebUSB transport acquired');
       await this.closeOpenDevice(input.path);
@@ -394,7 +414,11 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
     } catch (e) {
       this.Log.debug('acquire error: ', e instanceof Error ? `${e.name}: ${e.message}` : String(e));
       this.acquiredPaths.delete(input.path);
-      await this.closeOpenDevice(input.path);
+      try {
+        await this.closeOpenDevice(input.path);
+      } finally {
+        this.releaseIdentityProbeHandle(input.path);
+      }
       throw e;
     }
   }
@@ -569,11 +593,20 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
    */
   async connectToDevice(path: string, first: boolean) {
     let device: USBDevice = await this.findDevice(path);
+    if (this.identityProbe && this.identityProbeDevices.get(path) !== device) {
+      await this.closeOpenDevice(path);
+      this.releaseIdentityProbeHandle(path);
+      this.claimIdentityProbeHandle(path, device);
+    }
+    this.assertHandleAvailable(device);
     if (!device.opened) {
+      openingHandles.add(device);
       try {
         await device.open();
       } catch (error) {
-        return this.throwWebUsbIoError(path, 'open', error);
+        return await this.throwWebUsbIoError(path, 'open', error);
+      } finally {
+        openingHandles.delete(device);
       }
     }
     // A V1 packet retry continues an in-flight exchange. Preserve its endpoint
@@ -587,11 +620,20 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
     }
     await this.getConnectedDevices();
     device = await this.findDevice(path);
+    if (this.identityProbe && this.identityProbeDevices.get(path) !== device) {
+      await this.closeOpenDevice(path);
+      this.releaseIdentityProbeHandle(path);
+      this.claimIdentityProbeHandle(path, device);
+    }
+    this.assertHandleAvailable(device);
     if (!device.opened) {
+      openingHandles.add(device);
       try {
         await device.open();
       } catch (error) {
-        return this.throwWebUsbIoError(path, 'open', error);
+        return await this.throwWebUsbIoError(path, 'open', error);
+      } finally {
+        openingHandles.delete(device);
       }
     }
 
@@ -615,9 +657,41 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
     await this.clearEndpointHalt(device, 'out', endpoints.endpointOut);
   }
 
+  private assertHandleAvailable(device: USBDevice) {
+    if (
+      identityProbeHandles.has(device) &&
+      ![...this.identityProbeDevices.values()].includes(device)
+    ) {
+      throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'USB device is already 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');
+    }
+    identityProbeHandles.add(device);
+    this.identityProbeDevices.set(path, device);
+  }
+
+  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) {
-    const current = this.deviceList.find(device => device.path === path)?.device;
+    const current = this.identityProbe
+      ? this.identityProbeDevices.get(path)
+      : this.deviceList.find(device => device.path === path)?.device;
     if (!current?.opened) return;
+    this.assertHandleAvailable(current);
 
     const endpoints = this.deviceEndpoints.get(path);
     const ifaceNum = endpoints?.interfaceNumber ?? this.interfaceId;
@@ -630,6 +704,7 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
       await current.close();
     } catch (error) {
       this.Log?.debug('[WebUsbTransport] close before reconnect failed:', error);
+      if (this.identityProbe) throw error;
     }
   }
 
@@ -984,15 +1059,15 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
     }
 
     try {
-      await this.callProtocolV1(
+      const response = await this.callProtocolV1(
         path,
-        'Initialize',
+        this.identityProbe ? 'GetFeatures' : 'Initialize',
         {},
         {
           timeoutMs: PROTOCOL_V1_PROBE_TIMEOUT,
         }
       );
-      return true;
+      return !this.identityProbe || response.type === 'Features';
     } catch (error) {
       if (this.isWebUsbIoHardwareError(error)) throw error;
       return false;
@@ -1149,8 +1224,12 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
    */
   async release(path: string) {
     this.acquiredPaths.delete(path);
-    await this.invalidateProtocolV2UsbLink(path, 'WebUSB transport released');
-    await this.closeOpenDevice(path);
+    try {
+      await this.invalidateProtocolV2UsbLink(path, 'WebUSB transport released');
+      await this.closeOpenDevice(path);
+    } finally {
+      this.releaseIdentityProbeHandle(path);
+    }
     // Keep deviceProtocol/deviceProtocolHints across release: the probe result is a
     // physical-device property, so the next acquire can skip the wire-level probe.
     // V2 entries are still dropped by onProtocolV2UsbLinkInvalidated via the link