@onekeyfe/hd-core 1.2.0-alpha.8 → 1.2.0-alpha.81

package/src/api/GetDeviceState.ts

@@ -0,0 +1,59 @@
+import { ERRORS, HardwareErrorCode, createDeviceNotSupportMethodError } from '@onekeyfe/hd-shared';
+
+import { UI_REQUEST } from '../constants/ui-request';
+import { BaseMethod } from './BaseMethod';
+
+import type { DeviceStateSection } from '../types';
+import type { DeviceStateScope, GetDeviceStateParams } from '../types/api/getDeviceState';
+
+const SCOPE_SECTIONS: Record<DeviceStateScope, DeviceStateSection[]> = {
+  runtime: ['status'],
+  settings: ['status', 'settings'],
+  firmware: ['status', 'identity', 'versions', 'verification'],
+};
+
+const isLoaderMode = (mode: string) => mode === 'bootloader' || mode === 'romloader';
+
+export default class GetDeviceState extends BaseMethod<
+  Required<Pick<GetDeviceStateParams, 'scope'>>
+> {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
+  init() {
+    const scope = (this.payload.scope ?? 'runtime') as DeviceStateScope;
+    if (!Object.prototype.hasOwnProperty.call(SCOPE_SECTIONS, scope)) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallMethodInvalidParameter,
+        `Unsupported device state scope: ${String(scope)}`
+      );
+    }
+    this.allowDeviceMode = [
+      ...this.allowDeviceMode,
+      UI_REQUEST.NOT_INITIALIZE,
+      UI_REQUEST.BOOTLOADER,
+    ];
+    this.unlockPolicy = 'none';
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+    this.params = { scope };
+  }
+
+  async run() {
+    const state = await this.device.getDeviceState({
+      refreshSections: SCOPE_SECTIONS[this.params.scope],
+    });
+    if (
+      this.params.scope === 'settings' &&
+      this.device.isProtocolV2() &&
+      isLoaderMode(state.status.mode)
+    ) {
+      throw createDeviceNotSupportMethodError(
+        `${this.name}:${this.params.scope}`,
+        this.device.getCurrentFirmwareType()
+      );
+    }
+    return state;
+  }
+}

package/src/api/GetFeatures.ts

@@ -1,10 +1,12 @@
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import { UI_REQUEST } from '../constants/ui-request';
+import { projectFeatures } from '../device/DeviceStateProjector';
 import { BaseMethod } from './BaseMethod';
 
 export default class GetFeatures extends BaseMethod {
   init() {
+    this.unlockPolicy = 'none';
     this.allowDeviceMode = [
       ...this.allowDeviceMode,
       UI_REQUEST.NOT_INITIALIZE,
@@ -18,9 +20,9 @@ export default class GetFeatures extends BaseMethod {
     if (this.payload?.detectBootloaderDevice && this.device.isBootloader()) {
       return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceDetectInBootloaderMode));
     }
-    if (this.device.isProtocolV2()) {
-      return this.device.getFeatures();
-    }
-    return Promise.resolve(this.device.features);
+    const state = await this.device.getDeviceState({
+      includeRaw: true,
+    });
+    return projectFeatures(state);
   }
 }

package/src/api/GetOnekeyFeatures.ts

@@ -2,82 +2,19 @@ import semver from 'semver';
 
 import { UI_REQUEST } from '../constants/ui-request';
 import { fixVersion } from '../utils/deviceFeaturesUtils';
-import { PROTOCOL_V2_DEVICE_INFO_REQUEST } from '../protocols/protocol-v2';
-import { requestProtocolV2DeviceInfo } from '../protocols/protocol-v2/features';
 import { BaseMethod } from './BaseMethod';
 
 import type { OnekeyFeatures } from '../types';
 
