@onekeyfe/hardware-cli 1.2.0-alpha.99 → 1.2.0

package/dist/cli.js

@@ -62,15 +62,11 @@ program
 program
     .command('upload-wallpaper')
     .description('Upload and activate a Pro2 wallpaper')
-    .requiredOption('--rgba <path>', '604x1024 raw RGBA file')
+    .requiredOption('--jpeg <path>', '604x1024 JPEG file')
     .option('--file-name <name>', 'Device wallpaper file name', 'wallpaper-cli')
     .option('--chunk-size <bytes>', 'Transfer chunk size in bytes')
     .action(opts => runCommand({}, async ({ sdk, globalOpts, params }) => {
-    const rgba = readBinaryParam(opts.rgba);
-    const expectedBytes = 604 * 1024 * 4;
-    if (rgba.byteLength !== expectedBytes) {
-        throw new Error(`Invalid RGBA size: expected ${expectedBytes} bytes, received ${rgba.byteLength}`);
-    }
+    const jpegBase64 = (0, node_fs_1.readFileSync)(opts.jpeg).toString('base64');
     let transferStartedAt;
     let transferEndedAt;
     let lastProgress = -1;
@@ -111,9 +107,7 @@ program
     try {
         result = await sdk.deviceUploadWallpaper(globalOpts.connectId, {
             ...params,
-            width: 604,
-            height: 1024,
-            rgba,
+            jpegBase64,
             fileName: opts.fileName,
             chunkSize: opts.chunkSize ? safeParseInt(opts.chunkSize, '--chunk-size') : undefined,
         });
@@ -938,17 +932,18 @@ async function resolveLegacyFirmwareConnectId(sdk, explicitConnectId, deviceName
         throw new Error('Unable to scan BLE devices');
     }
     const devices = searchResult.payload;
-    const normalizedName = deviceName?.trim().toLowerCase();
-    const matches = normalizedName
-        ? devices.filter(device => device.name?.trim().toLowerCase() === normalizedName)
+    const requestedName = deviceName?.trim();
+    const matches = requestedName
+        ? devices.filter(device => (0, hd_shared_1.isSameOnekeyBleName)(device.name, requestedName) ||
+            device.name?.trim().toLowerCase() === requestedName.toLowerCase())
         : devices.filter(device => device.deviceType?.toLowerCase() === 'classic');
     if (matches.length === 0) {
-        throw new Error(normalizedName
+        throw new Error(requestedName
             ? `BLE device not found by name: ${deviceName}`
             : 'No Classic/Pure BLE device found');
     }
     if (matches.length > 1) {
-        throw new Error(normalizedName
+        throw new Error(requestedName
             ? `Multiple BLE devices found by name: ${deviceName}`
             : 'Multiple Classic/Pure BLE devices found; specify --device-name');
     }

package/dist/transports/nobleBlePlugin.js

@@ -20,6 +20,7 @@ const connectedDevices = new Map();
 const deviceCharacteristics = new Map();
 const notificationStates = new Map();
 const notificationGenerations = new Map();
+const disconnectListeners = new Map();
 function isOneKeyPeripheral(peripheral) {
     const serviceUuids = peripheral.advertisement?.serviceUuids;
     return ((0, hd_shared_1.hasOnekeyCommunicationService)(serviceUuids) &&
@@ -63,11 +64,32 @@ function clearNotificationState(deviceId, reason) {
     if (!state)
         return;
     notificationStates.delete(deviceId);
-    const error = new Error(reason);
+    const error = reason instanceof Error ? reason : new Error(reason);
     state.pendingReceivers.forEach(receiver => receiver.reject(error));
     state.pendingReceivers.clear();
     state.queue.length = 0;
 }
+function removeDisconnectListener(deviceId) {
+    const tracked = disconnectListeners.get(deviceId);
+    if (!tracked)
+        return;
+    tracked.peripheral.removeListener('disconnect', tracked.listener);
+    disconnectListeners.delete(deviceId);
+}
+function trackUnexpectedDisconnect(deviceId, peripheral) {
+    removeDisconnectListener(deviceId);
+    const listener = (reason) => {
+        removeDisconnectListener(deviceId);
+        if (connectedDevices.get(deviceId) !== peripheral)
+            return;
+        deviceCharacteristics.get(deviceId)?.notify.removeAllListeners('data');
+        connectedDevices.delete(deviceId);
+        deviceCharacteristics.delete(deviceId);
+        clearNotificationState(deviceId, hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BleDeviceDisconnected, reason || `BLE device disconnected: ${deviceId}`));
+    };
+    disconnectListeners.set(deviceId, { peripheral, listener });
+    peripheral.on('disconnect', listener);
+}
 function waitForNobleCleanup(registerCallback) {
     return new Promise(resolve => {
         let completed = false;
@@ -280,6 +302,7 @@ function writeCharacteristic(characteristic, buffer, withoutResponse) {
 async function disconnectDevice(uuid) {
     const peripheral = connectedDevices.get(uuid);
     const characteristics = deviceCharacteristics.get(uuid);
+    removeDisconnectListener(uuid);
     clearNotificationState(uuid, `BLE device disconnected: ${uuid}`);
     if (characteristics) {
         characteristics.notify.removeAllListeners('data');
@@ -321,8 +344,10 @@ function createNobleBlePlugin() {
                 await subscribeNotifications(uuid, notificationState.generation, characteristics.notify);
                 connectedDevices.set(uuid, peripheral);
                 deviceCharacteristics.set(uuid, characteristics);
+                trackUnexpectedDisconnect(uuid, peripheral);
             }
             catch (error) {
+                removeDisconnectListener(uuid);
                 clearNotificationState(uuid, `BLE notification subscription failed: ${uuid}`);
                 if (characteristics) {
                     characteristics.notify.removeAllListeners('data');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hardware-cli",
-  "version": "1.2.0-alpha.99",
+  "version": "1.2.0",
   "description": "OneKey hardware wallet CLI for testing device communication",
   "author": "OneKey",
   "license": "Apache-2.0",
@@ -31,12 +31,12 @@
     "test": "jest"
   },
   "dependencies": {
-    "@onekeyfe/hd-common-connect-sdk": "1.2.0-alpha.99",
-    "@onekeyfe/hd-core": "1.2.0-alpha.99",
-    "@onekeyfe/hd-shared": "1.2.0-alpha.99",
-    "@onekeyfe/hd-transport-usb": "1.2.0-alpha.99",
+    "@onekeyfe/hd-common-connect-sdk": "1.2.0",
+    "@onekeyfe/hd-core": "1.2.0",
+    "@onekeyfe/hd-shared": "1.2.0",
+    "@onekeyfe/hd-transport-usb": "1.2.0",
     "@stoprocent/noble": "2.3.16",
     "commander": "^12.0.0"
   },
-  "gitHead": "8924c0e509f84675a2c33c0062166967f5bcb2d0"
+  "gitHead": "cc51df0a415bead21304ad1d8bc92b5312c91344"
 }

package/src/__tests__/noble-ble-plugin.test.ts

@@ -1,4 +1,5 @@
 import { EventEmitter } from 'events';
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 type MockCharacteristic = EventEmitter & {
   uuid: string;
@@ -27,18 +28,19 @@ const createPeripheral = (id: string) => {
     uuid: '0001',
     discoverCharacteristics: jest.fn((_uuids, callback) => callback(null, [write, notify])),
   };
-  return {
-    peripheral: {
-      id,
-      state: 'connected',
-      advertisement: {
-        localName: `OneKey Pro 2 ${id}`,
-        serviceUuids: ['0001'],
-      },
-      discoverServices: jest.fn((_uuids, callback) => callback(null, [service])),
-      connect: jest.fn(callback => callback()),
-      disconnect: jest.fn(callback => callback()),
+  const peripheral = Object.assign(new EventEmitter(), {
+    id,
+    state: 'connected',
+    advertisement: {
+      localName: `OneKey Pro 2 ${id}`,
+      serviceUuids: ['0001'],
     },
+    discoverServices: jest.fn((_uuids, callback) => callback(null, [service])),
+    connect: jest.fn(callback => callback()),
+    disconnect: jest.fn(callback => callback()),
+  });
+  return {
+    peripheral,
     service,
     write,
     notify,
@@ -177,6 +179,38 @@ describe('Noble BLE plugin notification routing', () => {
     expect(result).toBe('completed');
   });
 
+  test('rejects a pending receive when the peripheral disconnects unexpectedly', async () => {
+    const device = createPeripheral('device-a');
+    const noble = new EventEmitter() as EventEmitter & {
+      state: string;
+      startScanning: jest.Mock;
+      stopScanning: jest.Mock;
+    };
+    noble.state = 'poweredOn';
+    noble.startScanning = jest.fn((_services, _duplicates, callback) => {
+      callback?.();
+      noble.emit('discover', device.peripheral);
+    });
+    noble.stopScanning = jest.fn(callback => callback?.());
+    jest.doMock('@stoprocent/noble', () => noble);
+
+    const { createNobleBlePlugin } = await import('../transports/nobleBlePlugin');
+    const plugin = createNobleBlePlugin();
+    await plugin.init();
+    await plugin.connect('device-a');
+
+    const receive = plugin.receive('device-a');
+    device.peripheral.state = 'disconnected';
+    device.peripheral.emit('disconnect', 'Remote User Terminated Connection');
+
+    await expect(receive).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleDeviceDisconnected,
+    });
+    await expect(plugin.receive('device-a')).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.TransportNotFound,
+    });
+  });
+
   test('disconnects an untracked peripheral when service discovery fails', async () => {
     const device = createPeripheral('device-a');
     device.peripheral.discoverServices.mockImplementation((_uuids, callback) =>

package/src/__tests__/wallpaper-upload-command.test.ts

@@ -6,6 +6,7 @@ describe('upload-wallpaper CLI command', () => {
 
     expect(command).toBeDefined();
     expect(command?.description()).toBe('Upload and activate a Pro2 wallpaper');
+    expect(command?.options.some(option => option.long === '--jpeg' && option.required)).toBe(true);
   });
 
   test('reports effective transfer speed from encoded bytes and elapsed time', () => {

package/src/cli.ts

@@ -2,7 +2,7 @@ import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { Command } from 'commander';
 import { UI_EVENT, UI_REQUEST, getDeviceType } from '@onekeyfe/hd-core';
-import { EDeviceType } from '@onekeyfe/hd-shared';
+import { EDeviceType, isSameOnekeyBleName } from '@onekeyfe/hd-shared';
 
 import {
   resolveBatchGetAddress,
@@ -99,18 +99,12 @@ program
 program
   .command('upload-wallpaper')
   .description('Upload and activate a Pro2 wallpaper')
-  .requiredOption('--rgba <path>', '604x1024 raw RGBA file')
+  .requiredOption('--jpeg <path>', '604x1024 JPEG file')
   .option('--file-name <name>', 'Device wallpaper file name', 'wallpaper-cli')
   .option('--chunk-size <bytes>', 'Transfer chunk size in bytes')
   .action(opts =>
     runCommand({}, async ({ sdk, globalOpts, params }) => {
-      const rgba = readBinaryParam(opts.rgba);
-      const expectedBytes = 604 * 1024 * 4;
-      if (rgba.byteLength !== expectedBytes) {
-        throw new Error(
-          `Invalid RGBA size: expected ${expectedBytes} bytes, received ${rgba.byteLength}`
-        );
-      }
+      const jpegBase64 = readFileSync(opts.jpeg).toString('base64');
 
       let transferStartedAt: number | undefined;
       let transferEndedAt: number | undefined;
@@ -159,9 +153,7 @@ program
       try {
         result = await sdk.deviceUploadWallpaper(globalOpts.connectId, {
           ...params,
-          width: 604,
-          height: 1024,
-          rgba,
+          jpegBase64,
           fileName: opts.fileName,
           chunkSize: opts.chunkSize ? safeParseInt(opts.chunkSize, '--chunk-size') : undefined,
         });
@@ -1225,21 +1217,25 @@ async function resolveLegacyFirmwareConnectId(
   }
 
   const devices = searchResult.payload as EnrichedSearchDevice[];
-  const normalizedName = deviceName?.trim().toLowerCase();
-  const matches = normalizedName
-    ? devices.filter(device => device.name?.trim().toLowerCase() === normalizedName)
+  const requestedName = deviceName?.trim();
+  const matches = requestedName
+    ? devices.filter(
+        device =>
+          isSameOnekeyBleName(device.name, requestedName) ||
+          device.name?.trim().toLowerCase() === requestedName.toLowerCase()
+      )
     : devices.filter(device => device.deviceType?.toLowerCase() === 'classic');
 
   if (matches.length === 0) {
     throw new Error(
-      normalizedName
+      requestedName
         ? `BLE device not found by name: ${deviceName}`
         : 'No Classic/Pure BLE device found'
     );
   }
   if (matches.length > 1) {
     throw new Error(
-      normalizedName
+      requestedName
         ? `Multiple BLE devices found by name: ${deviceName}`
         : 'Multiple Classic/Pure BLE devices found; specify --device-name'
     );

package/src/transports/nobleBlePlugin.ts

@@ -43,6 +43,11 @@ type NobleNotificationState = {
   pendingReceivers: Set<NoblePendingReceiver>;
 };
 
+type NobleDisconnectListener = {
+  peripheral: Peripheral;
+  listener: (reason: string) => void;
+};
+
 const ONEKEY_SERVICE_UUIDS = [ONEKEY_SERVICE_UUID];
 const ONEKEY_SERVICE_UUID_ALIASES = createKnownBleUuidAliases(ONEKEY_SERVICE_UUID);
 const ONEKEY_WRITE_UUID_ALIASES = createKnownBleUuidAliases(ONEKEY_WRITE_CHARACTERISTIC_UUID);
@@ -63,6 +68,7 @@ const connectedDevices = new Map<string, Peripheral>();
 const deviceCharacteristics = new Map<string, CharacteristicPair>();
 const notificationStates = new Map<string, NobleNotificationState>();
 const notificationGenerations = new Map<string, number>();
+const disconnectListeners = new Map<string, NobleDisconnectListener>();
 
 function isOneKeyPeripheral(peripheral: Peripheral) {
   const serviceUuids = peripheral.advertisement?.serviceUuids;
@@ -108,17 +114,45 @@ function createNotificationState(deviceId: string) {
   return state;
 }
 
-function clearNotificationState(deviceId: string, reason: string) {
+function clearNotificationState(deviceId: string, reason: string | Error) {
   const state = notificationStates.get(deviceId);
   if (!state) return;
 
   notificationStates.delete(deviceId);
-  const error = new Error(reason);
+  const error = reason instanceof Error ? reason : new Error(reason);
   state.pendingReceivers.forEach(receiver => receiver.reject(error));
   state.pendingReceivers.clear();
   state.queue.length = 0;
 }
 
+function removeDisconnectListener(deviceId: string) {
+  const tracked = disconnectListeners.get(deviceId);
+  if (!tracked) return;
+  tracked.peripheral.removeListener('disconnect', tracked.listener);
+  disconnectListeners.delete(deviceId);
+}
+
+function trackUnexpectedDisconnect(deviceId: string, peripheral: Peripheral) {
+  removeDisconnectListener(deviceId);
+  const listener = (reason: string) => {
+    removeDisconnectListener(deviceId);
+    if (connectedDevices.get(deviceId) !== peripheral) return;
+
+    deviceCharacteristics.get(deviceId)?.notify.removeAllListeners('data');
+    connectedDevices.delete(deviceId);
+    deviceCharacteristics.delete(deviceId);
+    clearNotificationState(
+      deviceId,
+      ERRORS.TypedError(
+        HardwareErrorCode.BleDeviceDisconnected,
+        reason || `BLE device disconnected: ${deviceId}`
+      )
+    );
+  };
+  disconnectListeners.set(deviceId, { peripheral, listener });
+  peripheral.on('disconnect', listener);
+}
+
 function waitForNobleCleanup(registerCallback: (callback: () => void) => void) {
   return new Promise<void>(resolve => {
     let completed = false;
@@ -377,6 +411,7 @@ function writeCharacteristic(
 async function disconnectDevice(uuid: string) {
   const peripheral = connectedDevices.get(uuid);
   const characteristics = deviceCharacteristics.get(uuid);
+  removeDisconnectListener(uuid);
   clearNotificationState(uuid, `BLE device disconnected: ${uuid}`);
   if (characteristics) {
     characteristics.notify.removeAllListeners('data');
@@ -425,7 +460,9 @@ export function createNobleBlePlugin(): LowlevelTransportSharedPlugin {
         await subscribeNotifications(uuid, notificationState.generation, characteristics.notify);
         connectedDevices.set(uuid, peripheral);
         deviceCharacteristics.set(uuid, characteristics);
+        trackUnexpectedDisconnect(uuid, peripheral);
       } catch (error) {
+        removeDisconnectListener(uuid);
         clearNotificationState(uuid, `BLE notification subscription failed: ${uuid}`);
         if (characteristics) {
           characteristics.notify.removeAllListeners('data');