@onekeyfe/hd-core 1.2.0-alpha.169 → 1.2.0-alpha.170

package/src/api/FirmwareUpdateV4.ts

@@ -375,18 +375,6 @@ const isProtocolV2TargetStatusInProgress = (
   normalizeProtocolV2TargetStatus(status) === PROTOCOL_V2_TARGET_STATUS_PENDING ||
   normalizeProtocolV2TargetStatus(status) === PROTOCOL_V2_TARGET_STATUS_IN_PROGRESS;
 
-const getProtocolV2FirmwareStatusFingerprint = (
-  statusTargets: ProtocolV2FirmwareUpdateStatusTarget[]
-) =>
-  JSON.stringify(
-    statusTargets.map(target => ({
-      targetId: normalizeProtocolV2TargetId(target.target_id) ?? target.target_id,
-      status: normalizeProtocolV2TargetStatus(target.status) ?? target.status ?? null,
-      payloadVersion: target.payload_version ?? null,
-      path: target.path ?? null,
-    }))
-  );
-
 const isProtocolV2TargetStatusFailed = (status: ProtocolV2FirmwareUpdateStatusTarget['status']) => {
   const normalizedStatus = normalizeProtocolV2TargetStatus(status);
   return (
@@ -542,10 +530,10 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
   private protocolV2InstallBaselineVersions = new Map<number, string>();
 
-  private protocolV2InstallStatusBaseline?: ProtocolV2FirmwareUpdateStatusTarget[];
-
   private protocolV2InstallNeedsBleReconnect = false;
 
+  private protocolV2InstallRequestConfirmed = false;
+
   private protocolV2LastRuntimeProbeFeatures?: Features;
 
   private protocolV2LastTransferProgress?: number;
@@ -2228,19 +2216,41 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     }
   }
 
+  private collectProtocolV2LiveTargetIds(
+    statusTargets: ProtocolV2FirmwareUpdateStatusTarget[],
+    expectedTargetIds: Set<number>,
+    liveTargetIds: Set<number>
+  ) {
+    statusTargets.forEach(target => {
+      const targetId = normalizeProtocolV2TargetId(target.target_id);
+      if (
+        targetId !== undefined &&
+        expectedTargetIds.has(targetId) &&
+        isProtocolV2TargetStatusInProgress(target.status)
+      ) {
+        liveTargetIds.add(targetId);
+      }
+    });
+  }
+
   private assertProtocolV2TargetStatus(
     statusTargets: ProtocolV2FirmwareUpdateStatusTarget[],
     expectedTargetIds: Set<number>,
-    expectedPaths = new Map<number, string>()
+    expectedPaths?: Map<number, string>,
+    liveTargetIds?: Set<number>
   ) {
+    const resolvedExpectedPaths = expectedPaths ?? new Map<number, string>();
     Log.log(
       `[FirmwareUpdateV4] DeviceFirmwareUpdateStatus records=${JSON.stringify(statusTargets)}`
     );
-    const failedTarget = statusTargets.find(
-      target =>
-        expectedTargetIds.has(normalizeProtocolV2TargetId(target.target_id) ?? -1) &&
-        isProtocolV2TargetStatusFailed(target.status)
-    );
+    const failedTarget = statusTargets.find(target => {
+      const targetId = normalizeProtocolV2TargetId(target.target_id) ?? -1;
+      return (
+        expectedTargetIds.has(targetId) &&
+        isProtocolV2TargetStatusFailed(target.status) &&
+        (!liveTargetIds || liveTargetIds.has(targetId))
+      );
+    });
     if (failedTarget) {
       const failedTargetDetails = JSON.stringify({
         targetId: failedTarget.target_id,
@@ -2257,6 +2267,27 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         }
       );
     }
+    if (liveTargetIds) {
+      const staleFailedTargets = statusTargets.filter(target => {
+        const targetId = normalizeProtocolV2TargetId(target.target_id) ?? -1;
+        return (
+          expectedTargetIds.has(targetId) &&
+          isProtocolV2TargetStatusFailed(target.status) &&
+          !liveTargetIds.has(targetId)
+        );
+      });
+      if (staleFailedTargets.length > 0) {
+        Log.log(
+          `[FirmwareUpdateV4] ignoring stale failed firmware status until those targets start: ${JSON.stringify(
+            staleFailedTargets.map(target => ({
+              targetId: target.target_id,
+              status: target.status,
+              path: target.path,
+            }))
+          )}`
+        );
+      }
+    }
 
     const matchingTargets = statusTargets.filter(target =>
       expectedTargetIds.has(normalizeProtocolV2TargetId(target.target_id) ?? -1)
@@ -2264,10 +2295,15 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     const seenTargetIds = new Set<number>();
     for (const target of matchingTargets) {
       const targetId = normalizeProtocolV2TargetId(target.target_id);
+      const pathConflictsWithCurrentInstall =
+        Boolean(target.path) &&
+        Boolean(resolvedExpectedPaths.get(targetId)) &&
+        target.path !== resolvedExpectedPaths.get(targetId) &&
+        (!liveTargetIds || liveTargetIds.has(targetId));
       if (
         targetId === undefined ||
         seenTargetIds.has(targetId) ||
-        (target.path && expectedPaths.get(targetId) && target.path !== expectedPaths.get(targetId))
+        pathConflictsWithCurrentInstall
       ) {
         Log.error(`[FirmwareUpdateV4] install status conflicts with target=${target.target_id}`);
         throw ERRORS.TypedError(
@@ -2399,12 +2435,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   ) {
     const expectedTargetIds = new Set(targets.map(target => target.target_id));
     const expectedPaths = new Map(targets.map(target => [target.target_id, target.path]));
-    const confirmationStartedAt = Date.now();
-    let installStartedAt = requireCurrentInstallStatus ? undefined : confirmationStartedAt;
-    const effectiveBaselineStatusTargets = this.protocolV2InstallStatusBaseline;
-    const baselineStatusFingerprint = effectiveBaselineStatusTargets
-      ? getProtocolV2FirmwareStatusFingerprint(effectiveBaselineStatusTargets)
-      : undefined;
+    const startTime = Date.now();
     let lastError: unknown;
     // USB may keep the loader link usable. BLE can release it as installation starts, so its
     // recovery reconnects directly to status polling without generic Ping or DeviceInfo probes.
@@ -2412,17 +2443,18 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     this.protocolV2InstallNeedsBleReconnect = false;
     let deviceInfo: ProtocolV2DeviceInfo | undefined;
     let bleInstallLinkReady = false;
-    let installEvidenceObserved = false;
+    let installEvidenceObserved = this.protocolV2InstallRequestConfirmed;
     let currentInstallStatusObserved = false;
+    const liveTargetIds = new Set<number>();
 
-    while (Date.now() - (installStartedAt ?? confirmationStartedAt) < PROTOCOL_V2_INSTALL_TIMEOUT) {
+    while (Date.now() - startTime < PROTOCOL_V2_INSTALL_TIMEOUT) {
       // A transport release caused by an explicit workflow cancellation must not
       // be mistaken for the expected device reboot during installation.
       this.throwIfAborted();
       try {
         if (shouldReconnect) {
           const isBleInstallReconnect = this.isBleReconnect();
-          await this.reconnectProtocolV2Device({ skipBleProtocolProbe: isBleInstallReconnect });
+          await this.reconnectProtocolV2Device({ skipProtocolProbe: true });
           bleInstallLinkReady = isBleInstallReconnect;
           deviceInfo = isBleInstallReconnect
             ? undefined
@@ -2453,33 +2485,9 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
             statusResponse.type === 'DeviceFirmwareUpdateStatus'
               ? ((statusResponse.message.records ?? []) as ProtocolV2FirmwareUpdateStatusTarget[])
               : [];
-          const hasPendingOrInProgressTarget = statusTargets.some(target => {
-            const targetId = normalizeProtocolV2TargetId(target.target_id);
-            return (
-              targetId !== undefined &&
-              expectedTargetIds.has(targetId) &&
-              isProtocolV2TargetStatusInProgress(target.status)
-            );
-          });
-          const isExpectedStatusSnapshot =
-            statusTargets.length === targets.length &&
-            targets.every((expectedTarget, index) => {
-              const statusTarget = statusTargets[index];
-              return (
-                statusTarget !== undefined &&
-                normalizeProtocolV2TargetId(statusTarget.target_id) === expectedTarget.target_id &&
-                statusTarget.path === expectedTarget.path
-              );
-            });
-          const statusFingerprint = getProtocolV2FirmwareStatusFingerprint(statusTargets);
-          const hasCurrentInstallTransition =
-            baselineStatusFingerprint !== undefined
-              ? isExpectedStatusSnapshot && statusFingerprint !== baselineStatusFingerprint
-              : hasPendingOrInProgressTarget;
-          if (!currentInstallStatusObserved && hasCurrentInstallTransition) {
+          this.collectProtocolV2LiveTargetIds(statusTargets, expectedTargetIds, liveTargetIds);
+          if (liveTargetIds.size > 0) {
             currentInstallStatusObserved = true;
-            installStartedAt = Date.now();
-            Log.log('[FirmwareUpdateV4] current firmware install records observed');
           }
           const hasMatchingTargetStatus = statusTargets.some(target => {
             const targetId = normalizeProtocolV2TargetId(target.target_id);
@@ -2499,7 +2507,12 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
             !requireCurrentInstallStatus || currentInstallStatusObserved;
           if (
             shouldVerifyTargetCompletion &&
-            this.assertProtocolV2TargetStatus(statusTargets, expectedTargetIds, expectedPaths)
+            this.assertProtocolV2TargetStatus(
+              statusTargets,
+              expectedTargetIds,
+              expectedPaths,
+              requireCurrentInstallStatus ? liveTargetIds : undefined
+            )
           ) {
             return;
           }
@@ -2760,19 +2773,53 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     );
   }
 
-  private async reconnectProtocolV2Device(options?: { skipBleProtocolProbe?: boolean }) {
+  private async reconnectProtocolV2Device(options?: { skipProtocolProbe?: boolean }) {
     if (this.isBleReconnect()) {
-      await this.acquireProtocolV2BleDevice(options?.skipBleProtocolProbe);
+      await this.acquireProtocolV2BleDevice(options?.skipProtocolProbe);
       return;
     }
 
     const deviceDiff = await this.device.deviceConnector?.enumerate();
     const devicesDescriptor = deviceDiff?.descriptors ?? [];
+    const env = DataManager.getSettings('env');
+    const isWebUsb = DataManager.isBrowserWebUsb(env) || DataManager.isDesktopWebUsb(env);
+
+    if (isWebUsb && options?.skipProtocolProbe) {
+      const expectedSerialNumber = this.protocolV2ExpectedSerialNumber?.trim();
+      const expectedPath = this.protocolV2ExpectedPath?.trim();
+      const reconnectDescriptor = devicesDescriptor.find(descriptor => {
+        const descriptorPath = descriptor.path?.trim();
+        return (
+          (!!expectedSerialNumber && descriptorPath === expectedSerialNumber) ||
+          (!!expectedPath && descriptorPath === expectedPath)
+        );
+      });
+      if (!reconnectDescriptor?.path) {
+        throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound);
+      }
+      this.device.updateDescriptor(
+        {
+          ...reconnectDescriptor,
+          protocolType: PROTOCOL_V2_CONNECT_PROTOCOL,
+        },
+        true
+      );
+      const mainId = await this.device.deviceConnector?.acquire(
+        reconnectDescriptor.path,
+        null,
+        undefined,
+        PROTOCOL_V2_CONNECT_PROTOCOL,
+        undefined,
+        undefined,
+        true
+      );
+      this.device.mainId = typeof mainId === 'string' ? mainId : reconnectDescriptor.path;
+      this.device.commands.disposed = false;
+      this.device.getCommands().mainId = this.device.mainId;
+      return;
+    }
 
-    if (
-      DataManager.isBrowserWebUsb(DataManager.getSettings('env')) &&
-      devicesDescriptor.length === 1
-    ) {
+    if (isWebUsb && devicesDescriptor.length === 1) {
       const descriptor = devicesDescriptor[0];
       if (!this.protocolV2ExpectedSerialNumber && descriptor.path !== this.protocolV2ExpectedPath) {
         throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound);
@@ -2923,31 +2970,10 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     targets: Array<{ target_id: number; path: string }>;
   }) {
     this.protocolV2LastRuntimeProbeFeatures = undefined;
-    this.protocolV2InstallStatusBaseline = undefined;
     this.protocolV2InstallNeedsBleReconnect = false;
+    this.protocolV2InstallRequestConfirmed = false;
     const commands = this.device.getCommands();
     await commands.typedCall('DeviceFirmwareUpdateStage', 'Success', { targets });
-    try {
-      const baselineStatusResponse = await commands.typedCall(
-        'DeviceFirmwareUpdateStatusGet',
-        ['DeviceFirmwareUpdateStatus', 'Success'],
-        {
-          fields: {
-            status: true,
-            payload_version: true,
-            path: true,
-          },
-        },
-        { timeoutMs: PROTOCOL_V2_FIRMWARE_STATUS_RESPONSE_TIMEOUT }
-      );
-      this.protocolV2InstallStatusBaseline =
-        baselineStatusResponse.type === 'DeviceFirmwareUpdateStatus'
-          ? ((baselineStatusResponse.message.records ??
-              []) as ProtocolV2FirmwareUpdateStatusTarget[])
-          : [];
-    } catch (error) {
-      Log.log('[FirmwareUpdateV4] unable to capture pre-install firmware status: ', error);
-    }
     this.device.setCancelableAction(() => commands.cancelDevice());
     const interaction = this.device.createProtocolV2UiPhaseMetadata('button', 'start');
     this.postMessage(
@@ -2962,7 +2988,10 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       })
     );
     try {
-      await commands.call('DeviceFirmwareUpdateRequest', {});
+      await commands.typedCall('DeviceFirmwareUpdateRequest', 'Success', {});
+      this.protocolV2InstallRequestConfirmed = true;
+      this.postProgressMessage(1, 'installingFirmware');
+      Log.log('[FirmwareUpdateV4] firmware install confirmed by device response');
     } catch (error) {
       this.throwIfAborted();
       if (!isProtocolV2DeviceDisconnectedError(error)) {

package/src/core/index.ts

@@ -1220,6 +1220,9 @@ export const cancel = (context: CoreContext, connectId?: string) => {
           ','
         )}`
       );
+      // Abort before rejecting: rejectRequest releases the task and would make
+      // its AbortController unreachable to an in-flight method loop.
+      requestQueue.abortRequestsByConnectId(connectId);
       const canceledDevices: Device[] = [];
       const interruptDevice = (device: Device | undefined, deviceConnectId: string) => {
         if (!device || canceledDevices.includes(device)) {
@@ -1244,7 +1247,6 @@ export const cancel = (context: CoreContext, connectId?: string) => {
         }
       }
       interruptDevice(deviceCacheMap.get(connectId), connectId);
-      requestQueue.abortRequestsByConnectId(connectId);
       pollingManager.stop(connectId);
     } catch (e) {
       Log.error('Cancel API Error: ', e);
@@ -1253,6 +1255,8 @@ export const cancel = (context: CoreContext, connectId?: string) => {
     const env = DataManager.getSettings('env');
     if (DataManager.isBleConnect(env)) {
       Log.debug('Cancel Api all _deviceList: ');
+      // Keep method abort signals observable until every active task is rejected.
+      requestQueue.abortAllRequests();
       const canceledDevices: Device[] = [];
       const interruptDevice = (device?: Device) => {
         if (!device || canceledDevices.includes(device)) {
@@ -1277,7 +1281,6 @@ export const cancel = (context: CoreContext, connectId?: string) => {
         }
       }
       deviceCacheMap.forEach(interruptDevice);
-      requestQueue.abortAllRequests();
       pollingManager.stopAll();
     } else {
       _deviceList?.allDevices().forEach(device => {

package/src/device/DeviceConnector.ts

@@ -105,9 +105,7 @@ export default class DeviceConnector {
       const transport = this.getActiveTransport();
       let res;
       if (DataManager.isBleConnect(env)) {
-        const acquireInput: Parameters<Transport['acquire']>[0] & {
-          skipProtocolProbe?: boolean;
-        } = {
+        const acquireInput: Parameters<Transport['acquire']>[0] = {
           uuid: path,
           forceCleanRunPromise,
           expectedProtocol,
@@ -123,6 +121,7 @@ export default class DeviceConnector {
           expectedProtocol,
           protocolHint,
           forceProtocolDetection,
+          skipProtocolProbe,
         });
       }
       if (expectedProtocol) {

package/src/protocols/protocol-v2/resources.ts

@@ -59,7 +59,15 @@ export function isProtocolV2ResourceArchiveEntryName(entryName: string): boolean
   return (
     fileName.length > 0 &&
     !fileName.startsWith('.') &&
-    !parts.some(part => part === '__MACOSX' || part === '.' || part === '..' || part === '')
+    !parts.some(
+      part =>
+        !part ||
+        part === '.' ||
+        part === '..' ||
+        part === '.DS_Store' ||
+        part.startsWith('._') ||
+        part.toUpperCase() === '__MACOSX'
+    )
   );
 }