-const ONEKEY_FEATURE_KEYS: Array<keyof OnekeyFeatures> = [
-  'onekey_device_type',
-  'onekey_board_version',
-  'onekey_boot_version',
-  'onekey_firmware_version',
-  'onekey_board_hash',
-  'onekey_boot_hash',
-  'onekey_firmware_hash',
-  'onekey_board_build_id',
-  'onekey_boot_build_id',
-  'onekey_firmware_build_id',
-  'onekey_serial_no',
-  'onekey_ble_name',
-  'onekey_ble_version',
-  'onekey_ble_build_id',
-  'onekey_ble_hash',
-  'onekey_se_type',
-  'onekey_se01_state',
-  'onekey_se02_state',
-  'onekey_se03_state',
-  'onekey_se04_state',
-  'onekey_se01_version',
-  'onekey_se02_version',
-  'onekey_se03_version',
-  'onekey_se04_version',
-  'onekey_se01_hash',
-  'onekey_se02_hash',
-  'onekey_se03_hash',
-  'onekey_se04_hash',
-  'onekey_se01_build_id',
-  'onekey_se02_build_id',
-  'onekey_se03_build_id',
-  'onekey_se04_build_id',
-  'onekey_se01_boot_version',
-  'onekey_se02_boot_version',
-  'onekey_se03_boot_version',
-  'onekey_se04_boot_version',
-  'onekey_se01_boot_hash',
-  'onekey_se02_boot_hash',
-  'onekey_se03_boot_hash',
-  'onekey_se04_boot_hash',
-  'onekey_se01_boot_build_id',
-  'onekey_se02_boot_build_id',
-  'onekey_se03_boot_build_id',
-  'onekey_se04_boot_build_id',
-];
-
 function normalizeOnekeyFirmwareVersion(message: OnekeyFeatures) {
   if (message.onekey_firmware_version && !semver.valid(message.onekey_firmware_version)) {
     message.onekey_firmware_version = fixVersion(message.onekey_firmware_version);
   }
 }
 
