@onekeyfe/hd-transport-web-device 1.2.8-alpha.101 → 1.2.8-alpha.103

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

@@ -120,6 +120,53 @@ describe('WebUSB identity probe ownership', () => {
     }
   );
 
+  test('clears the Core session while retaining ownership after normal native close fails', async () => {
+    const previous = TransportManager.transport;
+    const { settings } = DataManager;
+    const active = createAcquiredTransport();
+    TransportManager.transport = active as unknown as Transport;
+    const selected = new Device({
+      path: 'USB_PATH',
+      id: 'USB_PATH',
+      name: 'Mock device',
+      commType: 'webusb',
+      session: 'USB_PATH',
+      debug: false,
+    });
+    selected.mainId = 'USB_PATH';
+    selected.deviceConnector = {
+      release: (path: string) => active.release(path),
+    } as never;
+    (selected as unknown as { deviceAcquired: boolean }).deviceAcquired = true;
+
+    try {
+      await active.acquire({ path: 'USB_PATH' });
+      device.close.mockRejectedValueOnce(new Error('native close failed'));
+
+      await selected.release();
+
+      expect(selected.originalDescriptor.session).toBeNull();
+      expect(selected.hasDeviceAcquire()).toBe(false);
+      expect(device.opened).toBe(true);
+
+      const competing = new WebUsbTransport();
+      competing.init({ debug: jest.fn() });
+      await expect(competing.connectToDevice('USB_PATH', true)).rejects.toThrow(
+        'USB device is already in use'
+      );
+    } finally {
+      device.close.mockImplementation(() => {
+        device.opened = false;
+        return Promise.resolve();
+      });
+      await active.release('USB_PATH');
+      await active.stop();
+      TransportManager.transport = previous;
+      DataManager.settings = settings;
+      jest.restoreAllMocks();
+    }
+  });
+
   test('does not replace the transport until USB cleanup completes, or after it fails', async () => {
     const previous = TransportManager.transport;
     const { settings } = DataManager;

package/__tests__/webusb-protocol-cache.test.ts

@@ -1,5 +1,5 @@
 import transport from '@onekeyfe/hd-transport';
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import WebUsbTransport from '../src/webusb';
 
@@ -64,6 +64,97 @@ describe('WebUsbTransport protocol probe cache', () => {
     }
   );
 
+  test('uses the SDK 1.1.31 WebUSB sequence with descriptor endpoints for Protocol V1', async () => {
+    const webusb = new WebUsbTransport() as any;
+    const logger = { debug: jest.fn() };
+    const path = 'legacy-v1-device';
+    const device = {
+      opened: false,
+      configuration: { configurationValue: 1 },
+      configurations: [
+        {
+          interfaces: [
+            {
+              interfaceNumber: 7,
+              alternates: [
+                {
+                  interfaceClass: 0xff,
+                  endpoints: [
+                    { direction: 'in', endpointNumber: 3 },
+                    { direction: 'out', endpointNumber: 4 },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+      ],
+      open: jest.fn().mockImplementation(() => {
+        device.opened = true;
+        return Promise.resolve();
+      }),
+      reset: jest.fn().mockResolvedValue(undefined),
+      selectConfiguration: jest.fn().mockResolvedValue(undefined),
+      claimInterface: jest.fn().mockResolvedValue(undefined),
+      clearHalt: jest.fn().mockResolvedValue(undefined),
+    };
+    webusb.Log = logger;
+    webusb.findDevice = jest.fn().mockResolvedValue(device);
+    webusb.getConnectedDevices = jest.fn().mockResolvedValue([]);
+
+    await webusb.connect(path, true, { expectedProtocol: 'V1' });
+
+    expect(device.open).toHaveBeenCalledTimes(1);
+    expect(device.selectConfiguration).toHaveBeenCalledWith(1);
+    expect(device.reset).toHaveBeenCalledTimes(1);
+    expect(device.claimInterface).toHaveBeenCalledWith(7);
+    expect(webusb.deviceEndpoints.get(path)).toEqual({
+      interfaceNumber: 7,
+      endpointIn: 3,
+      endpointOut: 4,
+    });
+    expect(device.selectConfiguration.mock.invocationCallOrder[0]).toBeLessThan(
+      device.reset.mock.invocationCallOrder[0]
+    );
+    expect(device.reset.mock.invocationCallOrder[0]).toBeLessThan(
+      device.claimInterface.mock.invocationCallOrder[0]
+    );
+    expect(webusb.getConnectedDevices).not.toHaveBeenCalled();
+    expect(device.clearHalt).not.toHaveBeenCalled();
+    expect(logger.debug).toHaveBeenCalledWith(
+      '[WebUsbTransport][lifecycle]',
+      expect.objectContaining({
+        event: 'connect-attempt',
+        phase: 'start',
+        connectionStrategy: 'protocol-v1-legacy-1.1.31',
+      })
+    );
+  });
+
+  test('keeps the current WebUSB sequence when a cached V1 protocol is force-reprobed', async () => {
+    const webusb = new WebUsbTransport() as any;
+    const path = 'force-reprobe-device';
+    const device = {
+      opened: true,
+      configuration: { configurationValue: 1 },
+      configurations: [],
+      reset: jest.fn().mockResolvedValue(undefined),
+      selectConfiguration: jest.fn().mockResolvedValue(undefined),
+      claimInterface: jest.fn().mockResolvedValue(undefined),
+      clearHalt: jest.fn().mockResolvedValue(undefined),
+    };
+    webusb.Log = { debug: jest.fn() };
+    webusb.deviceProtocol.set(path, 'V1');
+    webusb.findDevice = jest.fn().mockResolvedValue(device);
+    webusb.getConnectedDevices = jest.fn().mockResolvedValue([]);
+
+    await webusb.connectToDevice(path, true, { forceProtocolDetection: true });
+
+    expect(device.reset).toHaveBeenCalledTimes(1);
+    expect(webusb.getConnectedDevices).toHaveBeenCalledTimes(1);
+    expect(device.clearHalt).toHaveBeenCalledTimes(2);
+  });
+
   test('reports claimInterface failures as WebUSB device access errors', async () => {
     const webusb = new WebUsbTransport();
     const path = 'connected-usb-device';
@@ -91,6 +182,129 @@ describe('WebUsbTransport protocol probe cache', () => {
     });
   });
 
+  test('does not retry a typed WebUSB handle error', async () => {
+    const webusb = new WebUsbTransport() as any;
+    const logger = { debug: jest.fn() };
+    const path = 'sensitive-device-path';
+    const accessError = ERRORS.TypedError(
+      HardwareErrorCode.WebUsbDeviceAccessError,
+      'Unable to claim interface',
+      { operation: 'claimInterface' }
+    );
+    webusb.Log = logger;
+    webusb.connectToDevice = jest.fn().mockRejectedValue(accessError);
+
+    await expect(webusb.connect(path, true)).rejects.toBe(accessError);
+
+    expect(webusb.connectToDevice).toHaveBeenCalledTimes(1);
+    expect(logger.debug).toHaveBeenCalledWith(
+      '[WebUsbTransport][lifecycle]',
+      expect.objectContaining({
+        event: 'connect-attempt',
+        phase: 'error',
+        attempt: 1,
+        maxAttempts: 5,
+        willRetry: false,
+        errorCode: HardwareErrorCode.WebUsbDeviceAccessError,
+      })
+    );
+    expect(JSON.stringify(logger.debug.mock.calls)).not.toContain(path);
+  });
+
+  test('preserves the existing reconnect retry for a transient disconnect', async () => {
+    const webusb = new WebUsbTransport() as any;
+    const disconnected = ERRORS.TypedError(HardwareErrorCode.BridgeDeviceDisconnected);
+    webusb.Log = { debug: jest.fn() };
+    webusb.connectToDevice = jest
+      .fn()
+      .mockRejectedValueOnce(disconnected)
+      .mockResolvedValueOnce(undefined);
+
+    await expect(webusb.connect('device-path', true)).resolves.toBeUndefined();
+
+    expect(webusb.connectToDevice).toHaveBeenCalledTimes(2);
+  });
+
+  test('closes every owned handle after claimInterface fails across re-enumeration', async () => {
+    const webusb = new WebUsbTransport() as any;
+    const logger = { debug: jest.fn() };
+    const path = 'sensitive-device-path';
+    const claimError = Object.assign(new Error('Unable to claim interface'), {
+      name: 'NetworkError',
+    });
+    const usbInterface = {
+      interfaceNumber: 0,
+      claimed: false,
+      alternates: [],
+    };
+    const originalDevice = {
+      vendorId: 0x1209,
+      productId: 0x53c1,
+      serialNumber: path,
+      opened: false,
+      configuration: { configurationValue: 1, interfaces: [usbInterface] },
+      configurations: [],
+      open: jest.fn().mockImplementation(() => {
+        originalDevice.opened = true;
+        return Promise.resolve();
+      }),
+      reset: jest.fn().mockResolvedValue(undefined),
+      selectConfiguration: jest.fn().mockResolvedValue(undefined),
+      claimInterface: jest.fn().mockResolvedValue(undefined),
+      releaseInterface: jest.fn().mockResolvedValue(undefined),
+      close: jest.fn().mockImplementation(() => {
+        originalDevice.opened = false;
+        return Promise.resolve();
+      }),
+      clearHalt: jest.fn().mockResolvedValue(undefined),
+    };
+    const replacementDevice = {
+      ...originalDevice,
+      opened: false,
+      open: jest.fn().mockImplementation(() => {
+        replacementDevice.opened = true;
+        return Promise.resolve();
+      }),
+      reset: jest.fn().mockResolvedValue(undefined),
+      selectConfiguration: jest.fn().mockResolvedValue(undefined),
+      claimInterface: jest.fn().mockRejectedValue(claimError),
+      releaseInterface: jest.fn().mockResolvedValue(undefined),
+      close: jest.fn().mockImplementation(() => {
+        replacementDevice.opened = false;
+        return Promise.resolve();
+      }),
+      clearHalt: jest.fn().mockResolvedValue(undefined),
+    };
+    webusb.Log = logger;
+    webusb.usb = { getDevices: jest.fn().mockResolvedValue([replacementDevice]) };
+    webusb.deviceList = [{ path, device: originalDevice, commType: 'webusb' }];
+    webusb.rotateProtocolV2UsbGeneration = jest.fn().mockResolvedValue(undefined);
+
+    await expect(webusb.acquire({ path })).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.WebUsbDeviceAccessError,
+    });
+
+    expect(originalDevice.claimInterface).not.toHaveBeenCalled();
+    expect(replacementDevice.claimInterface).toHaveBeenCalledTimes(1);
+    expect(originalDevice.releaseInterface).not.toHaveBeenCalled();
+    expect(replacementDevice.releaseInterface).not.toHaveBeenCalled();
+    expect(originalDevice.close).toHaveBeenCalledTimes(1);
+    expect(replacementDevice.close).toHaveBeenCalledTimes(1);
+    expect(originalDevice.opened).toBe(false);
+    expect(replacementDevice.opened).toBe(false);
+    expect(logger.debug).toHaveBeenCalledWith(
+      '[WebUsbTransport][lifecycle]',
+      expect.objectContaining({
+        event: 'handle-operation',
+        operation: 'releaseInterface',
+        phase: 'skipped',
+        reason: 'interface-not-claimed',
+        deviceRefId: expect.any(Number),
+      })
+    );
+    expect(JSON.stringify(logger.debug.mock.calls)).not.toContain(path);
+  });
+
   test('reports transferIn failures as WebUSB device access errors', async () => {
     const webusb = new WebUsbTransport() as any;
     const path = 'connected-usb-device';
@@ -193,6 +407,10 @@ describe('WebUsbTransport protocol probe cache', () => {
 
     await expect(webusb.acquire({ path, expectedProtocol: 'V1' })).resolves.toBe(path);
 
+    expect(webusb.connect).toHaveBeenCalledWith(path, true, {
+      expectedProtocol: 'V1',
+      forceProtocolDetection: undefined,
+    });
     expect(webusb.detectProtocol).not.toHaveBeenCalled();
     expect(webusb.deviceProtocol.get(path)).toBe('V1');
     expect(webusb.acquiredPaths.has(path)).toBe(true);

package/dist/index.d.ts

@@ -12,8 +12,16 @@ interface DeviceInfo extends OneKeyDeviceInfoBase {
     device: USBDevice;
     protocolType?: ProtocolType;
 }
+interface WebUsbConnectOptions {
+    expectedProtocol?: ProtocolType;
+    forceProtocolDetection?: boolean;
+}
 declare class WebUsbTransport extends ProtocolV2UsbTransportBase<string> {
     private readonly identityProbe;
+    private readonly transportInstanceId;
+    private handleOperationSequence;
+    private deviceLogSequence;
+    private deviceLogIds;
     messages: ReturnType<typeof _onekeyfe_hd_transport__default.parseConfigure> | undefined;
     /** Protobuf schema for Protocol V2 transports. */
     messagesV2: ReturnType<typeof _onekeyfe_hd_transport__default.parseConfigure> | undefined;
@@ -68,6 +76,13 @@ declare class WebUsbTransport extends ProtocolV2UsbTransportBase<string> {
     private stopResources;
     private assertRunning;
     private runHandleOperation;
+    private getInterfaceClaimed;
+    private getDeviceLogId;
+    private getHandleLogState;
+    private getDiagnosticError;
+    private logLifecycle;
+    private logSkippedHandleOperation;
+    private runLoggedHandleOperation;
     /**
      * Announce that a USB device left. Called from the module-scoped disconnect
      * listener, which is why it is public rather than inlined.
@@ -128,7 +143,8 @@ declare class WebUsbTransport extends ProtocolV2UsbTransportBase<string> {
     /**
      * Connect to device with retry mechanism
      */
-    connect(path: string, first: boolean): Promise<undefined>;
+    connect(path: string, first: boolean, options?: WebUsbConnectOptions): Promise<undefined>;
+    private shouldUseLegacyV1Connection;
     /**
      * Discover vendor-class (0xFF) interface and its IN/OUT endpoint numbers from USB descriptors.
      * Falls back to legacy hardcoded values if no vendor interface is found.
@@ -138,7 +154,8 @@ declare class WebUsbTransport extends ProtocolV2UsbTransportBase<string> {
      * Connect to specific device.
      * Discovers interface/endpoint numbers from USB descriptors on first connection.
      */
-    connectToDevice(path: string, first: boolean): Promise<undefined>;
+    connectToDevice(path: string, first: boolean, options?: WebUsbConnectOptions): Promise<undefined>;
+    private claimDeviceInterface;
     private assertHandleAvailable;
     private claimNormalHandle;
     private releaseNormalHandles;
@@ -146,6 +163,7 @@ declare class WebUsbTransport extends ProtocolV2UsbTransportBase<string> {
     private claimIdentityProbeHandle;
     private releaseIdentityProbeHandle;
     private closeOpenDevice;
+    private closeDeviceHandle;
     private clearEndpointHalt;
     /**
      * With the protocol cache surviving release(), deviceProtocol presence no