@ukeyfe/hardware-core 1.1.25 → 1.1.27

package/src/api/CheckBridgeStatus.ts

@@ -1,5 +1,6 @@
 import axios from 'axios';
 import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+
 import { BaseMethod } from './BaseMethod';
 
 export default class CheckBridgeStatus extends BaseMethod {

package/src/api/CheckFirmwareRelease.ts

@@ -1,7 +1,9 @@
 import { BaseMethod } from './BaseMethod';
 import { UI_REQUEST } from '../constants/ui-request';
-
 import { getFirmwareReleaseInfo } from './firmware/releaseHelper';
+import { getFirmwareType } from '../utils';
+
+import type { CheckFirmwareReleaseParams } from '../types/api/checkFirmwareRelease';
 
 export default class CheckFirmwareRelease extends BaseMethod {
   init() {
@@ -15,8 +17,13 @@ export default class CheckFirmwareRelease extends BaseMethod {
   }
 
   run() {
+    const payload = this.payload as CheckFirmwareReleaseParams;
+
     if (this.device.features) {
-      const releaseInfo = getFirmwareReleaseInfo(this.device.features);
+      const deviceFirmwareType = getFirmwareType(this.device.features);
+      const firmwareType = payload.firmwareType ?? deviceFirmwareType;
+
+      const releaseInfo = getFirmwareReleaseInfo(this.device.features, firmwareType);
       return Promise.resolve(releaseInfo);
     }
     return Promise.resolve(null);

package/src/api/CheckFirmwareTypeAvailable.tsx

@@ -0,0 +1,30 @@
+import { EDeviceType } from '@ukeyfe/hardware-shared';
+
+import { BaseMethod } from './BaseMethod';
+import { getLatestFirmwareField } from '../utils/deviceFeaturesUtils';
+import { DataManager } from '../data-manager';
+import { findLatestRelease } from '../utils/release';
+
+import type { CheckFirmwareTypeAvailableParams } from '../types/api/checkFirmwareTypeAvailable';
+
+export default class CheckFirmwareTypeAvailable extends BaseMethod {
+  init() {
+    this.useDevice = false;
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+  }
+
+  run() {
+    const payload = this.payload as CheckFirmwareTypeAvailableParams;
+    const { deviceType, firmwareType } = payload;
+    if (deviceType === EDeviceType.Unknown) {
+      return Promise.resolve(undefined);
+    }
+
+    const latestFirmwareField = getLatestFirmwareField(firmwareType);
+
+    const releaseInfos = DataManager.deviceMap[deviceType]?.[latestFirmwareField] ?? [];
+    const releaseInfo = findLatestRelease(releaseInfos);
+    return Promise.resolve(releaseInfo);
+  }
+}

package/src/api/CipherKeyValue.ts

@@ -1,11 +1,12 @@
-import { CipherKeyValue as HardwareCipherKeyValue } from '@ukeyfe/hardware-transport';
 import { UI_REQUEST } from '../constants/ui-request';
 import { serializedPath, validatePath } from './helpers/pathUtils';
 import { BaseMethod } from './BaseMethod';
 import { validateParams } from './helpers/paramsValidator';
-import { CipheredKeyValue, CipheredKeyValueParams } from '../types';
 import { formatAnyHex } from './helpers/hexUtils';
 
+import type { CipheredKeyValue, CipheredKeyValueParams } from '../types';
+import type { CipherKeyValue as HardwareCipherKeyValue } from '@ukeyfe/hardware-transport';
+
 export default class CipherKeyValue extends BaseMethod<HardwareCipherKeyValue[]> {
   hasBundle = false;
 

package/src/api/FirmwareUpdate.ts

@@ -1,24 +1,25 @@
 import {
+  EFirmwareType,
   ERRORS,
-  HardwareErrorCode,
   HardwareError,
+  HardwareErrorCode,
   createDeferred,
-  Deferred,
 } from '@ukeyfe/hardware-shared';
+
 import { UI_REQUEST } from '../constants/ui-request';
 import { BaseMethod } from './BaseMethod';
 import { validateParams } from './helpers/paramsValidator';
 import { getBinary } from './firmware/getBinary';
 import { uploadFirmware } from './firmware/uploadFirmware';
 import { createUiMessage } from '../events';
-import { type KnownDevice, DeviceModelToTypes } from '../types';
-
+import { DeviceModelToTypes, type KnownDevice } from '../types';
 import { isEnteredManuallyBoot } from './firmware/bootloaderHelper';
-
 import { LoggerNames, getDeviceType, getDeviceUUID, getLogger, wait } from '../utils';
 import { DataManager } from '../data-manager';
 import { DevicePool } from '../device/DevicePool';
 
+import type { Deferred } from '@ukeyfe/hardware-shared';
+
 type Params = {
   binary?: ArrayBuffer;
   version?: number[];
@@ -189,6 +190,7 @@ export default class FirmwareUpdate extends BaseMethod<Params> {
           features: device.features,
           version: params.version,
           updateType: params.updateType,
+          firmwareType: EFirmwareType.Universal,
         });
         binary = firmware.binary;
         this.postTipMessage('DownloadFirmwareSuccess');
@@ -204,7 +206,8 @@ export default class FirmwareUpdate extends BaseMethod<Params> {
       this.device.getCommands().typedCall.bind(this.device.getCommands()),
       this.postMessage,
       device,
-      { payload: binary, rebootOnSuccess: this.payload.rebootOnSuccess }
+      { payload: binary, rebootOnSuccess: this.payload.rebootOnSuccess },
+      false
     );
 
     if (this.connectId) {

package/src/api/FirmwareUpdateV2.ts

@@ -1,12 +1,14 @@
 import {
-  createDeferred,
-  Deferred,
+  type Deferred,
   EDeviceType,
+  type EFirmwareType,
   ERRORS,
   HardwareError,
   HardwareErrorCode,
+  createDeferred,
 } from '@ukeyfe/hardware-shared';
 import semver from 'semver';
+
 import { UI_REQUEST } from '../constants/ui-request';
 import { BaseMethod } from './BaseMethod';
 import { validateParams } from './helpers/paramsValidator';
@@ -14,20 +16,21 @@ import { DevicePool } from '../device/DevicePool';
 import { getBinary, getInfo, getSysResourceBinary } from './firmware/getBinary';
 import { updateResources, uploadFirmware } from './firmware/uploadFirmware';
 import {
+  LoggerNames,
+  getDeviceFirmwareVersion,
   getDeviceType,
   getDeviceUUID,
-  wait,
+  getFirmwareType,
   getLogger,
-  LoggerNames,
-  getDeviceFirmwareVersion,
+  wait,
 } from '../utils';
-import { createUiMessage, FirmwareUpdateTipMessage } from '../events/ui-request';
+import { FirmwareUpdateTipMessage, createUiMessage } from '../events/ui-request';
 import { DeviceModelToTypes } from '../types';
 import { DataManager } from '../data-manager';
+import { DEVICE } from '../events';
 
-import type { KnownDevice, Features } from '../types';
+import type { Features, KnownDevice } from '../types';
 import type { Device } from '../device/Device';
-import { DEVICE } from '../events';
 
 type Params = {
   binary?: ArrayBuffer;
@@ -35,6 +38,7 @@ type Params = {
   updateType: 'firmware' | 'ble';
   forcedUpdateRes?: boolean;
   isUpdateBootloader?: boolean;
+  firmwareType?: EFirmwareType;
 };
 
 const Log = getLogger(LoggerNames.Method);
@@ -55,6 +59,7 @@ export default class FirmwareUpdateV2 extends BaseMethod<Params> {
       { name: 'binary', type: 'buffer' },
       { name: 'forcedUpdateRes', type: 'boolean' },
       { name: 'platform', type: 'string', required: true },
+      { name: 'firmwareType', type: 'string' },
     ]);
 
     if (!payload.updateType) {
@@ -74,6 +79,7 @@ export default class FirmwareUpdateV2 extends BaseMethod<Params> {
       this.params = {
         ...this.params,
         version: payload.version,
+        firmwareType: payload.firmwareType,
       };
     }
 
@@ -141,7 +147,11 @@ export default class FirmwareUpdateV2 extends BaseMethod<Params> {
           await wait(3000);
         }
 
-        if (checkCount > 4 && DataManager.isWebUsbConnect(DataManager.getSettings('env'))) {
+        if (
+          checkCount > 4 &&
+          DataManager.isBrowserWebUsb(DataManager.getSettings('env')) &&
+          !this.payload.skipWebDevicePrompt
+        ) {
           clearInterval(intervalTimer);
           clearTimeout(timeoutTimer);
 
@@ -242,14 +252,14 @@ export default class FirmwareUpdateV2 extends BaseMethod<Params> {
    * Check the version number of Touch to determine if it
    * needs to be upgraded via the desktop
    */
-  checkVersionForCopyTouchResource(features?: Features) {
+  checkVersionForCopyTouchResource(features: Features | undefined, firmwareType: EFirmwareType) {
     if (!features) return;
     const deviceType = getDeviceType(features);
     const currentVersion = getDeviceFirmwareVersion(features).join('.');
     const targetVersion = this.params.version?.join('.');
     const { updateType } = this.params;
 
-    const releaseInfo = getInfo({ features, updateType });
+    const releaseInfo = getInfo({ features, updateType, firmwareType });
     if (!releaseInfo) return;
     const { fullResourceRange } = releaseInfo;
     if (!fullResourceRange) return;
@@ -271,7 +281,10 @@ export default class FirmwareUpdateV2 extends BaseMethod<Params> {
     const { features, commands } = device;
     const deviceType = getDeviceType(features);
 
-    this.checkVersionForCopyTouchResource(features);
+    const deviceFirmwareType = getFirmwareType(device.features);
+    const firmwareType = params.firmwareType ?? deviceFirmwareType;
+
+    this.checkVersionForCopyTouchResource(features, firmwareType);
 
     if (!features?.bootloader_mode && features) {
       const uuid = getDeviceUUID(features);
@@ -283,10 +296,11 @@ export default class FirmwareUpdateV2 extends BaseMethod<Params> {
       // check & upgrade firmware resource
       if (features && this.isSupportResourceUpdate(features, params.updateType)) {
         this.postTipMessage('CheckLatestUiResource');
-        const resourceUrl = DataManager.getSysResourcesLatestRelease(
+        const resourceUrl = DataManager.getSysResourcesLatestRelease({
           features,
-          params.forcedUpdateRes
-        );
+          forcedUpdateRes: params.forcedUpdateRes,
+          firmwareType,
+        });
         if (resourceUrl) {
           this.postTipMessage('DownloadLatestUiResource');
           const resource = await getSysResourceBinary(resourceUrl);
@@ -356,11 +370,13 @@ export default class FirmwareUpdateV2 extends BaseMethod<Params> {
           );
         }
         this.postTipMessage('DownloadFirmware');
+
         const firmware = await getBinary({
           features: device.features,
           version: params.version,
           updateType: params.updateType,
           isUpdateBootloader: params.isUpdateBootloader,
+          firmwareType,
         });
         binary = firmware.binary;
         this.postTipMessage('DownloadFirmwareSuccess');
@@ -379,7 +395,8 @@ export default class FirmwareUpdateV2 extends BaseMethod<Params> {
       this.device.getCommands().typedCall.bind(this.device.getCommands()),
       this.postMessage,
       device,
-      { payload: binary, rebootOnSuccess: true }
+      { payload: binary, rebootOnSuccess: true },
+      params.isUpdateBootloader
     );
 
     if (this.connectId) {

package/src/api/FirmwareUpdateV3.ts

@@ -1,23 +1,27 @@
-import { Deferred, ERRORS, HardwareErrorCode, EDeviceType, wait } from '@ukeyfe/hardware-shared';
+import { EDeviceType, ERRORS, HardwareError, HardwareErrorCode, wait } from '@ukeyfe/hardware-shared';
 import semver from 'semver';
 import JSZip from 'jszip';
-import { UI_REQUEST, FirmwareUpdateTipMessage } from '../events/ui-request';
-import { validateParams } from './helpers/paramsValidator';
 
+import { FirmwareUpdateTipMessage, UI_REQUEST } from '../events/ui-request';
+import { validateParams } from './helpers/paramsValidator';
 import {
-  getDeviceType,
-  getDeviceBootloaderVersion,
+  LoggerNames,
   getDeviceBLEFirmwareVersion,
+  getDeviceBootloaderVersion,
   getDeviceFirmwareVersion,
-  LoggerNames,
+  getDeviceType,
+  getFirmwareType,
   getLogger,
 } from '../utils';
 import { getBinary, getSysResourceBinary } from './firmware/getBinary';
 import { DataManager } from '../data-manager';
-import { FirmwareUpdateV3Params } from '../types/api/firmwareUpdate';
 import { FirmwareUpdateBaseMethod } from './firmware/FirmwareUpdateBaseMethod';
 import { DevicePool } from '../device/DevicePool';
-import { TypedResponseMessage } from '../device/DeviceCommands';
+import { DEVICE } from '../events';
+
+import type { FirmwareUpdateV3Params } from '../types/api/firmwareUpdate';
+import type { Deferred, EFirmwareType } from '@ukeyfe/hardware-shared';
+import type { TypedResponseMessage } from '../device/DeviceCommands';
 
 const Log = getLogger(LoggerNames.Method);
 
@@ -37,6 +41,8 @@ export const MIN_UPDATE_V3_BOOTLOADER_VERSION = '2.8.0';
 export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareUpdateV3Params> {
   checkPromise: Deferred<any> | null = null;
 
+  private isSwitchFirmware = false;
+
   init() {
     this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.NOT_INITIALIZE];
     this.requireDeviceMode = [];
@@ -54,6 +60,7 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
       { name: 'forcedUpdateRes', type: 'boolean' },
       { name: 'bootloaderVersion', type: 'array' },
       { name: 'bootloaderBinary', type: 'buffer' },
+      { name: 'firmwareType', type: 'string' },
       { name: 'platform', type: 'string' },
     ]);
 
@@ -66,6 +73,7 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
       bootloaderBinary: payload.bootloaderBinary,
       firmwareVersion: payload.firmwareVersion,
       resourceBinary: payload.resourceBinary,
+      firmwareType: payload.firmwareType,
       platform: payload.platform,
     };
   }
@@ -83,14 +91,18 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
       throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Device features not available');
     }
 
+    const deviceFirmwareType = getFirmwareType(features);
+    const firmwareType = this.params.firmwareType ?? deviceFirmwareType;
+    this.isSwitchFirmware = firmwareType !== deviceFirmwareType;
+
     let resourceBinary: ArrayBuffer | null = null;
     let fwBinaryMap: { fileName: string; binary: ArrayBuffer }[] = [];
     let bootloaderBinary: ArrayBuffer | null = null;
     try {
       this.postTipMessage(FirmwareUpdateTipMessage.StartDownloadFirmware);
-      resourceBinary = await this.prepareResourceBinary();
-      fwBinaryMap = await this.prepareFirmwareAndBleBinary();
-      bootloaderBinary = await this.prepareBootloaderBinary();
+      resourceBinary = await this.prepareResourceBinary(firmwareType);
+      fwBinaryMap = await this.prepareFirmwareAndBleBinary(firmwareType);
+      bootloaderBinary = await this.prepareBootloaderBinary(firmwareType);
       this.postTipMessage(FirmwareUpdateTipMessage.FinishDownloadFirmware);
     } catch (err) {
       throw ERRORS.TypedError(HardwareErrorCode.FirmwareUpdateDownloadFailed, err.message ?? err);
@@ -130,16 +142,17 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
     }
   }
 
-  private async prepareResourceBinary() {
+  private async prepareResourceBinary(firmwareType: EFirmwareType) {
     if (this.params.resourceBinary) {
       return this.params.resourceBinary;
     }
     const { features } = this.device;
     if (!features) return null;
-    const resourceUrl = DataManager.getSysResourcesLatestRelease(
+    const resourceUrl = DataManager.getSysResourcesLatestRelease({
       features,
-      this.params.forcedUpdateRes
-    );
+      forcedUpdateRes: this.params.forcedUpdateRes,
+      firmwareType,
+    });
 
     if (resourceUrl) {
       const resource = (await getSysResourceBinary(resourceUrl)).binary;
@@ -149,7 +162,7 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
     return null;
   }
 
-  private async prepareBootloaderBinary(): Promise<ArrayBuffer | null> {
+  private async prepareBootloaderBinary(firmwareType: EFirmwareType): Promise<ArrayBuffer | null> {
     if (this.params.bootloaderBinary) {
       return this.params.bootloaderBinary;
     }
@@ -157,7 +170,7 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
     if (!features) return null;
 
     if (this.params.bootloaderVersion) {
-      const bootResourceUrl = DataManager.getBootloaderResource(features);
+      const bootResourceUrl = DataManager.getBootloaderResource(features, firmwareType);
       if (bootResourceUrl) {
         const bootBinary = (await getSysResourceBinary(bootResourceUrl)).binary;
         return bootBinary;
@@ -166,7 +179,7 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
     return null;
   }
 
-  private async prepareFirmwareAndBleBinary() {
+  private async prepareFirmwareAndBleBinary(firmwareType: EFirmwareType) {
     const fwBinaryMap: { fileName: string; binary: ArrayBuffer }[] = [];
     if (this.params.firmwareBinary) {
       fwBinaryMap.push({
@@ -182,6 +195,7 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
             version: this.params.firmwareVersion,
             updateType: 'firmware',
             isUpdateBootloader: false,
+            firmwareType,
           })
         ).binary;
         fwBinaryMap.push({
@@ -203,6 +217,7 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
           features,
           version: this.params.bleVersion,
           updateType: 'ble',
+          firmwareType,
         });
         fwBinaryMap.push({
           fileName: 'ble-firmware.bin',
@@ -236,7 +251,7 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
     }
 
     this.postTipMessage(FirmwareUpdateTipMessage.StartTransferData);
-    // 处理资源文件
+    // Process resource zip contents
     if (resourceBinary) {
       const file = await JSZip.loadAsync(resourceBinary);
       const files = Object.entries(file.files);
@@ -288,6 +303,7 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
       if (error?.errorCode) {
         const unexpectedError = [
           HardwareErrorCode.ActionCancelled,
+          HardwareErrorCode.CallQueueActionCancelled,
           HardwareErrorCode.FirmwareVerificationFailed,
           // BLE connection errors
           HardwareErrorCode.BleDeviceNotBonded,
@@ -324,6 +340,9 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
     const installStartTime = Date.now();
     const maxWaitTimeForInstallingFirmware = 5 * 60 * 1000; // 5 minutes in milliseconds
 
+    let getFeaturesTimeoutCount = 0;
+    const maxGetFeaturesTimeoutBeforeReauth = 3;
+
     // eslint-disable-next-line no-constant-condition
     while (true) {
       // Check if timeout exceeded
@@ -336,31 +355,61 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
 
       try {
         const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+        const timeoutMs = 3000;
         const featuresRes = await Promise.race<TypedResponseMessage<'Features'>>([
           typedCall('GetFeatures', 'Features', {}),
           new Promise<never>((_, reject) => {
-            setTimeout(() => reject(new Error('GetFeatures timeout after 3 seconds')), 3000);
+            setTimeout(
+              () =>
+                reject(
+                  ERRORS.TypedError(
+                    HardwareErrorCode.CallMethodNotResponse,
+                    'GetFeatures timeout',
+                    { method: 'GetFeatures', timeoutMs }
+                  )
+                ),
+              timeoutMs
+            );
           }),
         ]);
+        getFeaturesTimeoutCount = 0;
         const features = featuresRes.message;
         const bootloaderVersion = getDeviceBootloaderVersion(features).join('.');
         const bleVersion = getDeviceBLEFirmwareVersion(features).join('.');
         const firmwareVersion = getDeviceFirmwareVersion(features).join('.');
-        this.postTipMessage(FirmwareUpdateTipMessage.FirmwareUpdateCompleted);
-        DevicePool.resetState();
-        return {
-          bootloaderVersion,
-          bleVersion,
-          firmwareVersion,
-        };
+        // Treat update as complete once firmware version becomes non-zero
+        if (firmwareVersion !== '0.0.0') {
+          this.postTipMessage(FirmwareUpdateTipMessage.FirmwareUpdateCompleted);
+          DevicePool.resetState();
+          return {
+            bootloaderVersion,
+            bleVersion,
+            firmwareVersion,
+          };
+        }
+        // Still in update mode; continue polling (e.g., iOS may return firmwareVersion 0.0.0 during switches)
+        await wait(1000);
       } catch (error) {
-        if (error.message && error.message.includes('Update mode')) {
-          const updateParts = error.message.split('Update mode ');
-          const progressValue = updateParts[1] ?? '0';
-          const progress = parseInt(progressValue, 10) || 0;
+        Log.log('getFeatures error', error);
+        let shouldReconnect = true;
+        const progress = this.extractUpdateModeProgress(error);
+        if (progress !== null) {
+          getFeaturesTimeoutCount = 0;
           this.postProgressMessage(progress, 'installingFirmware');
           await wait(1000);
+          shouldReconnect = false;
+        } else if (this.isGetFeaturesTimeoutError(error)) {
+          getFeaturesTimeoutCount += 1;
+          // Retry transient GetFeatures timeouts to avoid unnecessary WebUSB re-authorization prompts.
+          if (getFeaturesTimeoutCount <= maxGetFeaturesTimeoutBeforeReauth) {
+            await wait(1000);
+            shouldReconnect = false;
+          }
         } else {
+          getFeaturesTimeoutCount = 0;
+        }
+
+        if (shouldReconnect) {
           await wait(1000);
           /**
            * Needs second reconnect case:
@@ -372,12 +421,67 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
               ? 3 * 60 * 1000 // 3 minutes for BLE reconnect
               : 60 * 1000; // 1 minute for normal reconnect
 
+          getFeaturesTimeoutCount = 0;
           await this.waitForDeviceReconnect(reconnectTimeout);
         }
       }
     }
   }
 
+  /**
+   * Parse “Update mode XX” progress value from device errors to avoid hardcoded message.includes.
+   */
+  private extractUpdateModeProgress(error: unknown): number | null {
+    const message = this.normalizeErrorMessage(error);
+    if (!message) {
+      return null;
+    }
+    const match = message.match(/Update mode\s*(\d+)/i);
+    if (!match) {
+      return null;
+    }
+    const progress = parseInt(match[1], 10);
+    return Number.isNaN(progress) ? null : progress;
+  }
+
+  private isGetFeaturesTimeoutError(error: unknown): boolean {
+    return (
+      error instanceof HardwareError &&
+      error.errorCode === HardwareErrorCode.CallMethodNotResponse &&
+      error.params?.method === 'GetFeatures'
+    );
+  }
+
+  private normalizeErrorMessage(error: unknown): string {
+    if (!error) {
+      return '';
+    }
+    if (typeof error === 'string') {
+      return error;
+    }
+    if (typeof error === 'object') {
+      const { message } = error as { message?: unknown };
+      if (typeof message === 'string') {
+        return message;
+      }
+      if (message !== undefined && message !== null) {
+        return String(message);
+      }
+    }
+    return '';
+  }
+
+  private canPromptWebUsbSwitchFirmwareReconnect(): boolean {
+    if (!this.isSwitchFirmware) {
+      return false;
+    }
+    return (
+      DataManager.isBrowserWebUsb(DataManager.getSettings('env')) &&
+      !this.payload.skipWebDevicePrompt &&
+      this.device.listenerCount(DEVICE.SELECT_DEVICE_FOR_SWITCH_FIRMWARE_WEB_DEVICE) > 0
+    );
+  }
+
   /**
    * @description Reconnect device - While update with bootloader, it will reconnect device
    * @param {number} timeout - The timeout for the reconnection
@@ -385,6 +489,7 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
   async waitForDeviceReconnect(timeout: number) {
     const startTime = Date.now();
     const isBleReconnect = this.isBleReconnect();
+    let webUsbCheckCount = 0;
     while (Date.now() - startTime < timeout) {
       try {
         if (isBleReconnect) {
@@ -411,6 +516,24 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
         } else {
           const deviceDiff = await this.device.deviceConnector?.enumerate();
           const devicesDescriptor = deviceDiff?.descriptors ?? [];
+
+          const canPromptSwitchFirmwareReconnect = this.canPromptWebUsbSwitchFirmwareReconnect();
+
+          if (canPromptSwitchFirmwareReconnect) {
+            webUsbCheckCount += 1;
+            if (webUsbCheckCount > 4) {
+              this.postTipMessage(FirmwareUpdateTipMessage.SwitchFirmwareReconnectDevice);
+              try {
+                await this._promptDeviceForSwitchFirmwareWebDevice();
+              } catch (e) {
+                Log.log('WebUSB re-authorization failed: ', e);
+              }
+              webUsbCheckCount = 0;
+            }
+          } else {
+            webUsbCheckCount = 0;
+          }
+
           const { deviceList } = await DevicePool.getDevices(devicesDescriptor, this.connectId);
 
           if (deviceList.length === 1) {

package/src/api/GetFeatures.ts

@@ -1,4 +1,5 @@
 import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+
 import { UI_REQUEST } from '../constants/ui-request';
 import { BaseMethod } from './BaseMethod';
 

package/src/api/GetPassphraseState.ts

@@ -1,4 +1,5 @@
 import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+
 import { UI_REQUEST } from '../constants/ui-request';
 import { getPassphraseStateWithRefreshDeviceInfo } from '../utils/deviceFeaturesUtils';
 import { BaseMethod } from './BaseMethod';

package/src/api/GetUkeyFeatures.ts

@@ -1,4 +1,5 @@
 import semver from 'semver';
+
 import { UI_REQUEST } from '../constants/ui-request';
 import { fixVersion } from '../utils/deviceFeaturesUtils';
 import { BaseMethod } from './BaseMethod';

package/src/api/PromptWebDeviceAccess.ts

@@ -1,10 +1,12 @@
 import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
-import { UKeyDeviceInfo } from '@ukeyfe/hardware-transport';
+
 import { BaseMethod } from './BaseMethod';
 import TransportManager from '../data-manager/TransportManager';
 import { DataManager } from '../data-manager';
 import { DevicePool } from '../device/DevicePool';
-import { getLogger, LoggerNames } from '../utils';
+import { LoggerNames, getLogger } from '../utils';
+
+import type { UKeyDeviceInfo } from '@ukeyfe/hardware-transport';
 
 const Log = getLogger(LoggerNames.Method);
 

package/src/api/SearchDevices.ts

@@ -1,10 +1,11 @@
 import { BaseMethod } from './BaseMethod';
-import DeviceConnector from '../device/DeviceConnector';
 import TransportManager from '../data-manager/TransportManager';
 import { DataManager } from '../data-manager';
 import { getDeviceTypeByBleName } from '../utils';
 import { DevicePool } from '../device/DevicePool';
 
+import type DeviceConnector from '../device/DeviceConnector';
+
 export default class SearchDevices extends BaseMethod {
   connector?: DeviceConnector;