@onekeyfe/hardware-cli 1.2.0-alpha.2 → 1.2.0-alpha.21

package/dist/deviceStateCommands.d.ts

@@ -0,0 +1,19 @@
+import type { CoreApi, DeviceStateScope } from '@onekeyfe/hd-core';
+type DeviceStateSdk = Pick<CoreApi, 'searchDevices' | 'getDeviceState' | 'getFeatures'>;
+/**
+ * Unified state entry for the new CLI. Resolve the user-facing connectId through
+ * discovery so V1 serial IDs map to the process-local USB path.
+ */
+export declare const getCanonicalDeviceState: (sdk: DeviceStateSdk, connectId: string | undefined, scope: DeviceStateScope) => Promise<import("@onekeyfe/hd-core").Unsuccessful | {
+    success: true;
+    payload: import("@onekeyfe/hd-core").DeviceState;
+}>;
+/**
+ * Legacy CLI only: retain getFeatures for V1 and reuse the discovery projection for V2.
+ * Public SDK.getFeatures remains V1-only.
+ */
+export declare const getCompatibleFeatures: (sdk: DeviceStateSdk, connectId?: string) => Promise<import("@onekeyfe/hd-core").Unsuccessful | {
+    success: true;
+    payload: import("@onekeyfe/hd-core").Features;
+}>;
+export {};

package/dist/deviceStateCommands.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCompatibleFeatures = exports.getCanonicalDeviceState = void 0;
+const createDeviceNotFoundResult = (connectId) => ({
+    success: false,
+    payload: {
+        code: 'DEVICE_NOT_FOUND',
+        error: connectId ? `Device not found: ${connectId}` : 'No device found',
+    },
+});
+const resolveSearchDevice = async (sdk, connectId) => {
+    const searchResult = await sdk.searchDevices();
+    if (!searchResult.success)
+        return searchResult;
+    const devices = searchResult.payload;
+    const device = connectId ? devices.find(item => item.connectId === connectId) : devices[0];
+    if (!device?.connectId)
+        return createDeviceNotFoundResult(connectId);
+    return { success: true, payload: device };
+};
+/**
+ * Unified state entry for the new CLI. Resolve the user-facing connectId through
+ * discovery so V1 serial IDs map to the process-local USB path.
+ */
+const getCanonicalDeviceState = async (sdk, connectId, scope) => {
+    const deviceResult = await resolveSearchDevice(sdk, connectId);
+    if (!deviceResult.success)
+        return deviceResult;
+    if (scope === 'runtime' && deviceResult.payload.state) {
+        return { success: true, payload: deviceResult.payload.state };
+    }
+    const resolvedConnectId = deviceResult.payload.connectId ?? undefined;
+    if (!resolvedConnectId)
+        return createDeviceNotFoundResult();
+    return sdk.getDeviceState(resolvedConnectId, { scope });
+};
+exports.getCanonicalDeviceState = getCanonicalDeviceState;
+/**
+ * Legacy CLI only: retain getFeatures for V1 and reuse the discovery projection for V2.
+ * Public SDK.getFeatures remains V1-only.
+ */
+const getCompatibleFeatures = async (sdk, connectId) => {
+    const deviceResult = await resolveSearchDevice(sdk, connectId);
+    if (!deviceResult.success)
+        return deviceResult;
+    const device = deviceResult.payload;
+    const protocol = device.state?.protocol ?? device.features?.protocol;
+    if (protocol === 'V2') {
+        if (!device.features) {
+            return {
+                success: false,
+                payload: {
+                    code: 'DEVICE_FEATURES_UNAVAILABLE',
+                    error: 'Protocol V2 compatibility features are unavailable',
+                },
+            };
+        }
+        return { success: true, payload: device.features };
+    }
+    return sdk.getFeatures(device.connectId ?? '');
+};
+exports.getCompatibleFeatures = getCompatibleFeatures;

package/dist/sdk.d.ts