-function pickOnekeyFeatures(features?: OnekeyFeatures | null): OnekeyFeatures {
-  const message: OnekeyFeatures = {};
-  if (!features) return message;
-
-  for (const key of ONEKEY_FEATURE_KEYS) {
-    const value = features[key];
-    if (value !== undefined && value !== null) {
-      (message as Record<string, unknown>)[key] = value;
-    }
-  }
-
-  normalizeOnekeyFirmwareVersion(message);
-  return message;
-}
-
 export default class GetOnekeyFeatures extends BaseMethod {
   init() {
+    this.unlockPolicy = 'none';
     this.allowDeviceMode = [
       ...this.allowDeviceMode,
       UI_REQUEST.NOT_INITIALIZE,
@@ -88,17 +25,6 @@ export default class GetOnekeyFeatures extends BaseMethod {
   }
 
   async run() {
-    if (this.device.isProtocolV2()) {
-      // V2 没有 OnekeyGetFeatures 消息：
-      // 取完整 DeviceInfoGet（含 SE/hash/build_id）后刷新结构化 features 缓存。
-      const deviceInfo = await requestProtocolV2DeviceInfo({
-        commands: this.device.commands,
-        request: PROTOCOL_V2_DEVICE_INFO_REQUEST,
-      });
-      const features = this.device.updateProtocolV2Features(deviceInfo);
-      return pickOnekeyFeatures(features as OnekeyFeatures);
-    }
-
     const { message } = await this.device.commands.typedCall('OnekeyGetFeatures', 'OnekeyFeatures');
     normalizeOnekeyFirmwareVersion(message);
     return Promise.resolve(message);

package/src/api/GetPassphraseState.ts

@@ -1,37 +1,52 @@
-import { EDeviceType } from '@onekeyfe/hd-shared';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
 
 import { UI_REQUEST } from '../constants/ui-request';
+import { refreshProtocolV2DeviceStatus } from '../protocols/protocol-v2/walletSession';
 import { getPassphraseStateWithRefreshDeviceInfo } from '../utils/deviceFeaturesUtils';
 import { BaseMethod } from './BaseMethod';
 
 export default class GetPassphraseState extends BaseMethod {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   init() {
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
     this.useDevicePassphraseState = false;
   }
 
   async run() {
-    const { passphraseState, newSession, unlockedAttachPin } =
-      await getPassphraseStateWithRefreshDeviceInfo(this.device, {
-        expectPassphraseState: this.payload.passphraseState,
-        onlyMainPin: this.payload.useEmptyPassphrase,
-        allowCreateAttachPin: this.payload.allowCreateAttachPin,
-        initSession: this.payload.initSession,
-      });
+    if (!this.device.features) {
+      throw ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed);
+    }
+
+    const isProtocolV2 = this.device.isProtocolV2();
+    if (isProtocolV2 && this.payload.useEmptyPassphrase !== true) {
+      const features = await refreshProtocolV2DeviceStatus(this.device);
+      if (features.unlocked === false) {
+        await this.device.unlockDevice(DeviceSessionPinType.Main, {
+          source: 'unlock-coordinator',
+          reason: 'device-locked',
+          deviceOnly: true,
+          method: 'getPassphraseState',
+        });
+      }
+    }
+    const { passphraseState } = await getPassphraseStateWithRefreshDeviceInfo(
+      this.device,
+      isProtocolV2
+        ? {
+            onlyMainPin: this.payload.useEmptyPassphrase === true,
+            initSession: this.payload.initSession === true,
+          }
+        : undefined
+    );
 
-    const { features } = this.device;
-    const passphraseProtection = this.device.getCurrentPassphraseProtection() ?? null;
-    const deviceType = this.device.getCurrentDeviceType();
-    const isProSeries = deviceType === EDeviceType.Pro || deviceType === EDeviceType.Pro2;
+    if (!isProtocolV2 && this.device.getCurrentPassphraseProtection() !== true) {
+      return undefined;
+    }
 
-    // refresh device info
-    return Promise.resolve({
-      passphraseState: isProSeries || passphraseProtection === true ? passphraseState : undefined,
-      sessionId: this.payload.initSession
-        ? newSession ?? undefined
-        : newSession ?? features?.sessionId ?? undefined,
-      unlockedAttachPin: unlockedAttachPin ?? features?.unlockedAttachPin,
-      passphraseProtection,
-    });
+    return passphraseState;
   }
 }

package/src/api/OpenWalletSession.ts

@@ -0,0 +1,268 @@
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
+
+import { deviceWalletSessionStore } from '../device/DeviceWalletSessionStore';
+import { getProtocolV2WalletSession } from '../protocols/protocol-v2/walletSession';
+import { getPassphraseStateWithRefreshDeviceInfo } from '../utils/deviceFeaturesUtils';
+import { BaseMethod } from './BaseMethod';
+import { invalidParameter } from './helpers/paramsValidator';
+import { OpenWalletSessionMode } from '../types/api/openWalletSession';
+
+import type {
+  OpenWalletSessionParams,
+  OpenWalletSessionPayload,
+} from '../types/api/openWalletSession';
+
+const requiredString = (value: unknown, name: string) => {
+  if (value === undefined || value === null) {
+    throw invalidParameter(`Missing required parameter: ${name}`);
+  }
+  if (typeof value !== 'string' || !value.trim()) {
+    throw invalidParameter(`Parameter [${name}] must be a non-empty string.`);
+  }
+  return value.trim();
+};
+
+const wasResumed = (session: unknown) =>
+  !!session &&
+  typeof session === 'object' &&
+  'resumed' in session &&
+  (session as { resumed?: unknown }).resumed === true;
+
+const requireHiddenWalletResponse = (session: { passphraseState?: string }) => {
+  if (!session.passphraseState) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.DeviceInitializeFailed,
+      'Hidden wallet response is missing passphraseState'
+    );
+  }
+  return {
+    passphraseState: session.passphraseState,
+  };
+};
+
+const normalizeParams = (payload: Record<string, unknown>): OpenWalletSessionParams => {
+  if (payload.mode === undefined) {
+    throw invalidParameter('Parameter [mode] is required.');
+  }
+  if (
+    payload.mode !== OpenWalletSessionMode.Standard &&
+    payload.mode !== OpenWalletSessionMode.SelectHidden &&
+    payload.mode !== OpenWalletSessionMode.ResumeHidden
+  ) {
+    throw invalidParameter(
+      'Parameter [mode] must be one of standard, select-hidden, or resume-hidden.'
+    );
+  }
+  if (payload.useEmptyPassphrase !== undefined || payload.initSession !== undefined) {
+    throw invalidParameter(
+      'Legacy parameters [useEmptyPassphrase] and [initSession] are not supported by openWalletSession.'
+    );
+  }
+  if (
+    payload.mode === OpenWalletSessionMode.Standard ||
+    payload.mode === OpenWalletSessionMode.SelectHidden
+  ) {
+    if (payload.deviceId !== undefined || payload.passphraseState !== undefined) {
+      throw invalidParameter(
+        'Parameters [deviceId] and [passphraseState] are only allowed with mode [resume-hidden].'
+      );
+    }
+    return { mode: payload.mode };
+  }
+  return {
+    mode: OpenWalletSessionMode.ResumeHidden,
+    deviceId: requiredString(payload.deviceId, 'deviceId'),
+    passphraseState: requiredString(payload.passphraseState, 'passphraseState'),
+  };
+};
+
+export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParams> {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
+  init() {
+    this.useDevicePassphraseState = false;
+    this.unlockPolicy = 'unlock-before-run';
+    this.skipForceUpdateCheck = true;
+    this.params = normalizeParams(this.payload as unknown as Record<string, unknown>);
+    this.payload.useEmptyPassphrase = this.params.mode === OpenWalletSessionMode.Standard;
+  }
+
+  async run(): Promise<OpenWalletSessionPayload> {
+    const isProtocolV2 = this.device.isProtocolV2();
+    let state = await this.device.getDeviceState({ refreshSections: ['status'] });
+    let currentDeviceId = state.identity.deviceId;
+    const hasAuthoritativeProtocolV2WalletStatus = (candidate: typeof state) =>
+      candidate.status.unlocked === true &&
+      typeof candidate.status.passphraseProtection === 'boolean' &&
+      typeof candidate.status.unlockedAttachPin === 'boolean';
+    const requireAuthoritativeProtocolV2WalletStatus = (candidate: typeof state) => {
+      if (!hasAuthoritativeProtocolV2WalletStatus(candidate)) {
+        throw ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed);
+      }
+      return candidate;
+    };
+    const requireDeviceId = () => {
+      if (!currentDeviceId) {
+        throw ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed);
+      }
+      return currentDeviceId;
+    };
+    const refreshProtocolV2DeviceState = async () => {
+      state = await this.device.getDeviceState({ refreshSections: ['status'] });
+      currentDeviceId = state.identity.deviceId;
+      return state;
+    };
+    const ensureProtocolV2WalletStatus = async () => {
+      if (isProtocolV2 && !hasAuthoritativeProtocolV2WalletStatus(state)) {
+        await this.device.unlockDevice(DeviceSessionPinType.Main, {
+          source: 'unlock-coordinator',
+          reason: 'device-locked',
+          deviceOnly: true,
+          method: 'openWalletSession',
+        });
+        requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState());
+      }
+      return state;
+    };
+
+    const protocol = isProtocolV2 ? 'V2' : 'V1';
+
+    if (this.params.mode === OpenWalletSessionMode.Standard) {
+      this.device.passphraseState = undefined;
+      const session = isProtocolV2
+        ? await getProtocolV2WalletSession(this.device, {
+            onlyMainPin: true,
+            deriveCardano: this.payload.deriveCardano,
+            selectMainWalletBeforeRestore:
+              !hasAuthoritativeProtocolV2WalletStatus(state) ||
+              state.status.unlockedAttachPin === true,
+          })
+        : await getPassphraseStateWithRefreshDeviceInfo(this.device, {
+            onlyMainPin: true,
+            initSession: this.payload.initSession,
+          });
+      const refreshedState = isProtocolV2
+        ? requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState())
+        : state;
+      const deviceId = requireDeviceId();
+      if (
+        session.unlockedAttachPin ||
+        (isProtocolV2 && refreshedState.status.unlockedAttachPin === true)
+      ) {
+        try {
+          await this.device.lockDevice();
+        } catch {
+          // The wallet context is rejected even when an older device cannot be locked.
+        }
+        this.device.clearInternalState();
+        throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckUnlockTypeError);
+      }
+      return {
+        protocol,
+        walletType: 'standard',
+        deviceId,
+        passphraseState: null,
+        resumed: wasResumed(session),
+      };
+    }
+
+    if (this.params.mode === OpenWalletSessionMode.ResumeHidden) {
+      if (isProtocolV2) {
+        await ensureProtocolV2WalletStatus();
+        const refreshedDeviceId = requireDeviceId();
+        if (refreshedDeviceId !== this.params.deviceId) {
+          deviceWalletSessionStore.delete(this.params.deviceId, this.params.passphraseState);
+          throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
+        }
+      } else if (requireDeviceId() !== this.params.deviceId) {
+        throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
+      }
+      this.device.passphraseState = this.params.passphraseState;
+      const cachedSessionId = deviceWalletSessionStore.get(
+        this.params.deviceId,
+        this.params.passphraseState
+      );
+      if (!cachedSessionId && !isProtocolV2) {
+        throw ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid);
+      }
+      if (!isProtocolV2) {
+        await this.device.initialize({
+          deviceId: this.params.deviceId,
+          passphraseState: this.params.passphraseState,
+        });
+      }
+      const session = isProtocolV2
+        ? await getProtocolV2WalletSession(this.device, {
+            expectedPassphraseState: this.params.passphraseState,
+            deriveCardano: this.payload.deriveCardano,
+          })
+        : await getPassphraseStateWithRefreshDeviceInfo(this.device, {
+            expectPassphraseState: this.params.passphraseState,
+          });
+      const deviceId = requireDeviceId();
+      if (session.passphraseState !== this.params.passphraseState) {
+        this.device.clearInternalState();
+        throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);
+      }
+      return {
+        protocol,
+        walletType: 'hidden',
+        deviceId,
+        ...requireHiddenWalletResponse(session),
+        resumed: wasResumed(session) || (!isProtocolV2 && session.newSession === cachedSessionId),
+      };
+    }
+
+    this.device.passphraseState = undefined;
+    const walletStatus = await ensureProtocolV2WalletStatus();
+    if (isProtocolV2 && walletStatus.status.passphraseProtection !== true) {
+      this.device.clearInternalState();
+      throw ERRORS.TypedError(HardwareErrorCode.DeviceNotOpenedPassphrase);
+    }
+    const readCurrentAttachPinSession =
+      isProtocolV2 && walletStatus.status.unlockedAttachPin === true;
+    const session = isProtocolV2
+      ? await getProtocolV2WalletSession(this.device, {
+          ...(readCurrentAttachPinSession
+            ? { readCurrentAttachPinSession: true }
+            : { forceWalletSelection: true }),
+          deriveCardano: this.payload.deriveCardano,
+        })
+      : await getPassphraseStateWithRefreshDeviceInfo(this.device, { initSession: true });
+    const refreshedState = isProtocolV2
+      ? requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState())
+      : state;
+    const deviceId = requireDeviceId();
+    if (isProtocolV2 && refreshedState.status.passphraseProtection !== true) {
+      this.device.clearInternalState();
+      throw ERRORS.TypedError(HardwareErrorCode.DeviceNotOpenedPassphrase);
+    }
+    if (
+      isProtocolV2 &&
+      readCurrentAttachPinSession &&
+      refreshedState.status.unlockedAttachPin !== true
+    ) {
+      this.device.clearInternalState();
+      throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckUnlockTypeError);
+    }
+    const responseBase = {
+      protocol,
+      deviceId,
+      resumed: wasResumed(session),
+    } as const;
+    return !isProtocolV2 && this.device.getCurrentPassphraseProtection() === false
+      ? {
+          ...responseBase,
+          walletType: 'standard',
+          passphraseState: null,
+        }
+      : {
+          ...responseBase,
+          walletType: 'hidden',
+          ...requireHiddenWalletResponse(session),
+        };
+  }
+}

