@onekeyfe/hd-transport-web-device 1.2.0-alpha.99 → 1.2.0

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

@@ -0,0 +1,276 @@
+import transport from '@onekeyfe/hd-transport';
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import WebUsbTransport from '../src/webusb';
+
+const schema = {
+  nested: {
+    Ping: { fields: { message: { type: 'string', id: 1 } } },
+    Success: { fields: { message: { type: 'string', id: 1 } } },
+    MessageType: {
+      values: {
+        MessageType_Ping: 60206,
+        MessageType_Success: 60207,
+      },
+    },
+  },
+};
+
+function buildAcquirableTransport(path = 'pro-webusb') {
+  const webusb = new WebUsbTransport() as any;
+  webusb.Log = { debug: jest.fn() };
+  webusb.rotateProtocolV2UsbGeneration = jest.fn().mockResolvedValue(undefined);
+  webusb.closeOpenDevice = jest.fn().mockResolvedValue(undefined);
+  webusb.connect = jest.fn().mockResolvedValue(undefined);
+  // Simulate a device that stayed connected since the probe: same USBDevice
+  // object present in the device list and recorded as the probed object.
+  const deviceObject = { serialNumber: path } as unknown as USBDevice;
+  webusb.deviceList = [{ path, device: deviceObject, commType: 'webusb' }];
+  webusb.probedDeviceObjects.set(path, deviceObject);
+  return webusb;
+}
+
+describe('WebUsbTransport protocol probe cache', () => {
+  test('acquire skips the wire probe when the protocol is already cached', async () => {
+    const webusb = buildAcquirableTransport();
+    const path = 'pro-webusb';
+    webusb.deviceProtocol.set(path, 'V1');
+    webusb.detectProtocol = jest.fn();
+
+    await expect(webusb.acquire({ path, expectedProtocol: 'V1' })).resolves.toBe(path);
+
+    expect(webusb.detectProtocol).not.toHaveBeenCalled();
+    expect(webusb.deviceProtocol.get(path)).toBe('V1');
+    expect(webusb.acquiredPaths.has(path)).toBe(true);
+  });
+
+  test('acquire re-probes when the caller expects a different protocol than cached', async () => {
+    const webusb = buildAcquirableTransport();
+    const path = 'pro-webusb';
+    webusb.deviceProtocol.set(path, 'V1');
+    webusb.detectProtocol = jest.fn().mockImplementation((p: string) => {
+      webusb.deviceProtocol.set(p, 'V2');
+      return Promise.resolve('V2');
+    });
+
+    await expect(webusb.acquire({ path, expectedProtocol: 'V2' })).resolves.toBe(path);
+
+    expect(webusb.detectProtocol).toHaveBeenCalledWith(path, 'V2', undefined);
+    expect(webusb.deviceProtocol.get(path)).toBe('V2');
+  });
+
+  test('acquire probes when nothing is cached for the path', async () => {
+    const webusb = buildAcquirableTransport();
+    const path = 'pro-webusb';
+    webusb.detectProtocol = jest.fn().mockResolvedValue('V1');
+
+    await expect(webusb.acquire({ path, expectedProtocol: 'V1' })).resolves.toBe(path);
+
+    expect(webusb.detectProtocol).toHaveBeenCalledWith(path, 'V1', undefined);
+  });
+
+  test('acquire reuses a previously confirmed protocol during explicit no-probe recovery', async () => {
+    const webusb = buildAcquirableTransport();
+    const path = 'pro-webusb';
+    webusb.deviceProtocol.set(path, 'V1');
+    webusb.confirmedDeviceProtocols.set(path, 'V2');
+    webusb.markProtocolStale(path);
+    webusb.detectProtocol = jest.fn();
+
+    await expect(
+      webusb.acquire({ path, expectedProtocol: 'V2', skipProtocolProbe: true })
+    ).resolves.toBe(path);
+
+    expect(webusb.detectProtocol).not.toHaveBeenCalled();
+    expect(webusb.deviceProtocol.get(path)).toBe('V2');
+    expect(webusb.staleProtocolPaths.has(path)).toBe(false);
+    expect(webusb.acquiredPaths.has(path)).toBe(true);
+  });
+
+  test('acquire rejects no-probe recovery without a previously confirmed protocol', async () => {
+    const webusb = buildAcquirableTransport();
+    const path = 'pro-webusb';
+    webusb.detectProtocol = jest.fn();
+
+    await expect(
+      webusb.acquire({ path, expectedProtocol: 'V2', skipProtocolProbe: true })
+    ).rejects.toThrow('previously confirmed protocol');
+
+    expect(webusb.detectProtocol).not.toHaveBeenCalled();
+    expect(webusb.deviceProtocol.has(path)).toBe(false);
+    expect(webusb.acquiredPaths.has(path)).toBe(false);
+  });
+
+  test('forced protocol detection bypasses a valid cache and probes on the wire', async () => {
+    const webusb = buildAcquirableTransport();
+    const path = 'pro-webusb';
+    // Valid cache AND unchanged USBDevice object — the strongest cache hit.
+    webusb.deviceProtocol.set(path, 'V1');
+    webusb.detectProtocol = jest.fn().mockImplementation((p: string) => {
+      webusb.deviceProtocol.set(p, 'V1');
+      return Promise.resolve('V1');
+    });
+
+    await expect(webusb.acquire({ path, forceProtocolDetection: true })).resolves.toBe(path);
+
+    // Explicit recovery must always reach the wire probe.
+    expect(webusb.detectProtocol).toHaveBeenCalledTimes(1);
+  });
+
+  test('acquire re-probes when the USBDevice object identity changed since the probe', async () => {
+    const webusb = buildAcquirableTransport();
+    const path = 'pro-webusb';
+    webusb.deviceProtocol.set(path, 'V1');
+    // Simulate a replug the transport never saw a disconnect event for: the OS
+    // re-enumerated the device, so the list now holds a NEW USBDevice object.
+    webusb.deviceList = [
+      { path, device: { serialNumber: path } as unknown as USBDevice, commType: 'webusb' },
+    ];
+    webusb.detectProtocol = jest.fn().mockImplementation((p: string) => {
+      webusb.deviceProtocol.set(p, 'V1');
+      return Promise.resolve('V1');
+    });
+
+    await expect(webusb.acquire({ path, expectedProtocol: 'V1' })).resolves.toBe(path);
+
+    expect(webusb.detectProtocol).toHaveBeenCalledTimes(1);
+  });
+
+  test('acquire re-probes a stale-marked path even when a protocol is cached', async () => {
+    const webusb = buildAcquirableTransport();
+    const path = 'pro-webusb';
+    webusb.deviceProtocol.set(path, 'V1');
+    webusb.markProtocolStale(path);
+    webusb.detectProtocol = jest.fn().mockImplementation((p: string) => {
+      webusb.deviceProtocol.set(p, 'V1');
+      return Promise.resolve('V1');
+    });
+
+    await expect(webusb.acquire({ path, expectedProtocol: 'V1' })).resolves.toBe(path);
+
+    expect(webusb.detectProtocol).toHaveBeenCalledTimes(1);
+    expect(webusb.staleProtocolPaths.has(path)).toBe(false);
+  });
+
+  test('release keeps the cached V1 protocol so the next acquire can reuse it', async () => {
+    const webusb = new WebUsbTransport() as any;
+    const path = 'pro-webusb';
+    webusb.deviceProtocol.set(path, 'V1');
+    webusb.deviceProtocolHints.set(path, 'V2');
+    webusb.deviceEndpoints.set(path, { interfaceNumber: 0, endpointIn: 1, endpointOut: 1 });
+    webusb.acquiredPaths.add(path);
+    webusb.closeOpenDevice = jest.fn().mockResolvedValue(undefined);
+
+    await webusb.release(path);
+
+    expect(webusb.deviceProtocol.get(path)).toBe('V1');
+    expect(webusb.deviceProtocolHints.get(path)).toBe('V2');
+    expect(webusb.deviceEndpoints.has(path)).toBe(false);
+    expect(webusb.acquiredPaths.has(path)).toBe(false);
+  });
+
+  test('release still drops a cached V2 protocol through link invalidation', async () => {
+    const webusb = new WebUsbTransport() as any;
+    const path = 'pro2-webusb';
+    webusb.Log = { debug: jest.fn() };
+    webusb.messages = transport.parseConfigure(schema);
+    webusb.messagesV2 = transport.parseConfigure(schema);
+    webusb.writeProtocolV2UsbPacket = jest.fn().mockResolvedValue(undefined);
+    let markReadStarted: () => void = () => undefined;
+    const readStarted = new Promise<void>(resolve => {
+      markReadStarted = resolve;
+    });
+    webusb.readProtocolV2UsbPacket = jest.fn().mockImplementation(() => {
+      markReadStarted();
+      return new Promise<void>(() => {});
+    });
+    webusb.closeOpenDevice = jest.fn().mockResolvedValue(undefined);
+    webusb.deviceProtocol.set(path, 'V2');
+    await webusb.rotateProtocolV2UsbGeneration(path, 'test connection');
+
+    const call = webusb.callProtocolV2(path, 'Ping', { message: 'release' });
+    await readStarted;
+    await webusb.release(path);
+
+    await expect(call).rejects.toThrow('WebUSB transport released');
+    expect(webusb.deviceProtocol.has(path)).toBe(false);
+  });
+
+  test('call and post fail fast for a path that is not acquired', async () => {
+    const webusb = new WebUsbTransport() as any;
+    const path = 'pro-webusb';
+    webusb.Log = { debug: jest.fn() };
+    webusb.messages = transport.parseConfigure(schema);
+    webusb.messagesV2 = transport.parseConfigure(schema);
+    // A surviving protocol cache entry must NOT act as a session token.
+    webusb.deviceProtocol.set(path, 'V1');
+
+    await expect(webusb.call(path, 'Ping', {})).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.RuntimeError,
+      message: expect.stringContaining('not acquired'),
+    });
+    await expect(webusb.post(path, 'Ping', {})).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.RuntimeError,
+      message: expect.stringContaining('not acquired'),
+    });
+  });
+
+  test('a transfer-level reconnect marks the protocol stale for the next acquire', async () => {
+    const webusb = new WebUsbTransport() as any;
+    const path = 'pro-webusb';
+    webusb.Log = { debug: jest.fn() };
+    webusb.deviceProtocol.set(path, 'V1');
+    webusb.findDevice = jest.fn().mockResolvedValue({ opened: false });
+    webusb.getConnectedDevices = jest.fn().mockResolvedValue([]);
+    webusb.connect = jest.fn().mockResolvedValue(undefined);
+
+    await webusb.reconnectForPacketIoRetry(path, 'in', 0, new Error('transferIn failed'));
+
+    // The in-flight call keeps the cached protocol; only the next acquire re-probes.
+    expect(webusb.deviceProtocol.get(path)).toBe('V1');
+    expect(webusb.staleProtocolPaths.has(path)).toBe(true);
+  });
+
+  test('USB disconnect marks the serial stale and the listener attaches only once', () => {
+    const addEventListener = jest.fn();
+    const usb = { addEventListener } as unknown as USB;
+    const originalNavigator = (globalThis as any).navigator;
+    Object.defineProperty(globalThis, 'navigator', {
+      value: { usb },
+      configurable: true,
+    });
+    try {
+      const first = new WebUsbTransport() as any;
+      first.init({ debug: jest.fn() });
+      const second = new WebUsbTransport() as any;
+      second.init({ debug: jest.fn() });
+
+      // Module-level listener: one registration across instances.
+      expect(addEventListener).toHaveBeenCalledTimes(1);
+      const handler = addEventListener.mock.calls[0][1] as (event: {
+        device?: { serialNumber?: string | null };
+      }) => void;
+
+      const path = 'pro-webusb';
+      first.deviceProtocol.set(path, 'V1');
+      second.deviceProtocol.set(path, 'V1');
+      handler({ device: { serialNumber: path } });
+
+      // Routed to the most recently initialized instance; the cached value is
+      // retained (in-flight sessions keep working) but marked stale.
+      expect(second.staleProtocolPaths.has(path)).toBe(true);
+      expect(second.deviceProtocol.get(path)).toBe('V1');
+      expect(first.staleProtocolPaths.has(path)).toBe(false);
+
+      // Events without a device identity are ignored.
+      handler({ device: { serialNumber: null } });
+      handler({});
+      expect(second.staleProtocolPaths.size).toBe(1);
+    } finally {
+      Object.defineProperty(globalThis, 'navigator', {
+        value: originalNavigator,
+        configurable: true,
+      });
+    }
+  });
+});