@@ -13,6 +13,8 @@ export interface SDKOptions {
     connectId?: string;
     passphraseState?: string;
     useEmptyPassphrase?: boolean;
+    debug?: boolean;
+    transport?: 'usb' | 'ble';
 }
 export declare function createSDK(opts: SDKOptions): Promise<typeof HardwareSDK>;
 /**

package/dist/sdk.js

@@ -41,6 +41,7 @@ const readline = __importStar(require("node:readline"));
 const hd_common_connect_sdk_1 = __importDefault(require("@onekeyfe/hd-common-connect-sdk"));
 const hd_core_1 = require("@onekeyfe/hd-core");
 const pinentry_1 = require("./pinentry");
+const nobleBlePlugin_1 = require("./transports/nobleBlePlugin");
 /**
  * Current per-invocation CLI options. Event handlers read from this object
  * so that invoking createSDK() with different opts never results in stale
@@ -167,12 +168,12 @@ function registerEventHandlers(sdk) {
             process.stderr.write('[onekey-hw] Please confirm the action on your device...\n');
         }
     });
-    sdk.on(hd_core_1.DEVICE.CONNECT, (device) => {
+    sdk.on(hd_core_1.DEVICE.CONNECT, ({ device }) => {
         const name = device?.label || device?.name;
         if (name)
             process.stderr.write(`[onekey-hw] Device connected: ${name}\n`);
     });
-    sdk.on(hd_core_1.DEVICE.DISCONNECT, (device) => {
+    sdk.on(hd_core_1.DEVICE.DISCONNECT, ({ device }) => {
         const name = device?.label || device?.name;
         if (name)
             process.stderr.write(`[onekey-hw] Device disconnected: ${name}\n`);
@@ -182,12 +183,13 @@ function registerEventHandlers(sdk) {
 // SDK Factory
 // ---------------------------------------------------------------------------
 async function initSDK() {
+    const transport = currentOpts.transport ?? 'usb';
     const settings = {
-        debug: false,
+        debug: currentOpts.debug ?? false,
         fetchConfig: true,
-        env: 'node-usb',
+        env: transport === 'ble' ? 'lowlevel' : 'node-usb',
     };
-    await hd_common_connect_sdk_1.default.init(settings);
+    await hd_common_connect_sdk_1.default.init(settings, undefined, transport === 'ble' ? (0, nobleBlePlugin_1.createNobleBlePlugin)() : undefined);
     // Defensive: strip any stale listeners (e.g. left over from a previous
     // dispose/init cycle in a long-running process) before wiring ours.
     // Mirrors app-monorepo's cleanupHardwareSDKInstance() which removes
@@ -220,7 +222,7 @@ async function disposeSDK() {
         return;
     try {
         const sdk = await sdkReadyPromise;
-        sdk.dispose();
+        await Promise.resolve(sdk.dispose());
     }
     catch {
         // ignore errors during cleanup

package/dist/transports/nobleBlePlugin.d.ts

@@ -0,0 +1,2 @@
+import type { LowlevelTransportSharedPlugin } from '@onekeyfe/hd-transport';
+export declare function createNobleBlePlugin(): LowlevelTransportSharedPlugin;

package/dist/transports/nobleBlePlugin.js

@@ -0,0 +1,384 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNobleBlePlugin = void 0;
+const hd_shared_1 = require("@onekeyfe/hd-shared");
+const ONEKEY_SERVICE_UUIDS = [hd_shared_1.ONEKEY_SERVICE_UUID];
+const PRO2_ADVERTISEMENT_SERVICE_UUID_KEYS = new Set(['fffd']);
+const NORMALIZED_WRITE_UUID = '0002';
+const NORMALIZED_NOTIFY_UUID = '0003';
+const NORMALIZED_ONEKEY_SERVICE_UUIDS = new Set([
+    ...ONEKEY_SERVICE_UUIDS.map(uuid => getBleUuidKey(uuid)),
+    '0001',
+]);
+const BLUETOOTH_INIT_TIMEOUT = 10000;
+const DEVICE_SCAN_TIMEOUT = 8000;
+const CONNECTION_TIMEOUT = 8000;
+const SERVICE_DISCOVERY_TIMEOUT = 10000;
+const BLE_CLEANUP_TIMEOUT = 100;
+const BLE_PACKET_SIZE = 192;
+const BLE_ENCRYPTION_ERROR_PATTERNS = [/encryption is insufficient/i, /insufficient encryption/i];
+let noble = null;
+let nobleReadyPromise = null;
+const discoveredDevices = new Map();
+const connectedDevices = new Map();
+const deviceCharacteristics = new Map();
+const notificationStates = new Map();
+const notificationGenerations = new Map();
+function getBleUuidKey(uuid) {
+    const normalized = (uuid ?? '').replace(/-/g, '').toLowerCase();
+    return normalized.length >= 8 ? normalized.substring(4, 8) : normalized;
+}
+function isGenericBleService(uuid) {
+    return ['1800', '1801', '180a', '180f'].includes(getBleUuidKey(uuid));
+}
+function hasOneKeyAdvertisementService(peripheral) {
+    const serviceUuids = peripheral.advertisement?.serviceUuids ?? [];
+    return serviceUuids.some(uuid => {
+        const uuidKey = getBleUuidKey(uuid);
+        return (NORMALIZED_ONEKEY_SERVICE_UUIDS.has(uuidKey) ||
+            PRO2_ADVERTISEMENT_SERVICE_UUID_KEYS.has(uuidKey));
+    });
+}
+function isOneKeyPeripheral(peripheral) {
+    const deviceName = peripheral.advertisement?.localName || null;
+    return (0, hd_shared_1.isOnekeyDevice)(deviceName, peripheral.id) || hasOneKeyAdvertisementService(peripheral);
+}
+function enqueueNotification(deviceId, generation, data) {
+    const state = notificationStates.get(deviceId);
+    if (!state || state.generation !== generation)
+        return;
+    const hex = data.toString('hex');
+    const [receiver] = state.pendingReceivers;
+    if (receiver) {
+        state.pendingReceivers.delete(receiver);
+        receiver.resolve(hex);
+        return;
+    }
+    state.queue.push(hex);
+}
+function createNotificationState(deviceId) {
+    const existing = notificationStates.get(deviceId);
+    if (existing) {
+        const error = new Error(`BLE notification state replaced for ${deviceId}`);
+        existing.pendingReceivers.forEach(receiver => receiver.reject(error));
+    }
+    const generation = (notificationGenerations.get(deviceId) ?? 0) + 1;
+    notificationGenerations.set(deviceId, generation);
+    const state = {
+        generation,
+        queue: [],
+        pendingReceivers: new Set(),
+    };
+    notificationStates.set(deviceId, state);
+    return state;
+}
+function clearNotificationState(deviceId, reason) {
+    const state = notificationStates.get(deviceId);
+    if (!state)
+        return;
+    notificationStates.delete(deviceId);
+    const error = new Error(reason);
+    state.pendingReceivers.forEach(receiver => receiver.reject(error));
+    state.pendingReceivers.clear();
+    state.queue.length = 0;
+}
+function waitForNobleCleanup(registerCallback) {
+    return new Promise(resolve => {
+        let completed = false;
+        const complete = () => {
+            if (completed)
+                return;
+            completed = true;
+            clearTimeout(timeout);
+            resolve();
+        };
+        const timeout = setTimeout(complete, BLE_CLEANUP_TIMEOUT);
+        try {
+            registerCallback(complete);
+        }
+        catch {
+            complete();
+        }
+    });
+}
+async function initializeNoble() {
+    if (!noble) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires, global-require
+            noble = require('@stoprocent/noble');
+        }
+        catch (error) {
+            throw hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BleUnsupported, error instanceof Error ? error.message : String(error));
+        }
+    }
+    if (noble.state === 'poweredOn')
+        return;
+    if (nobleReadyPromise) {
+        await nobleReadyPromise;
+        return;
+    }
+    nobleReadyPromise = new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            noble?.removeListener('stateChange', onStateChange);
+            reject(hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BlePoweredOff, 'Bluetooth is not powered on'));
+        }, BLUETOOTH_INIT_TIMEOUT);
+        const onStateChange = (state) => {
+            if (state === 'poweredOn') {
+                clearTimeout(timeout);
+                noble?.removeListener('stateChange', onStateChange);
+                resolve();
+            }
+            else if (state === 'unsupported') {
+                clearTimeout(timeout);
+                noble?.removeListener('stateChange', onStateChange);
+                reject(hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BleUnsupported));
+            }
+        };
+        noble?.on('stateChange', onStateChange);
+    }).finally(() => {
+        nobleReadyPromise = null;
+    });
+    await nobleReadyPromise;
+}
+function stopScanning() {
+    try {
+        noble?.stopScanning();
+    }
+    catch {
+        // ignore best-effort scan cleanup
+    }
+}
+async function scanDevices(targetDeviceId) {
+    await initializeNoble();
+    if (!noble) {
+        throw hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.RuntimeError, 'Noble not initialized');
+    }
+    if (!targetDeviceId) {
+        discoveredDevices.clear();
+    }
+    const nobleInstance = noble;
+    return new Promise((resolve, reject) => {
+        const found = new Map();
+        const cleanup = () => {
+            clearTimeout(timeout);
+            nobleInstance.removeListener('discover', onDiscover);
+            stopScanning();
+        };
+        const finish = () => {
+            cleanup();
+            resolve([...found.values()]);
+        };
+        const onDiscover = (peripheral) => {
+            if (targetDeviceId && peripheral.id !== targetDeviceId)
+                return;
+            if (!targetDeviceId && !isOneKeyPeripheral(peripheral))
+                return;
+            discoveredDevices.set(peripheral.id, peripheral);
+            found.set(peripheral.id, peripheral);
+            if (targetDeviceId) {
+                finish();
+            }
+        };
+        const timeout = setTimeout(finish, DEVICE_SCAN_TIMEOUT);
+        nobleInstance.on('discover', onDiscover);
+        nobleInstance.startScanning([], false, (error) => {
+            if (error) {
+                cleanup();
+                reject(hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BleScanError, error.message));
+            }
+        });
+    });
+}
+function connectPeripheral(peripheral) {
+    if (peripheral.state === 'connected')
+        return Promise.resolve();
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            reject(hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BleConnectedError, 'Connection timeout'));
+        }, CONNECTION_TIMEOUT);
+        peripheral.connect((error) => {
+            clearTimeout(timeout);
+            if (error) {
+                reject(hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BleConnectedError, error.message));
+                return;
+            }
+            resolve();
+        });
+    });
+}
+async function discoverCharacteristics(peripheral) {
+    const services = await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            reject(hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BleServiceNotFound, 'Service discovery timeout'));
+        }, SERVICE_DISCOVERY_TIMEOUT);
+        peripheral.discoverServices([], (error, discoveredServices) => {
+            clearTimeout(timeout);
+            if (error) {
+                reject(hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BleServiceNotFound, error.message));
+                return;
+            }
+            resolve(discoveredServices);
+        });
+    });
+    let service = services.find(s => NORMALIZED_ONEKEY_SERVICE_UUIDS.has(getBleUuidKey(s.uuid)));
+    if (!service) {
+        service =
+            services.find(s => PRO2_ADVERTISEMENT_SERVICE_UUID_KEYS.has(getBleUuidKey(s.uuid))) ||
+                services.find(s => !isGenericBleService(s.uuid)) ||
+                services[0];
+    }
+    if (!service) {
+        throw hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BleServiceNotFound, 'No BLE service found');
+    }
+    const selectedService = service;
+    const characteristics = await new Promise((resolve, reject) => {
+        selectedService.discoverCharacteristics([], (error, discoveredCharacteristics) => {
+            if (error) {
+                reject(hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BleCharacteristicNotFound, error.message));
+                return;
+            }
+            resolve(discoveredCharacteristics);
+        });
+    });
+    let writeCharacteristic;
+    let notifyCharacteristic;
+    for (const characteristic of characteristics) {
+        const uuidKey = getBleUuidKey(characteristic.uuid);
+        if (uuidKey === NORMALIZED_WRITE_UUID) {
+            writeCharacteristic = characteristic;
+        }
+        else if (uuidKey === NORMALIZED_NOTIFY_UUID) {
+            notifyCharacteristic = characteristic;
+        }
+    }
+    if (!writeCharacteristic || !notifyCharacteristic) {
+        throw hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BleCharacteristicNotFound, 'Required OneKey BLE characteristics not found');
+    }
+    return {
+        write: writeCharacteristic,
+        notify: notifyCharacteristic,
+    };
+}
+function subscribeNotifications(deviceId, generation, notifyCharacteristic) {
+    return waitForNobleCleanup(callback => notifyCharacteristic.unsubscribe(callback))
+        .then(() => new Promise((resolve, reject) => {
+        notifyCharacteristic.subscribe((error) => {
+            if (error) {
+                const errorMessage = error.message || String(error);
+                if (BLE_ENCRYPTION_ERROR_PATTERNS.some(pattern => pattern.test(errorMessage))) {
+                    reject(hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BleDeviceNotBonded, `BLE device ${deviceId} is not paired or the encrypted link is not ready: ${errorMessage}`));
+                    return;
+                }
+                reject(hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BleCharacteristicNotifyChangeFailure, `Failed to subscribe notifications for ${deviceId}: ${errorMessage}`));
+                return;
+            }
+            resolve();
+        });
+    }))
+        .then(() => {
+        notifyCharacteristic.removeAllListeners('data');
+        notifyCharacteristic.on('data', data => enqueueNotification(deviceId, generation, data));
+    })
+        .catch(error => {
+        notifyCharacteristic.removeAllListeners('data');
+        if (error) {
+            throw error;
+        }
+        throw hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BleCharacteristicNotifyChangeFailure);
+    });
+}
+function writeCharacteristic(characteristic, buffer, withoutResponse) {
+    return new Promise((resolve, reject) => {
+        characteristic.write(buffer, withoutResponse, (error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+}
+async function disconnectDevice(uuid) {
+    const peripheral = connectedDevices.get(uuid);
+    const characteristics = deviceCharacteristics.get(uuid);
+    clearNotificationState(uuid, `BLE device disconnected: ${uuid}`);
+    if (characteristics) {
+        characteristics.notify.removeAllListeners('data');
+        await waitForNobleCleanup(callback => characteristics.notify.unsubscribe(callback));
+    }
+    connectedDevices.delete(uuid);
+    deviceCharacteristics.delete(uuid);
+    if (!peripheral || peripheral.state === 'disconnected')
+        return;
+    await waitForNobleCleanup(callback => peripheral.disconnect(callback));
+}
+function createNobleBlePlugin() {
+    return {
+        version: 'OneKey-CLI-Noble-1.0',
+        async init() {
+            await initializeNoble();
+        },
+        async enumerate() {
+            const devices = await scanDevices();
+            return devices.map(device => ({
+                commType: 'ble',
+                id: device.id,
+                name: device.advertisement?.localName || 'Unknown BLE Device',
+            }));
+        },
+        async connect(uuid) {
+            let peripheral = discoveredDevices.get(uuid);
+            if (!peripheral) {
+                [peripheral] = await scanDevices(uuid);
+            }
+            if (!peripheral) {
+                throw hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.DeviceNotFound, `BLE device not found: ${uuid}`);
+            }
+            await connectPeripheral(peripheral);
+            const characteristics = await discoverCharacteristics(peripheral);
+            const notificationState = createNotificationState(uuid);
+            try {
+                await subscribeNotifications(uuid, notificationState.generation, characteristics.notify);
+            }
+            catch (error) {
+                clearNotificationState(uuid, `BLE notification subscription failed: ${uuid}`);
+                throw error;
+            }
+            connectedDevices.set(uuid, peripheral);
+            deviceCharacteristics.set(uuid, characteristics);
+        },
+        async disconnect(uuid) {
+            await disconnectDevice(uuid);
+        },
+        async send(uuid, data, options) {
+            const characteristics = deviceCharacteristics.get(uuid);
+            if (!characteristics) {
+                throw hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BleCharacteristicNotFound, `BLE device is not connected: ${uuid}`);
+            }
+            const buffer = Buffer.from(data, 'hex');
+            const withoutResponse = options?.withoutResponse ?? true;
+            for (let offset = 0; offset < buffer.length; offset += BLE_PACKET_SIZE) {
+                const chunk = buffer.subarray(offset, Math.min(offset + BLE_PACKET_SIZE, buffer.length));
+                await writeCharacteristic(characteristics.write, chunk, withoutResponse);
+            }
+        },
+        async receive(uuid) {
+            const resolvedUuid = uuid ??
+                (notificationStates.size === 1 ? notificationStates.keys().next().value : undefined);
+            if (!resolvedUuid) {
+                throw hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.RuntimeError, 'BLE receive requires a device UUID when multiple devices are connected');
+            }
+            const state = notificationStates.get(resolvedUuid);
+            if (!state) {
+                throw hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.TransportNotFound, `BLE notification state not found: ${resolvedUuid}`);
+            }
+            const queued = state.queue.shift();
+            if (queued !== undefined)
+                return queued;
+            return new Promise((resolve, reject) => {
+                state.pendingReceivers.add({ resolve, reject });
+            });
+        },
+    };
+}
+exports.createNobleBlePlugin = createNobleBlePlugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hardware-cli",
-  "version": "1.2.0-alpha.2",
+  "version": "1.2.0-alpha.21",
   "description": "OneKey hardware wallet CLI for testing device communication",
   "author": "OneKey",
   "license": "Apache-2.0",
@@ -23,6 +23,7 @@
     "start": "node dist/cli.js",
     "search": "node dist/cli.js search",
     "get-features": "node dist/cli.js get-features",
+    "get-state": "node dist/cli.js get-state",
     "get-address": "node dist/cli.js get-address",
     "ping": "node dist/cli.js ping",
     "lint": "eslint .",
@@ -30,11 +31,12 @@
     "test": "jest"
   },
   "dependencies": {
-    "@onekeyfe/hd-common-connect-sdk": "1.2.0-alpha.2",
-    "@onekeyfe/hd-core": "1.2.0-alpha.2",
-    "@onekeyfe/hd-shared": "1.2.0-alpha.2",
-    "@onekeyfe/hd-transport-usb": "1.2.0-alpha.2",
+    "@onekeyfe/hd-common-connect-sdk": "1.2.0-alpha.21",
+    "@onekeyfe/hd-core": "1.2.0-alpha.21",
+    "@onekeyfe/hd-shared": "1.2.0-alpha.21",
+    "@onekeyfe/hd-transport-usb": "1.2.0-alpha.21",
+    "@stoprocent/noble": "2.3.16",
     "commander": "^12.0.0"
   },
-  "gitHead": "6c183b7f7027f4b4d3db4f427f6360351a6c6680"
+  "gitHead": "efe594367fb3b196a5126baee7e2aba3e94986cd"
 }

package/src/__tests__/cli-version.test.ts

@@ -0,0 +1,8 @@
+import packageJson from '../../package.json';
+import { program } from '../cli';
+
+describe('CLI 版本', () => {
+  test('与发布包 package.json 使用同一个版本来源', () => {
+    expect(program.version()).toBe(packageJson.version);
+  });
+});

package/src/__tests__/device-selection.test.ts

@@ -0,0 +1,29 @@
+import { selectSearchDevice } from '../deviceSelection';
+
+describe('selectSearchDevice', () => {
+  it('多设备环境优先选择显式 connectId 对应的设备', () => {
+    const devices = [
+      { connectId: 'first-device', name: 'Pro A9CA' },
+      { connectId: 'target-device', name: 'Pro2 6136' },
+    ];
+
+    expect(selectSearchDevice(devices, 'target-device')).toEqual(devices[1]);
+  });
+
+  it('未指定 connectId 时保持选择第一台设备的兼容行为', () => {
+    const devices = [
+      { connectId: 'first-device', name: 'Pro2 6136' },
+      { connectId: 'second-device', name: 'Pro2 C445' },
+    ];
+
+    expect(selectSearchDevice(devices)).toEqual(devices[0]);
+  });
+
+  it('显式 connectId 暂未出现在扫描结果时仍保留该目标', () => {
+    const devices = [{ connectId: 'other-device', name: 'Pro2 C445' }];
+
+    expect(selectSearchDevice(devices, 'target-device')).toEqual({
+      connectId: 'target-device',
+    });
+  });
+});