package/src/api/PathInfo.ts

@@ -1,7 +1,7 @@
 import { BaseMethod } from './BaseMethod';
 import {
-  validateNonEmptyString,
   validateOptionalNonNegativeInteger,
+  validateProtocolV2FilesystemPath,
 } from './helpers/filesystemValidation';
 
 export type PathInfoParams = {
@@ -10,13 +10,18 @@ export type PathInfoParams = {
 };
 
 export default class PathInfo extends BaseMethod<PathInfoParams> {
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
   init() {
-    // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
-    this.requireProtocolV2 = true;
+    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
     this.params = {
-      path: validateNonEmptyString(this.payload.path, 'path'),
+      path: validateProtocolV2FilesystemPath(this.payload.path, 'path', {
+        allowVolumeRoot: true,
+      }),
       timeoutMs: validateOptionalNonNegativeInteger(this.payload.timeoutMs, 'timeoutMs'),
     };
   }

package/src/api/PromptWebDeviceAccess.ts

@@ -52,14 +52,9 @@ export default class PromptWebDeviceAccess extends BaseMethod {
 
         if (isWebUsbEnv) {
           const usbDevice = device as USBDevice;
-          let path = usbDevice.serialNumber ?? '';
+          const path = usbDevice.serialNumber;
           if (!path) {
-            // 早期 Pro2 工程板 USB descriptor 没有 serial number。
-            // 授权后重新枚举，transport 会为空 serial 设备生成会话内稳定的 mock path，
-            // 这里按 USBDevice 对象身份找回该 path，保证后续 acquire 能匹配。
-            const diff = await this.connector?.enumerate();
-            const matched = diff?.descriptors?.find(d => (d as any).device === usbDevice);
-            path = matched?.path ?? '';
+            throw ERRORS.TypedError(HardwareErrorCode.WebDevicePromptAccessError);
           }
           devicesDescriptor = [
             {

package/src/api/SearchDevices.ts

@@ -1,11 +1,13 @@
 import { BaseMethod } from './BaseMethod';
 import TransportManager from '../data-manager/TransportManager';
 import { DataManager } from '../data-manager';
-import { getDeviceTypeByBleName } from '../utils';
+import { LoggerNames, getDeviceTypeByBleName, getLogger } from '../utils';
 import { DevicePool } from '../device/DevicePool';
 
 import type DeviceConnector from '../device/DeviceConnector';
 
+const Log = getLogger(LoggerNames.DevicePool);
+
 export default class SearchDevices extends BaseMethod {
   connector?: DeviceConnector;
 
@@ -39,6 +41,10 @@ export default class SearchDevices extends BaseMethod {
           devices.push({
             ...device,
             connectId: device.id,
+            serialNo: null,
+            // Legacy BLE discovery identifier. The physical serial number is unavailable here.
+            uuid: device.id,
+            deviceId: null,
             name: bleName || device.name,
             deviceType: getDeviceTypeByBleName(bleName),
           });
@@ -47,9 +53,30 @@ export default class SearchDevices extends BaseMethod {
       return devices;
     }
 
-    const { deviceList } = await DevicePool.getDevices(devicesDescriptor, undefined, {
-      connectProtocol: this.payload.connectProtocol,
-    });
+    const deviceList = [];
+    for (const descriptor of devicesDescriptor) {
+      try {
+        // Discovery is best effort. Browsers may retain WebUSB grants for devices that
+        // are offline, busy, or not ready, so one descriptor must not abort the scan.
+        const result = await DevicePool.getDevices([descriptor], descriptor.path, {
+          // Discovery must actively identify the protocol instead of trusting a caller hint.
+          connectProtocol: undefined,
+          forceProtocolDetection: true,
+          refreshRuntimeState: true,
+        });
+        deviceList.push(...result.deviceList);
+      } catch (error) {
+        const errorCode =
+          error && typeof error === 'object' && 'errorCode' in error
+            ? (error as { errorCode?: unknown }).errorCode
+            : undefined;
+        Log.debug('Skip unavailable device during search', {
+          path: descriptor.path,
+          ...(errorCode !== undefined ? { errorCode } : {}),
+        });
+      }
+    }
+
     return deviceList.map(device => device.toMessageObject());
   }
 }