@onekeyfe/hd-core 1.2.0-alpha.48 → 1.2.0-alpha.49

package/__tests__/check-all-firmware-release-protocol-v2.test.ts

@@ -291,7 +291,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     expect(result.targetsToUpdate).toEqual(['app_v1', 'app_v2']);
   });
 
-  test('uses the existing method on Protocol V2 and keeps its public API name', async () => {
+  test('does not read vol0 resource inventory while Protocol V2 is in Application mode', async () => {
     const method = new CheckAllFirmwareRelease({
       id: 1,
       payload: {
@@ -325,13 +325,13 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
       protocol: 'V2',
       deviceType: 'pro2',
       status: 'required',
-      resourceStatus: 'outdated',
-      targetsToUpdate: ['boot', 'app_v1', 'resource'],
+      resourceStatus: 'unknown',
+      targetsToUpdate: ['boot', 'app_v1'],
       firmware: {
         status: 'required',
       },
     });
-    expect(typedCall.mock.calls.some(call => call[0] === 'ResourceInventoryGet')).toBe(false);
+    expect(typedCall).not.toHaveBeenCalled();
     expect(method.getSupportedProtocols()).toEqual(['V1', 'V2']);
   });
 

package/__tests__/device-lifecycle-events.test.ts

@@ -1,3 +1,4 @@
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
 import { TRANSPORT_EVENT } from '@onekeyfe/hd-transport';
 
 import { initConnector, initCore } from '../src/core';
@@ -95,7 +96,7 @@ describe('public device lifecycle events', () => {
     expect(messages.filter(message => message.type === DEVICE.DISCONNECT)).toHaveLength(1);
   });
 
-  test('uses a cached protocol as a fallback-capable acquire hint', async () => {
+  test('uses a verified cached protocol as a strict expected protocol', async () => {
     jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
     const device = Device.fromDescriptor({
       id: 'ble-id',
@@ -103,16 +104,117 @@ describe('public device lifecycle events', () => {
       commType: 'ble',
       protocolType: 'V1',
     } as never);
-    const acquire = jest.fn().mockResolvedValue({ uuid: 'ble-id', protocolType: 'V2' });
+    const acquire = jest.fn().mockResolvedValue({ uuid: 'ble-id', protocolType: 'V1' });
     device.deviceConnector = { acquire } as never;
 
     await device.acquire();
 
-    expect(acquire).toHaveBeenCalledWith('ble-id', undefined, true, undefined, 'V1');
+    expect(acquire).toHaveBeenCalledWith('ble-id', undefined, true, 'V1', undefined);
+    expect(device.getProtocol()).toBe('V1');
+    expect(device.originalDescriptor.protocolType).toBe('V1');
+  });
+
+  test('bypasses a cached protocol only for explicit active detection', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    const device = Device.fromDescriptor({
+      id: 'ble-id',
+      path: 'ble-id',
+      commType: 'ble',
+      protocolType: 'V1',
+    } as never);
+    const acquire = jest.fn().mockResolvedValue({ uuid: 'ble-id', protocolType: 'V2' });
+    device.deviceConnector = { acquire } as never;
+
+    await device.acquire(undefined, { forceProtocolDetection: true });
+
+    expect(acquire).toHaveBeenCalledWith('ble-id', undefined, true, undefined, undefined);
     expect(device.getProtocol()).toBe('V2');
     expect(device.originalDescriptor.protocolType).toBe('V2');
   });
 
+  test('does not reuse a stale protocol when active detection returns no protocol', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    const device = Device.fromDescriptor({
+      id: 'ble-id',
+      path: 'ble-id',
+      commType: 'ble',
+      protocolType: 'V1',
+    } as never);
+    const acquire = jest.fn().mockResolvedValue({ uuid: 'ble-id' });
+    const release = jest.fn().mockResolvedValue(undefined);
+    device.deviceConnector = { acquire, release } as never;
+    await expect(
+      device.acquire(undefined, {
+        forceProtocolDetection: true,
+        throwOnRunPromiseError: true,
+      })
+    ).rejects.toMatchObject({ errorCode: HardwareErrorCode.RuntimeError });
+    expect(device.originalDescriptor.protocolType).toBe('V1');
+    expect(device.hasDeviceAcquire()).toBe(false);
+    expect(release).toHaveBeenCalledWith('ble-id', false);
+  });
+
+  test('actively reacquires an already connected device without initializing it', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('webusb' as never);
+    const device = Device.fromDescriptor({
+      id: 'usb-device',
+      path: 'usb-device',
+      session: 'old-session',
+      protocolType: 'V1',
+    } as never);
+    device.mainId = 'old-session';
+    device.commands = { disposed: false } as never;
+    const release = jest.spyOn(device, 'release').mockImplementation(() => {
+      device.mainId = null;
+      device.originalDescriptor.session = null;
+      device.commands.disposed = true;
+      return Promise.resolve();
+    });
+    const acquire = jest.spyOn(device, 'acquire').mockImplementation(() => {
+      device.mainId = 'new-session';
+      device.originalDescriptor.session = 'new-session';
+      device.originalDescriptor.protocolType = 'V2';
+      device.commands.disposed = false;
+      return Promise.resolve();
+    });
+    const initialize = jest.spyOn(device, 'initialize').mockResolvedValue(undefined);
+
+    await device.run(() => Promise.resolve(undefined), {
+      forceProtocolDetection: true,
+      skipInitialize: true,
+    });
+
+    expect(release).toHaveBeenCalled();
+    expect(acquire).toHaveBeenCalledWith(undefined, {
+      forceProtocolDetection: true,
+    });
+    expect(initialize).not.toHaveBeenCalled();
+    expect(device.getProtocol()).toBe('V2');
+  });
+
+  test('keeps the freshly probed React Native BLE session until the call completes', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    const device = Device.fromDescriptor({
+      id: 'ble-device',
+      path: 'ble-device',
+      commType: 'ble',
+      protocolType: 'V1',
+    } as never);
+    device.mainId = 'ble-device';
+    device.commands = { disposed: false } as never;
+    (device as unknown as { deviceAcquired: boolean }).deviceAcquired = true;
+    const release = jest.spyOn(device, 'release').mockResolvedValue(undefined);
+    const run = jest.fn().mockResolvedValue(undefined);
+
+    await device.run(run, {
+      forceProtocolDetection: true,
+      skipInitialize: true,
+    });
+
+    expect(run).toHaveBeenCalledTimes(1);
+    expect(release).toHaveBeenCalledTimes(1);
+  });
+
   test('keeps an explicit connectProtocol as a strict expected protocol', async () => {
     jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
     const device = Device.fromDescriptor({

package/__tests__/method-protocol-support.test.ts

@@ -1,6 +1,7 @@
 import { EFirmwareType, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import { BaseMethod } from '../src/api/BaseMethod';
+import { findMethod } from '../src/api/utils';
 import BTCGetAddress from '../src/api/btc/BTCGetAddress';
 import DeviceReboot from '../src/api/protocol-v2/DeviceReboot';
 import SolGetAddress from '../src/api/solana/SolGetAddress';
@@ -20,6 +21,24 @@ class DefaultMethod extends BaseMethod {
 }
 
 describe('method protocol support', () => {
+  test('creates a protocol detection method that returns only the current protocol', async () => {
+    const method = findMethod({
+      id: 6,
+      payload: {
+        method: 'detectDeviceConnectProtocol',
+        connectId: 'ble-device',
+      },
+    } as never);
+
+    method.init();
+    (method as unknown as { device: unknown }).device = {
+      getProtocol: () => 'V2',
+    };
+
+    expect(method.getSupportedProtocols()).toEqual(['V1', 'V2']);
+    await expect(method.run()).resolves.toBe('V2');
+  });
+
   test('defaults existing methods to Protocol V1 only', () => {
     const method = new DefaultMethod({
       id: 1,

package/__tests__/protocol-binding.test.ts

@@ -0,0 +1,89 @@
+import { createCoreApi, createProtocolAwareCall } from '../src/inject';
+
+import type { CoreApi } from '../src/types/api';
+
+describe('SDK protocol binding', () => {
+  test('exposes a minimal API that returns the actively detected protocol', async () => {
+    const response = { success: true as const, payload: 'V2' as const };
+    const rawCall = jest.fn().mockResolvedValue(response);
+    const api = createCoreApi(rawCall as CoreApi['call']);
+
+    await expect(api.detectDeviceConnectProtocol('USB_DEVICE_A')).resolves.toBe(response);
+    expect(rawCall).toHaveBeenCalledWith({
+      connectId: 'USB_DEVICE_A',
+      forceProtocolDetection: true,
+      method: 'detectDeviceConnectProtocol',
+    });
+  });
+
+  test('injects a strict protocol into every later call and isolates devices', async () => {
+    const rawCall = jest.fn(params => Promise.resolve({ success: true, payload: params }));
+    const protocolAwareCall = createProtocolAwareCall(rawCall as CoreApi['call']);
+    const api = createCoreApi(protocolAwareCall.call);
+
+    protocolAwareCall.setDeviceConnectProtocol('USB_DEVICE_A', 'V2');
+    protocolAwareCall.setDeviceConnectProtocol('ble-device-b', 'V1');
+
+    await api.deviceWipe('usb_device_a');
+    await api.deviceSupportFeatures('BLE-DEVICE-B');
+    await api.getFeatures('USB_DEVICE_A', { connectProtocol: 'V1' });
+    await api.getDeviceState('USB_DEVICE_A', { forceProtocolDetection: true });
+    await protocolAwareCall.call({
+      connectId: 'USB_DEVICE_A',
+      method: 'deviceUpdateReboot',
+    });
+
+    expect(rawCall).toHaveBeenNthCalledWith(1, {
+      connectId: 'usb_device_a',
+      method: 'deviceWipe',
+      connectProtocol: 'V2',
+    });
+    expect(rawCall).toHaveBeenNthCalledWith(2, {
+      connectId: 'BLE-DEVICE-B',
+      method: 'deviceSupportFeatures',
+      connectProtocol: 'V1',
+    });
+    expect(rawCall).toHaveBeenNthCalledWith(3, {
+      connectId: 'USB_DEVICE_A',
+      method: 'getFeatures',
+      connectProtocol: 'V1',
+    });
+    expect(rawCall).toHaveBeenNthCalledWith(4, {
+      connectId: 'USB_DEVICE_A',
+      method: 'getDeviceState',
+      forceProtocolDetection: true,
+    });
+    expect(rawCall).toHaveBeenNthCalledWith(5, {
+      connectId: 'USB_DEVICE_A',
+      method: 'deviceUpdateReboot',
+      connectProtocol: 'V2',
+    });
+  });
+
+  test('keeps bindings local to one SDK instance and supports clearing them', async () => {
+    const firstRawCall = jest.fn(() => Promise.resolve({ success: true, payload: {} }));
+    const secondRawCall = jest.fn(() => Promise.resolve({ success: true, payload: {} }));
+    const first = createProtocolAwareCall(firstRawCall as CoreApi['call']);
+    const second = createProtocolAwareCall(secondRawCall as CoreApi['call']);
+
+    first.setDeviceConnectProtocol('same-device', 'V2');
+    await first.call({ connectId: 'same-device', method: 'deviceWipe' });
+    await second.call({ connectId: 'same-device', method: 'deviceWipe' });
+    first.setDeviceConnectProtocol('same-device', undefined);
+    await first.call({ connectId: 'same-device', method: 'deviceWipe' });
+
+    expect(firstRawCall).toHaveBeenNthCalledWith(1, {
+      connectId: 'same-device',
+      method: 'deviceWipe',
+      connectProtocol: 'V2',
+    });
+    expect(secondRawCall).toHaveBeenCalledWith({
+      connectId: 'same-device',
+      method: 'deviceWipe',
+    });
+    expect(firstRawCall).toHaveBeenNthCalledWith(2, {
+      connectId: 'same-device',
+      method: 'deviceWipe',
+    });
+  });
+});

package/__tests__/protocol-v2.test.ts

@@ -3923,6 +3923,68 @@ describe('Protocol V2 firmware update targets', () => {
     });
   });
 
+  test('enters Protocol V2 bootloader before reading and downloading remote resources', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+        targetsToUpdate: ['resource'],
+      },
+    });
+    method.init();
+
+    (method as any).device = stubDevice({
+      originalDescriptor: { id: 'usb-id', path: 'app-path', protocolType: 'V2' },
+      features: {
+        deviceType: 'pro2',
+        firmwareVersion: '1.0.0',
+        mode: 'normal',
+        bootloaderMode: false,
+        capabilities: [],
+      },
+      isBootloader: () => false,
+      isRomloader: () => false,
+    });
+    (method as any).captureProtocolV2PhysicalIdentity = jest.fn().mockResolvedValue(undefined);
+    (method as any).prepareRemoteProtocolV2Binaries = jest.fn().mockResolvedValue({
+      bootloaderBinary: null,
+      fwBinaryMap: [],
+      installItems: [],
+    });
+
+    const order: string[] = [];
+    (method as any).enterProtocolV2BootloaderMode = jest.fn().mockImplementation(() => {
+      order.push('enter-bootloader');
+      return Promise.resolve(true);
+    });
+    (method as any).prepareProtocolV2ResourceBundles = jest.fn().mockImplementation(() => {
+      order.push('prepare-resources');
+      return Promise.resolve([
+        {
+          name: 'images.okpkg',
+          binary: new Uint8Array([1]).buffer,
+          devicePath: 'vol0:/bundles/images/images.okpkg',
+        },
+      ]);
+    });
+    (method as any).executeProtocolV2Update = jest.fn().mockImplementation(() => {
+      order.push('execute-update');
+      return Promise.resolve();
+    });
+    (method as any).exitProtocolV2BootloaderToNormal = jest.fn().mockResolvedValue(undefined);
+    (method as any).waitForProtocolV2FinalFeatures = jest.fn().mockResolvedValue({
+      bootloaderVersion: '1.0.0',
+      bleVersion: '1.0.0',
+      firmwareVersion: '1.0.0',
+    });
+    method.postTipMessage = jest.fn();
+
+    await method.run();
+
+    expect(order).toEqual(['enter-bootloader', 'prepare-resources', 'execute-update']);
+  });
+
   test('reboots Protocol V2 normal-mode device to bootloader before transfer', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -3972,6 +4034,33 @@ describe('Protocol V2 firmware update targets', () => {
     expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(1);
   });
 
+  test('keeps Protocol V2 bootloader active before firmware transfer', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    (method as any).device = stubDevice({
+      originalDescriptor: { id: 'usb-id', path: 'bootloader-path', protocolType: 'V2' },
+      features: {
+        deviceType: 'pro2',
+        mode: 'bootloader',
+        bootloaderMode: true,
+        capabilities: [],
+      },
+      isBootloader: () => true,
+      isRomloader: () => false,
+    });
+    (method as any).protocolV2Reboot = jest.fn();
+    method.postTipMessage = jest.fn();
+
+    await expect((method as any).enterProtocolV2BootloaderMode()).resolves.toBe(false);
+
+    expect((method as any).protocolV2Reboot).not.toHaveBeenCalled();
+    expect(method.postTipMessage).not.toHaveBeenCalledWith('AutoRebootToBootloader');
+  });
+
   test('keeps Protocol V2 romloader active before firmware transfer', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -4039,7 +4128,7 @@ describe('Protocol V2 firmware update targets', () => {
 
     await method.run();
 
-    expect(prepareResourceBundles).toHaveBeenCalledWith(true);
+    expect(prepareResourceBundles).not.toHaveBeenCalled();
     expect((method as any).protocolV2Reboot).not.toHaveBeenCalled();
     expect((method as any).executeProtocolV2Update).toHaveBeenCalledWith({
       bootloaderBinary: null,
@@ -4122,7 +4211,10 @@ describe('Protocol V2 firmware update targets', () => {
       getCommands: () => commands,
       mainId: 'usb-path',
     });
-    const cachedDevice = { getConnectId: () => 'usb-path' };
+    const cachedDevice = {
+      getConnectId: () => 'usb-path',
+      getCurrentSerialNo: () => '',
+    };
     const getDevices = jest.spyOn(DevicePool, 'getDevices').mockResolvedValue({
       devices: {},
       deviceList: [cachedDevice],
@@ -4139,6 +4231,182 @@ describe('Protocol V2 firmware update targets', () => {
     expect(initialize).not.toHaveBeenCalled();
   });
 
+  test('selects the matching physical device from multiple Protocol V2 USB reconnect candidates', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const commands = { disposed: true, mainId: '' };
+    const updateFromCache = jest.fn();
+    const device = stubDevice({
+      originalDescriptor: { id: 'old-usb-id', path: 'old-usb-path', protocolType: 'V2' },
+      deviceConnector: {
+        enumerate: jest.fn().mockResolvedValue({
+          descriptors: [
+            { id: 'usb-a', path: 'usb-a', protocolType: 'V2' },
+            { id: 'usb-b', path: 'usb-b', protocolType: 'V2' },
+          ],
+        }),
+      },
+      updateFromCache,
+      hasDeviceAcquire: jest.fn(() => false),
+      acquire: jest.fn().mockResolvedValue(undefined),
+      commands,
+      getCommands: () => commands,
+      mainId: 'old-usb-path',
+    });
+    const otherDevice = {
+      getConnectId: () => 'usb-a',
+      getCurrentSerialNo: () => 'PRO2-PHYSICAL-A',
+    };
+    const expectedDevice = {
+      getConnectId: () => 'usb-b',
+      getCurrentSerialNo: () => 'PRO2-PHYSICAL-B',
+    };
+    const getDevices = jest.spyOn(DevicePool, 'getDevices').mockResolvedValue({
+      devices: {},
+      deviceList: [otherDevice, expectedDevice],
+    } as any);
+    (method as any).device = device;
+    (method as any).protocolV2ExpectedSerialNumber = 'PRO2-PHYSICAL-B';
+
+    try {
+      await (method as any).reconnectProtocolV2Device();
+    } finally {
+      getDevices.mockRestore();
+    }
+
+    expect(updateFromCache).toHaveBeenCalledWith(expectedDevice);
+  });
+
+  test('rejects ambiguous Protocol V2 USB reconnect candidates without an identity match', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const updateFromCache = jest.fn();
+    const device = stubDevice({
+      originalDescriptor: { id: 'old-usb-id', path: 'old-usb-path', protocolType: 'V2' },
+      deviceConnector: {
+        enumerate: jest.fn().mockResolvedValue({
+          descriptors: [
+            { id: 'usb-a', path: 'usb-a', protocolType: 'V2' },
+            { id: 'usb-b', path: 'usb-b', protocolType: 'V2' },
+          ],
+        }),
+      },
+      updateFromCache,
+    });
+    const getDevices = jest.spyOn(DevicePool, 'getDevices').mockResolvedValue({
+      devices: {},
+      deviceList: [
+        {
+          getConnectId: () => 'usb-a',
+          getCurrentSerialNo: () => 'PRO2-PHYSICAL-A',
+        },
+        {
+          getConnectId: () => 'usb-b',
+          getCurrentSerialNo: () => 'PRO2-PHYSICAL-B',
+        },
+      ],
+    } as any);
+    (method as any).device = device;
+    (method as any).protocolV2ExpectedSerialNumber = 'PRO2-PHYSICAL-C';
+
+    try {
+      await expect((method as any).reconnectProtocolV2Device()).rejects.toBeDefined();
+    } finally {
+      getDevices.mockRestore();
+    }
+
+    expect(updateFromCache).not.toHaveBeenCalled();
+  });
+
+  test('allows a single Protocol V2 USB reconnect candidate when its physical serial is unavailable', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const commands = { disposed: true, mainId: '' };
+    const updateFromCache = jest.fn();
+    const device = stubDevice({
+      originalDescriptor: { id: 'old-usb-id', path: 'old-usb-path', protocolType: 'V2' },
+      deviceConnector: {
+        enumerate: jest.fn().mockResolvedValue({
+          descriptors: [{ id: 'usb-a', path: 'usb-a', protocolType: 'V2' }],
+        }),
+      },
+      updateFromCache,
+      hasDeviceAcquire: jest.fn(() => false),
+      acquire: jest.fn().mockResolvedValue(undefined),
+      commands,
+      getCommands: () => commands,
+      mainId: 'old-usb-path',
+    });
+    const candidate = {
+      getConnectId: () => 'usb-a',
+      getCurrentSerialNo: () => '',
+    };
+    const getDevices = jest.spyOn(DevicePool, 'getDevices').mockResolvedValue({
+      devices: {},
+      deviceList: [candidate],
+    } as any);
+    (method as any).device = device;
+    (method as any).protocolV2ExpectedSerialNumber = 'PRO2-PHYSICAL-A';
+
+    try {
+      await (method as any).reconnectProtocolV2Device();
+    } finally {
+      getDevices.mockRestore();
+    }
+
+    expect(updateFromCache).toHaveBeenCalledWith(candidate);
+  });
+
+  test('rejects a single Protocol V2 USB reconnect candidate with a different physical serial', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const updateFromCache = jest.fn();
+    const device = stubDevice({
+      originalDescriptor: { id: 'old-usb-id', path: 'old-usb-path', protocolType: 'V2' },
+      deviceConnector: {
+        enumerate: jest.fn().mockResolvedValue({
+          descriptors: [{ id: 'usb-a', path: 'usb-a', protocolType: 'V2' }],
+        }),
+      },
+      updateFromCache,
+    });
+    const getDevices = jest.spyOn(DevicePool, 'getDevices').mockResolvedValue({
+      devices: {},
+      deviceList: [
+        {
+          getConnectId: () => 'usb-a',
+          getCurrentSerialNo: () => 'PRO2-PHYSICAL-A',
+        },
+      ],
+    } as any);
+    (method as any).device = device;
+    (method as any).protocolV2ExpectedSerialNumber = 'PRO2-PHYSICAL-B';
+
+    try {
+      await expect((method as any).reconnectProtocolV2Device()).rejects.toBeDefined();
+    } finally {
+      getDevices.mockRestore();
+    }
+
+    expect(updateFromCache).not.toHaveBeenCalled();
+  });
+
   test('reuses an acquired Protocol V2 USB session while polling reconnect readiness', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -5938,14 +6206,14 @@ describe('Protocol V2 firmware reconnect identity', () => {
       .mockReturnValue(stable as any);
     (method as any).downloadProtocolV2Resource = jest.fn();
 
-    await expect((method as any).prepareProtocolV2ResourceBundles(false)).resolves.toEqual([]);
+    await expect((method as any).prepareProtocolV2ResourceBundles()).resolves.toEqual([]);
     expect(typedCall.mock.calls.some(call => call[0] === 'ResourceInventoryGet')).toBe(false);
     expect(typedCall.mock.calls.some(call => call[0] === 'FilesystemFileRead')).toBe(true);
     expect((method as any).downloadProtocolV2Resource).not.toHaveBeenCalled();
     resourcesSpy.mockRestore();
   });
 
-  test('downloads only changed resources in Application mode', async () => {
+  test('downloads only changed resources from loader inventory', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: { method: 'firmwareUpdateV4', platform: 'web', targetsToUpdate: ['resource'] },
@@ -5973,7 +6241,7 @@ describe('Protocol V2 firmware reconnect identity', () => {
       })
     );
 
-    const bundles = await (method as any).prepareProtocolV2ResourceBundles(false);
+    const bundles = await (method as any).prepareProtocolV2ResourceBundles();
 
     expect(bundles).toHaveLength(1);
     expect((method as any).downloadProtocolV2Resource).toHaveBeenCalledWith(stable[0]);
@@ -6008,7 +6276,7 @@ describe('Protocol V2 firmware reconnect identity', () => {
       })
     );
 
-    const bundles = await (method as any).prepareProtocolV2ResourceBundles(true);
+    const bundles = await (method as any).prepareProtocolV2ResourceBundles();
 
     expect(bundles).toHaveLength(1);
     expect(typedCall.mock.calls.some(call => call[0] === 'ResourceInventoryGet')).toBe(false);

package/__tests__/search-devices.test.ts

@@ -42,7 +42,7 @@ describe('SearchDevices', () => {
     mockIsBleConnect.mockReturnValue(false);
   });
 
-  test('单个 USB 描述符无响应时跳过该设备并继续搜索', async () => {
+  test('搜索忽略调用方协议并主动探测，单个无响应设备不阻断后续结果', async () => {
     const unresponsiveDescriptor = {
       path: 'stale-usb-device',
       id: 'stale-usb-device',
@@ -74,6 +74,7 @@ describe('SearchDevices', () => {
       id: 1,
       payload: {
         method: 'searchDevices',
+        connectProtocol: 'V2',
       },
     } as any);
     method.init();
@@ -89,13 +90,21 @@ describe('SearchDevices', () => {
       1,
       [unresponsiveDescriptor],
       unresponsiveDescriptor.path,
-      { connectProtocol: undefined, refreshRuntimeState: true }
+      {
+        connectProtocol: undefined,
+        forceProtocolDetection: true,
+        refreshRuntimeState: true,
+      }
     );
     expect(mockGetDevices).toHaveBeenNthCalledWith(
       2,
       [availableDescriptor],
       availableDescriptor.path,
-      { connectProtocol: undefined, refreshRuntimeState: true }
+      {
+        connectProtocol: undefined,
+        forceProtocolDetection: true,
+        refreshRuntimeState: true,
+      }
     );
   });
 

package/dist/api/CheckAllFirmwareRelease.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CheckAllFirmwareRelease.d.ts","sourceRoot":"","sources":["../../src/api/CheckAllFirmwareRelease.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAA6B,MAAM,qBAAqB,CAAC;AAY/E,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAM1C,OAAO,KAAK,EACV,kBAAkB,EAElB,kCAAkC,EAClC,+BAA+B,EAChC,MAAM,sCAAsC,CAAC;AAC9C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAC1E,OAAO,KAAK,EACV,oBAAoB,EACpB,mBAAmB,EACnB,oBAAoB,EAGrB,MAAM,UAAU,CAAC;AA6HlB,KAAK,6BAA6B,GAAG;IACnC,YAAY,EAAE,aAAa,CAAC;IAC5B,MAAM,EAAE,+BAA+B,CAAC;IACxC,UAAU,EAAE,OAAO,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;IAClB,eAAe,EAAE,mBAAmB,CAAC;IACrC,UAAU,EAAE,kCAAkC,EAAE,CAAC;IACjD,eAAe,EAAE,sBAAsB,EAAE,CAAC;IAC1C,OAAO,EAAE,oBAAoB,GAAG,SAAS,CAAC;CAC3C,CAAC;AAEF,wBAAgB,8BAA8B,CAAC,EAC7C,eAAe,EACf,mBAAwB,EACxB,mBAAwB,EACxB,YAAY,EACZ,OAAO,GACR,EAAE;IACD,eAAe,EAAE,mBAAmB,CAAC;IACrC,mBAAmB,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACpD,mBAAmB,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC;IAC9D,YAAY,EAAE,aAAa,CAAC;IAC5B,OAAO,EAAE,oBAAoB,GAAG,SAAS,CAAC;CAC3C,GAAG,6BAA6B,CAoEhC;AAED,MAAM,CAAC,OAAO,OAAO,uBAAwB,SAAQ,UAAU;IAC7D,qBAAqB;IAIrB,IAAI;IAME,GAAG;YAuDK,aAAa;CAmF5B"}
+{"version":3,"file":"CheckAllFirmwareRelease.d.ts","sourceRoot":"","sources":["../../src/api/CheckAllFirmwareRelease.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAA6B,MAAM,qBAAqB,CAAC;AAY/E,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAM1C,OAAO,KAAK,EACV,kBAAkB,EAElB,kCAAkC,EAClC,+BAA+B,EAChC,MAAM,sCAAsC,CAAC;AAC9C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAC1E,OAAO,KAAK,EACV,oBAAoB,EACpB,mBAAmB,EACnB,oBAAoB,EAGrB,MAAM,UAAU,CAAC;AA6HlB,KAAK,6BAA6B,GAAG;IACnC,YAAY,EAAE,aAAa,CAAC;IAC5B,MAAM,EAAE,+BAA+B,CAAC;IACxC,UAAU,EAAE,OAAO,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;IAClB,eAAe,EAAE,mBAAmB,CAAC;IACrC,UAAU,EAAE,kCAAkC,EAAE,CAAC;IACjD,eAAe,EAAE,sBAAsB,EAAE,CAAC;IAC1C,OAAO,EAAE,oBAAoB,GAAG,SAAS,CAAC;CAC3C,CAAC;AAEF,wBAAgB,8BAA8B,CAAC,EAC7C,eAAe,EACf,mBAAwB,EACxB,mBAAwB,EACxB,YAAY,EACZ,OAAO,GACR,EAAE;IACD,eAAe,EAAE,mBAAmB,CAAC;IACrC,mBAAmB,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACpD,mBAAmB,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC;IAC9D,YAAY,EAAE,aAAa,CAAC;IAC5B,OAAO,EAAE,oBAAoB,GAAG,SAAS,CAAC;CAC3C,GAAG,6BAA6B,CAoEhC;AAED,MAAM,CAAC,OAAO,OAAO,uBAAwB,SAAQ,UAAU;IAC7D,qBAAqB;IAIrB,IAAI;IAME,GAAG;YAuDK,aAAa;CAqF5B"}

package/dist/api/DetectDeviceConnectProtocol.d.ts

@@ -0,0 +1,7 @@
+import { BaseMethod } from './BaseMethod';
+export default class DetectDeviceConnectProtocol extends BaseMethod {
+    init(): void;
+    getSupportedProtocols(): readonly ["V1", "V2"];
+    run(): Promise<"V1" | "V2">;
+}
+//# sourceMappingURL=DetectDeviceConnectProtocol.d.ts.map

package/dist/api/DetectDeviceConnectProtocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DetectDeviceConnectProtocol.d.ts","sourceRoot":"","sources":["../../src/api/DetectDeviceConnectProtocol.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,MAAM,CAAC,OAAO,OAAO,2BAA4B,SAAQ,UAAU;IACjE,IAAI;IAOJ,qBAAqB;IAIrB,GAAG;CAGJ"}