@ukeyfe/hardware-core 1.1.24 → 1.1.26

package/src/constants/errors.ts

@@ -1,4 +1,4 @@
-import { HardwareError, ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+import { ERRORS, HardwareError, HardwareErrorCode } from '@ukeyfe/hardware-shared';
 
 export const safeThrowError = (error: any) => {
   if (error instanceof HardwareError) {

package/src/core/RequestQueue.ts

@@ -1,6 +1,7 @@
-import { Deferred } from '@ukeyfe/hardware-shared';
+import { LoggerNames, getLogger } from '../utils';
+
+import type { Deferred } from '@ukeyfe/hardware-shared';
 import type { BaseMethod } from '../api/BaseMethod';
-import { getLogger, LoggerNames } from '../utils';
 
 const Log = getLogger(LoggerNames.Core);
 export type RequestTask = {

package/src/core/index.ts

@@ -1,61 +1,77 @@
 import semver from 'semver';
 import EventEmitter from 'events';
-import { Features, LowlevelTransportSharedPlugin, UKeyDeviceInfo } from '@ukeyfe/hardware-transport';
 import {
-  createDeferred,
-  Deferred,
   ERRORS,
+  ERROR_CODES_REQUIRE_RELEASE,
   HardwareError,
   HardwareErrorCode,
+  createDefectiveFirmwareError,
+  createDeferred,
   createDeprecatedHardwareError,
+  createDeviceNotSupportMethodError,
   createNeedUpgradeFirmwareHardwareError,
   createNewFirmwareForceUpdateHardwareError,
   createNewFirmwareUnReleaseHardwareError,
-  createDefectiveFirmwareError,
 } from '@ukeyfe/hardware-shared';
+
 import {
-  getDeviceFirmwareVersion,
-  getDeviceBLEFirmwareVersion,
+  LoggerNames,
   enableLog,
+  getDeviceBLEFirmwareVersion,
+  getDeviceFirmwareVersion,
+  getFirmwareType,
   getLogger,
-  LoggerNames,
+  getMethodVersionRange,
   setLoggerPostMessage,
   wait,
-  getMethodVersionRange,
 } from '../utils';
 import {
   findDefectiveBatchDevice,
   getDefectiveDeviceInfo,
 } from '../utils/findDefectiveBatchDevice';
 import { supportNewPassphrase } from '../utils/deviceFeaturesUtils';
-import { Device, DeviceEvents, InitOptions, RunOptions } from '../device/Device';
+import {
+  cleanupSdkInstance,
+  completeRequestContext,
+  createRequestContext,
+  createSdkTracingContext,
+  formatRequestContext,
+  getActiveRequestsByDeviceInstance,
+  updateRequestContext,
+} from '../utils/tracing';
+import { Device } from '../device/Device';
 import { DeviceList } from '../device/DeviceList';
 import { DevicePool } from '../device/DevicePool';
 import { findMethod } from '../api/utils';
 import { DataManager } from '../data-manager';
-
 import { UI_REQUEST as UI_REQUEST_CONST } from '../constants/ui-request';
 import {
   CORE_EVENT,
-  CoreMessage,
-  createDeviceMessage,
-  createResponseMessage,
-  createUiMessage,
   DEVICE,
   IFRAME,
-  IFrameCallMessage,
   UI_REQUEST,
   UI_RESPONSE,
-  UiPromise,
-  UiPromiseResponse,
+  createDeviceMessage,
+  createResponseMessage,
+  createUiMessage,
 } from '../events';
-import type { BaseMethod } from '../api/BaseMethod';
-import type { ConnectSettings, KnownDevice } from '../types';
 import TransportManager from '../data-manager/TransportManager';
 import DeviceConnector from '../device/DeviceConnector';
 import RequestQueue from './RequestQueue';
 import { getSynchronize } from '../utils/getSynchronize';
 
+import type { ConnectSettings, KnownDevice } from '../types';
+import type { CoreMessage, IFrameCallMessage, UiPromise, UiPromiseResponse } from '../events';
+import type { DeviceEvents, InitOptions, RunOptions } from '../device/Device';
+import type { SdkTracingContext } from '../utils/tracing';
+import type { Deferred } from '@ukeyfe/hardware-shared';
+import type {
+  Features,
+  LowlevelTransportSharedPlugin,
+  UKeyDeviceInfo,
+} from '@ukeyfe/hardware-transport';
+import type { BaseMethod } from '../api/BaseMethod';
+
 const Log = getLogger(LoggerNames.Core);
 
 export type CoreContext = ReturnType<Core['getCoreContext']>;
@@ -96,6 +112,30 @@ let preConnectCache: {
   passphraseState: undefined,
 };
 
+const toError = (error: unknown): Error | undefined => {
+  if (error instanceof Error) return error;
+  if (error == null) return undefined;
+  if (typeof error === 'string') return new Error(error);
+  try {
+    return new Error(JSON.stringify(error));
+  } catch {
+    return new Error(String(error));
+  }
+};
+
+const updateMethodRequestContext = (method: BaseMethod, updates: any) => {
+  if (method.requestContext) {
+    updateRequestContext(method.requestContext.responseID, updates);
+  }
+};
+
+const completeMethodRequestContext = (method: BaseMethod, error?: unknown) => {
+  if (!method.requestContext) {
+    return;
+  }
+  completeRequestContext(method.requestContext.responseID, toError(error));
+};
+
 export const callAPI = async (context: CoreContext, message: CoreMessage) => {
   if (!message.id || !message.payload || message.type !== IFRAME.CALL) {
     return Promise.reject(ERRORS.TypedError('on call: message.id or message.payload is missing'));
@@ -107,6 +147,15 @@ export const callAPI = async (context: CoreContext, message: CoreMessage) => {
     method = findMethod(message as IFrameCallMessage);
     method.connector = _connector;
     method.postMessage = postMessage;
+    method.setContext?.(context);
+
+    method.requestContext = createRequestContext(method.responseID, method.name, {
+      sdkInstanceId: context.sdkInstanceId,
+      connectId: method.connectId,
+    });
+
+    Log.debug(`[${context.sdkInstanceId}] callAPI: ${formatRequestContext(method.requestContext)}`);
+
     method.init();
   } catch (error) {
     return Promise.reject(error);
@@ -115,10 +164,13 @@ export const callAPI = async (context: CoreContext, message: CoreMessage) => {
   DevicePool.emitter.on(DEVICE.CONNECT, onDeviceConnectHandler);
 
   if (!method.useDevice) {
+    updateMethodRequestContext(method, { status: 'running' });
     try {
       const response = await method.run();
+      completeMethodRequestContext(method);
       return createResponseMessage(method.responseID, true, response);
     } catch (error) {
+      completeMethodRequestContext(method, error);
       return createResponseMessage(method.responseID, false, { error });
     }
   }
@@ -190,6 +242,8 @@ const onCallDevice = async (
 
   const { requestQueue, getPrePendingCallPromise, setPrePendingCallPromise } = context;
 
+  updateMethodRequestContext(method, { status: 'running' });
+
   const connectStateChange = preConnectCache.passphraseState !== method.payload.passphraseState;
 
   preConnectCache = {
@@ -224,6 +278,8 @@ const onCallDevice = async (
   } catch (e) {
     console.log('ensureConnected error: ', e);
 
+    completeMethodRequestContext(method, e);
+
     if (e.name === 'AbortError' || e.message === 'Request aborted') {
       requestQueue.releaseTask(method.responseID);
       return createResponseMessage(method.responseID, false, {
@@ -234,10 +290,28 @@ const onCallDevice = async (
     return createResponseMessage(method.responseID, false, { error: e });
   }
 
+  if (method.payload?.onlyConnectBleDevice) {
+    Log.debug('Call API - only connect ble device: ', device?.mainId);
+    return createResponseMessage(method.responseID, true, null);
+  }
+
   Log.debug('Call API - setDevice: ', device.mainId);
   method.setDevice?.(device);
   method.context = context;
 
+  updateMethodRequestContext(method, {
+    deviceInstanceId: device.instanceId,
+    commandsInstanceId: device.commands?.instanceId,
+  });
+
+  const activeRequests = getActiveRequestsByDeviceInstance(device.instanceId);
+  if (activeRequests.length > 0) {
+    Log.warn(
+      `[${method.instanceId}] Device ${device.instanceId} has ${activeRequests.length} active requests:`,
+      activeRequests.map(formatRequestContext)
+    );
+  }
+
   device.on(DEVICE.PIN, onDevicePinHandler);
   device.on(DEVICE.BUTTON, onDeviceButtonHandler);
   device.on(
@@ -250,6 +324,10 @@ const onCallDevice = async (
     DEVICE.SELECT_DEVICE_IN_BOOTLOADER_FOR_WEB_DEVICE,
     onSelectDeviceInBootloaderForWebDeviceHandler
   );
+  device.on(
+    DEVICE.SELECT_DEVICE_FOR_SWITCH_FIRMWARE_WEB_DEVICE,
+    onSelectDeviceForSwitchFirmwareWebDeviceHandler
+  );
 
   try {
     if (method.connectId) {
@@ -282,7 +360,8 @@ const onCallDevice = async (
           }
         }
 
-        const newVersionStatus = DataManager.getFirmwareStatus(device.features);
+        const deviceFirmwareType = getFirmwareType(device.features);
+        const newVersionStatus = DataManager.getFirmwareStatus(device.features, deviceFirmwareType);
         const bleVersionStatus = DataManager.getBLEFirmwareStatus(device.features);
 
         const currentFirmwareVersion = getDeviceFirmwareVersion(device.features).join('.');
@@ -319,19 +398,21 @@ const onCallDevice = async (
             semver.lt(currentFirmwareVersion, versionRange.min)
           ) {
             if (newVersionStatus === 'none' || newVersionStatus === 'valid') {
-              throw createNewFirmwareUnReleaseHardwareError(
-                currentFirmwareVersion,
-                versionRange.min,
-                method.name
-              );
+              throw createNewFirmwareUnReleaseHardwareError({
+                currentVersion: currentFirmwareVersion,
+                requireVersion: versionRange.min,
+                methodName: method.name,
+                firmwareType: getFirmwareType(device.features),
+              });
             }
 
             return Promise.reject(
-              createNeedUpgradeFirmwareHardwareError(
-                currentFirmwareVersion,
-                versionRange.min,
-                method.name
-              )
+              createNeedUpgradeFirmwareHardwareError({
+                currentVersion: currentFirmwareVersion,
+                requireVersion: versionRange.min,
+                methodName: method.name,
+                firmwareType: getFirmwareType(device.features),
+              })
             );
           }
           if (
@@ -344,10 +425,7 @@ const onCallDevice = async (
             );
           }
         } else if (method.strictCheckDeviceSupport) {
-          throw ERRORS.TypedError(
-            HardwareErrorCode.DeviceNotSupportMethod,
-            `Method '${method.name}' is not supported by this device`
-          );
+          throw createDeviceNotSupportMethodError(method.name, getFirmwareType(device.features));
         }
       }
 
@@ -450,10 +528,20 @@ const onCallDevice = async (
         Log.debug('Call API - Inner Method Run: ');
         messageResponse = createResponseMessage(method.responseID, true, response);
         requestQueue.resolveRequest(method.responseID, messageResponse);
+        completeMethodRequestContext(method);
       } catch (error) {
-        Log.debug('Call API - Inner Method Run Error: ', error);
+        Log.debug(`Call API - Inner Method Run Error`, error);
         messageResponse = createResponseMessage(method.responseID, false, { error });
         requestQueue.resolveRequest(method.responseID, messageResponse);
+        completeMethodRequestContext(method, error);
+
+        // Re-throw errors that need to trigger device release/disconnect in Device._runInner
+        if (
+          error instanceof HardwareError &&
+          ERROR_CODES_REQUIRE_RELEASE.includes(error.errorCode as any)
+        ) {
+          throw error;
+        }
       }
     };
     Log.debug('Call API - Device Run: ', device.mainId);
@@ -469,6 +557,7 @@ const onCallDevice = async (
       return await task.callPromise.promise;
     } catch (e) {
       Log.debug('Device Run Error: ', e);
+      completeMethodRequestContext(method, e);
       return createResponseMessage(method.responseID, false, { error: e });
     }
   } catch (error) {
@@ -478,6 +567,7 @@ const onCallDevice = async (
       ERRORS.TypedError(HardwareErrorCode.CallMethodError, error.message)
     );
     Log.debug('Call API - Run Error: ', error);
+    completeMethodRequestContext(method, error);
   } finally {
     const response = messageResponse;
 
@@ -505,7 +595,21 @@ const onCallDevice = async (
 
     cleanup();
 
-    removeDeviceListener(device);
+    if (device) {
+      const stillActive = getActiveRequestsByDeviceInstance(device.instanceId);
+      if (stillActive.length > 1) {
+        Log.warn(
+          `[${method.instanceId}] Removing listeners while ${stillActive.length} requests are active!`,
+          {
+            deviceInstanceId: device.instanceId,
+            activeRequests: stillActive.map(formatRequestContext),
+            pinListeners: device.listenerCount(DEVICE.PIN),
+          }
+        );
+      } else {
+        removeDeviceListener(device);
+      }
+    }
   }
 };
 
@@ -557,10 +661,8 @@ function initDevice(method: BaseMethod) {
 
   if (!device) {
     const env = DataManager.getSettings('env');
-    if (DataManager.isWebUsbConnect(env)) {
-      if (!method.payload.skipWebDevicePrompt) {
-        postMessage(createUiMessage(UI_REQUEST.WEB_DEVICE_PROMPT_ACCESS_PERMISSION));
-      }
+    // Browser WebUSB needs permission prompt, desktop WebUSB doesn't
+    if (DataManager.isBrowserWebUsb(env)) {
       throw ERRORS.TypedError(HardwareErrorCode.WebDeviceNotFoundOrNeedsPermission);
     }
     throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound);
@@ -585,7 +687,10 @@ function initDeviceForBle(method: BaseMethod) {
   if (deviceCacheMap.has(method.connectId)) {
     device = deviceCacheMap.get(method.connectId) as Device;
   } else {
-    device = Device.fromDescriptor({ id: method.connectId } as UKeyDeviceInfo);
+    device = Device.fromDescriptor(
+      { id: method.connectId } as UKeyDeviceInfo,
+      method.sdkInstanceId
+    );
     deviceCacheMap.set(method.connectId, device);
   }
   device.deviceConnector = _connector;
@@ -600,6 +705,9 @@ let bleTimeoutRetry = 0;
 async function connectDeviceForBle(method: BaseMethod, device: Device) {
   try {
     await device.acquire();
+    if (method.payload?.onlyConnectBleDevice) {
+      return;
+    }
     await device.initialize(parseInitOptions(method));
   } catch (err) {
     if (err.errorCode === HardwareErrorCode.BleTimeoutError && bleTimeoutRetry <= 5) {
@@ -627,7 +735,6 @@ const ensureConnected = async (
   const POLL_INTERVAL_TIME = (method.payload && method.payload.pollIntervalTime) || 1000;
   const TIME_OUT = (method.payload && method.payload.timeout) || 10000;
   let timer: ReturnType<typeof setTimeout> | null = null;
-
   Log.debug(
     `EnsureConnected function start, MAX_RETRY_COUNT=${MAX_RETRY_COUNT}, POLL_INTERVAL_TIME=${POLL_INTERVAL_TIME}  `
   );
@@ -640,7 +747,7 @@ const ensureConnected = async (
           if (timer) {
             clearTimeout(timer);
           }
-          reject(ERRORS.TypedError(HardwareErrorCode.ActionCancelled));
+          reject(ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled));
           return true;
         }
         return false;
@@ -741,7 +848,6 @@ const ensureConnected = async (
             HardwareErrorCode.SelectDevice,
             HardwareErrorCode.DeviceDetectInBootloaderMode,
             HardwareErrorCode.BleCharacteristicNotifyChangeFailure,
-            HardwareErrorCode.WebDeviceNotFoundOrNeedsPermission,
             HardwareErrorCode.BridgeNeedsPermission,
           ].includes(error.errorCode)
         ) {
@@ -755,7 +861,14 @@ const ensureConnected = async (
           clearTimeout(timer);
         }
         Log.debug('EnsureConnected get to max try count, will return: ', tryCount);
-        reject(ERRORS.TypedError(HardwareErrorCode.DeviceNotFound));
+        // Browser WebUSB needs permission prompt, desktop WebUSB doesn't
+        // skipWebDevicePrompt can override this behavior for special cases
+        if (DataManager.isBrowserWebUsb(env) && !method.payload?.skipWebDevicePrompt) {
+          postMessage(createUiMessage(UI_REQUEST.WEB_DEVICE_PROMPT_ACCESS_PERMISSION));
+          reject(ERRORS.TypedError(HardwareErrorCode.WebDeviceNotFoundOrNeedsPermission));
+        } else {
+          reject(ERRORS.TypedError(HardwareErrorCode.DeviceNotFound));
+        }
         return;
       }
 
@@ -804,7 +917,7 @@ export const cancel = (context: CoreContext, connectId?: string) => {
           }
           requestQueue.rejectRequest(
             requestId,
-            ERRORS.TypedError(HardwareErrorCode.ActionCancelled)
+            ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled)
           );
         }
       }
@@ -829,7 +942,7 @@ export const cancel = (context: CoreContext, connectId?: string) => {
 
           requestQueue.rejectRequest(
             requestId,
-            ERRORS.TypedError(HardwareErrorCode.ActionCancelled)
+            ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled)
           );
         }
       }
@@ -842,7 +955,10 @@ export const cancel = (context: CoreContext, connectId?: string) => {
       });
 
       requestQueue.getRequestTasksId().forEach(requestId => {
-        requestQueue.rejectRequest(requestId, ERRORS.TypedError(HardwareErrorCode.ActionCancelled));
+        requestQueue.rejectRequest(
+          requestId,
+          ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled)
+        );
       });
     }
   }
@@ -995,6 +1111,23 @@ const onSelectDeviceInBootloaderForWebDeviceHandler = async (
   callback(null, uiResp.payload.deviceId);
 };
 
+const onSelectDeviceForSwitchFirmwareWebDeviceHandler = async (
+  ...[device, callback]: [...DeviceEvents['select_device_for_switch_firmware_web_device']]
+) => {
+  Log.debug('onSelectDeviceForSwitchFirmwareWebDeviceHandler');
+  const uiPromise = createUiPromise(
+    UI_RESPONSE.SELECT_DEVICE_FOR_SWITCH_FIRMWARE_WEB_DEVICE,
+    device
+  );
+  postMessage(
+    createUiMessage(UI_REQUEST.REQUEST_DEVICE_FOR_SWITCH_FIRMWARE_WEB_DEVICE, {
+      device: device.toMessageObject() as KnownDevice,
+    })
+  );
+  const uiResp = await uiPromise.promise;
+  callback(null, uiResp.payload.deviceId);
+};
+
 /**
  * Emit message to listener (parent).
  * Clear method reference from _callMethods
@@ -1003,6 +1136,9 @@ const onSelectDeviceInBootloaderForWebDeviceHandler = async (
  * @memberof Core
  */
 const postMessage = (message: CoreMessage) => {
+  if (!_core) {
+    return;
+  }
   _core.emit(CORE_EVENT, message);
 };
 
@@ -1021,6 +1157,10 @@ const removeUiPromise = (promise: Deferred<any>) => {
 };
 
 export default class Core extends EventEmitter {
+  private tracingContext: SdkTracingContext;
+
+  public readonly sdkInstanceId: string;
+
   private requestQueue = new RequestQueue();
 
   // background task
@@ -1028,8 +1168,17 @@ export default class Core extends EventEmitter {
 
   private methodSynchronize = getSynchronize();
 
+  constructor() {
+    super();
+    this.tracingContext = createSdkTracingContext();
+    this.sdkInstanceId = this.tracingContext.sdkInstanceId;
+    Log.debug(`[Core] Created SDK instance: ${this.sdkInstanceId}`);
+  }
+
   private getCoreContext() {
     return {
+      sdkInstanceId: this.sdkInstanceId,
+      tracingContext: this.tracingContext,
       requestQueue: this.requestQueue,
       methodSynchronize: this.methodSynchronize,
       getPrePendingCallPromise: () => this.prePendingCallPromise,
@@ -1050,7 +1199,8 @@ export default class Core extends EventEmitter {
     switch (message.type) {
       case UI_RESPONSE.RECEIVE_PIN:
       case UI_RESPONSE.RECEIVE_PASSPHRASE:
-      case UI_RESPONSE.SELECT_DEVICE_IN_BOOTLOADER_FOR_WEB_DEVICE: {
+      case UI_RESPONSE.SELECT_DEVICE_IN_BOOTLOADER_FOR_WEB_DEVICE:
+      case UI_RESPONSE.SELECT_DEVICE_FOR_SWITCH_FIRMWARE_WEB_DEVICE: {
         const uiPromise = findUiPromise(message.type);
         if (uiPromise) {
           Log.log('receive UI Response: ', message.type);
@@ -1105,7 +1255,10 @@ export default class Core extends EventEmitter {
   }
 
   dispose() {
-    // empty
+    _deviceList = undefined;
+    _connector = undefined;
+    Log.debug(`[Core] Disposing SDK instance: ${this.sdkInstanceId}`);
+    cleanupSdkInstance(this.sdkInstanceId);
   }
 }
 

package/src/data/config.ts

@@ -2,16 +2,16 @@
 const pkg = require('../package.json');
 
 export const getSDKVersion = () => pkg.version;
-export const DEFAULT_DOMAIN = `https://jssdk.sanying.site/${getSDKVersion()}/`;
+export const DEFAULT_DOMAIN = `https://jssdk.ukey.io/${getSDKVersion()}/`;
 
 export const whitelist = [
   // Electron local file
   { origin: 'file://' },
   // UKey App
   { origin: '1key.so' },
-  { origin: 'sanying.site' },
-  { origin: 'sanying.com' },
-  { origin: 'sanyingtest.com' },
+  { origin: 'ukey.io' },
+  { origin: 'ukeycn.com' },
+  { origin: 'ukeytest.com' },
   { origin: 'localhost' },
 ];