package/__tests__/webusb-protocol-v2-timeout.test.ts

@@ -21,8 +21,9 @@ const schema = {
 };
 
 describe('WebUsbTransport Protocol V2 timeout recovery', () => {
-  test('only enumerates devices with real USB serial numbers', async () => {
-    const filter = ONEKEY_WEBUSB_FILTER[0];
+  test('enumerates OneKey USB devices even when the serial string is omitted', async () => {
+    const filter =
+      ONEKEY_WEBUSB_FILTER.find(item => item.productId === 0x4f4c) ?? ONEKEY_WEBUSB_FILTER[0];
     const deviceWithSerial = {
       ...filter,
       manufacturerName: 'OneKey',
@@ -32,7 +33,7 @@ describe('WebUsbTransport Protocol V2 timeout recovery', () => {
     const deviceWithoutSerial = {
       ...filter,
       manufacturerName: 'OneKey',
-      productName: 'OneKey Pro 2',
+      productName: 'OneKey Neo',
       serialNumber: null,
     } as USBDevice;
     const webusb = new WebUsbTransport();
@@ -46,6 +47,11 @@ describe('WebUsbTransport Protocol V2 timeout recovery', () => {
         device: deviceWithSerial,
         commType: 'webusb',
       },
+      {
+        path: 'usb-1209-4f4c-onekey-neo',
+        device: deviceWithoutSerial,
+        commType: 'webusb',
+      },
     ]);
   });
 
@@ -148,7 +154,7 @@ describe('WebUsbTransport Protocol V2 timeout recovery', () => {
     expect(webusb.deviceProtocol.get(path)).toBe('V2');
   });
 
-  test('reports a Protocol V2 probe timeout only after the bounded retry is exhausted', async () => {
+  test('reports a device initialization failure only after the bounded retry is exhausted', async () => {
     const webusb = new WebUsbTransport() as any;
     const path = 'pro2-webusb';
     webusb.probeProtocolV1 = jest.fn();
@@ -156,9 +162,10 @@ describe('WebUsbTransport Protocol V2 timeout recovery', () => {
     webusb.resetConnectionAfterProbe = jest.fn().mockResolvedValue(undefined);
     webusb.closeConnectionAfterProbe = jest.fn().mockResolvedValue(undefined);
 
-    await expect(webusb.detectProtocol(path, 'V2')).rejects.toThrow(
-      'Protocol V2 probe timeout after 2 attempts'
-    );
+    await expect(webusb.detectProtocol(path, 'V2')).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceInitializeFailed,
+      message: 'Protocol V2 probe timeout after 2 attempts',
+    });
 
     expect(webusb.probeProtocolV2).toHaveBeenCalledTimes(2);
     expect(webusb.probeProtocolV1).not.toHaveBeenCalled();
@@ -380,6 +387,13 @@ describe('WebUsbTransport Protocol V2 timeout recovery', () => {
       webusb.callProtocolV2(path, 'Ping', { message: 'short' }, { timeoutMs: 25 }),
     ]);
 
-    expect(readTimeouts).toEqual([1_000, 25]);
+    // Each call keeps its own budget instead of inheriting the other's. The
+    // queued one is a deadline, so it arrives with whatever the first call left
+    // of its 25ms — asserting the exact remainder makes this fail on a loaded
+    // machine, which is timing, not behaviour.
+    expect(readTimeouts).toHaveLength(2);
+    expect(readTimeouts[0]).toBe(1_000);
+    expect(readTimeouts[1]).toBeGreaterThan(0);
+    expect(readTimeouts[1]).toBeLessThanOrEqual(25);
   });
 });

package/dist/electron-ble-transport.d.ts

@@ -27,6 +27,7 @@ export default class ElectronBleTransport {
     private connectedDevices;
     private deviceProtocol;
     private deviceProtocolHints;
+    private confirmedProtocolV2;
     private deviceMtus;
     private devicePacketCapacities;
     private v1Buffers;
@@ -37,12 +38,14 @@ export default class ElectronBleTransport {
     private warnedMissingRelease;
     private notificationCleanups;
     private mtuCleanups;
-    private disconnectCleanups;
+    private hostDisconnectCleanup?;
     private notificationTokens;
     private nextNotificationToken;
+    private toStaleBondError;
     private handleBluetoothError;
     private cleanupDeviceState;
     init(logger: any, emitter?: EventEmitter): void;
+    private subscribeHostDisconnects;
     configure(signedData: any): void;
     configureProtocolV2(signedData: any): void;
     listen(): Promise<OneKeyDeviceInfo[]>;
@@ -76,6 +79,7 @@ export default class ElectronBleTransport {
     private createMtuSubscription;
     private writeProtocolV2Frame;
     private handleNotification;
+    private readProtocolV2LinkDisabledFailure;
     private handleProtocolV2Notification;
     private getProtocolV2FrameQueue;
     private resolveProtocolV2Frame;
@@ -84,6 +88,7 @@ export default class ElectronBleTransport {
     private readProtocolV2Frame;
     private handleProtocolV1Notification;
     call(uuid: string, name: string, data: Record<string, unknown>, options?: TransportCallOptions): Promise<import("@onekeyfe/hd-transport").MessageFromOneKey>;
+    post(uuid: string, name: string, data: Record<string, unknown>): Promise<void>;
     private callProtocolV1;
     private callProtocolV2;
     private createProtocolV2Adapter;

package/dist/electron-ble-transport.d.ts.map

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

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import * as _onekeyfe_hd_transport from '@onekeyfe/hd-transport';
 import _onekeyfe_hd_transport__default, { ProtocolV2UsbTransportBase, AcquireInput, TransportCallOptions, ProtocolV2Schemas, ProtocolV2CallContext, ProtocolType, OneKeyDeviceInfoBase, OneKeyDeviceInfo } from '@onekeyfe/hd-transport';
+import EventEmitter from 'events';
 import { Deferred } from '@onekeyfe/hd-shared';
 import { DesktopAPI } from '@onekeyfe/hd-transport-electron';
-import EventEmitter from 'events';
 
 /**
  * Device information with path and WebUSB device instance
@@ -19,7 +19,24 @@ declare class WebUsbTransport extends ProtocolV2UsbTransportBase<string> {
     private protocolV2SchemaSource;
     /** Per-path protocol type detected by active wire-level probe. */
     private deviceProtocol;
+    /** Protocols previously confirmed by an active response for this transport instance. */
+    private confirmedDeviceProtocols;
     private deviceProtocolHints;
+    /**
+     * Paths whose cached protocol must be re-probed on the next acquire (a USB
+     * disconnect was seen, or a transfer-level reconnect happened mid-call).
+     */
+    private staleProtocolPaths;
+    /** Paths currently acquired (between a successful acquire() and its release()). */
+    private acquiredPaths;
+    /**
+     * 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
+     * connected, and a replug/reboot always yields a new object — so an identity
+     * mismatch proves the device was re-enumerated since the probe, even when the
+     * disconnect event itself was delayed or missed.
+     */
+    private probedDeviceObjects;
     /** Per-path USB endpoint / interface numbers (discovered from USB descriptors) */
     private deviceEndpoints;
     name: string;
@@ -27,6 +44,7 @@ declare class WebUsbTransport extends ProtocolV2UsbTransportBase<string> {
     configured: boolean;
     Log?: any;
     usb?: USB;
+    emitter?: EventEmitter;
     /**
      * Cached list of connected devices
      * This is essential for maintaining device references between operations
@@ -39,7 +57,23 @@ declare class WebUsbTransport extends ProtocolV2UsbTransportBase<string> {
     /**
      * Initialize WebUSB transport
      */
-    init(logger: any): void;
+    init(logger: any, emitter?: EventEmitter): void;
+    /**
+     * Announce that a USB device left. Called from the module-scoped disconnect
+     * listener, which is why it is public rather than inlined.
+     */
+    emitDeviceDisconnect(path: string, device?: USBDevice): void;
+    /**
+     * Protocol type is a property of the physical device keyed by USB serial number.
+     * It can only change across a device reboot (e.g. normal ↔ bootloader mode), and
+     * a reboot always surfaces as a USB disconnect. Disconnects (and transfer-level
+     * reconnects, which cover a missed disconnect event) only MARK the cached probe
+     * result stale instead of deleting it: an in-flight session keeps using the old
+     * value so the transfer-level reconnect retries can absorb a transient
+     * re-enumeration exactly as they did before the cache existed, while the next
+     * acquire re-probes from scratch.
+     */
+    markProtocolStale(path: string): void;
     /**
      * Configure Protocol V1 protobuf schema (legacy chunked 0x3F framing).
      */
@@ -97,6 +131,14 @@ declare class WebUsbTransport extends ProtocolV2UsbTransportBase<string> {
     connectToDevice(path: string, first: boolean): Promise<void>;
     private closeOpenDevice;
     private clearEndpointHalt;
+    /**
+     * With the protocol cache surviving release(), deviceProtocol presence no
+     * longer implies an active session. Guard call()/post() explicitly so a
+     * post-release straggler fails fast instead of silently reopening the device
+     * and driving it outside any session (pre-cache behavior: the deleted
+     * protocol entry produced the same fail-fast).
+     */
+    private assertAcquired;
     post(session: string, name: string, data: Record<string, unknown>): Promise<void>;
     private getErrorMessage;
     private isRetryablePacketIoError;
@@ -176,6 +218,8 @@ declare class ElectronBleTransport {
     private connectedDevices;
     private deviceProtocol;
     private deviceProtocolHints;
+    /** Endpoints that answered a V2 probe in this transport lifetime. Survives disconnect. */
+    private confirmedProtocolV2;
     private deviceMtus;
     private devicePacketCapacities;
     private v1Buffers;
@@ -187,12 +231,27 @@ declare class ElectronBleTransport {
     private warnedMissingRelease;
     private notificationCleanups;
     private mtuCleanups;
-    private disconnectCleanups;
+    /**
+     * Transport-lifetime subscription to host BLE disconnects.
+     *
+     * This must NOT be scoped to acquire()/release(): a logical release keeps the
+     * native link alive for the keep-alive window, so a device that drops while
+     * idle would otherwise go unobserved and consumers would never learn it left
+     * (OK-60486).
+     */
+    private hostDisconnectCleanup?;
     private notificationTokens;
     private nextNotificationToken;
+    private toStaleBondError;
     private handleBluetoothError;
     private cleanupDeviceState;
     init(logger: any, emitter?: EventEmitter): void;
+    /**
+     * One host subscription for the whole transport lifetime. init() can run
+     * again after an SDK reset, so drop the previous listener first rather than
+     * stacking duplicates.
+     */
+    private subscribeHostDisconnects;
     configure(signedData: any): void;
     configureProtocolV2(signedData: any): void;
     listen(): Promise<OneKeyDeviceInfo[]>;
@@ -226,6 +285,7 @@ declare class ElectronBleTransport {
     private createMtuSubscription;
     private writeProtocolV2Frame;
     private handleNotification;
+    private readProtocolV2LinkDisabledFailure;
     private handleProtocolV2Notification;
     private getProtocolV2FrameQueue;
     private resolveProtocolV2Frame;
@@ -234,6 +294,7 @@ declare class ElectronBleTransport {
     private readProtocolV2Frame;
     private handleProtocolV1Notification;
     call(uuid: string, name: string, data: Record<string, unknown>, options?: TransportCallOptions): Promise<_onekeyfe_hd_transport.MessageFromOneKey>;
+    post(uuid: string, name: string, data: Record<string, unknown>): Promise<void>;
     private callProtocolV1;
     private callProtocolV2;
     private createProtocolV2Adapter;