@onekeyfe/hardware-cli 1.2.0-alpha.1 → 1.2.0-alpha.100

package/src/deviceSelection.ts

@@ -0,0 +1,13 @@
+export function selectSearchDevice<T extends { connectId?: string | null }>(
+  devices: T[],
+  preferredConnectId?: string
+): T | undefined {
+  if (preferredConnectId) {
+    return (
+      devices.find(device => device.connectId === preferredConnectId) ??
+      ({ connectId: preferredConnectId } as T)
+    );
+  }
+
+  return devices[0];
+}

package/src/deviceStateCommands.ts

@@ -0,0 +1,71 @@
+import type { CoreApi, DeviceStateScope, KnownDevice, SearchDevice } from '@onekeyfe/hd-core';
+
+type DeviceStateSdk = Pick<CoreApi, 'searchDevices' | 'getDeviceState' | 'getFeatures'>;
+
+type DiscoveredDevice = SearchDevice & Partial<Pick<KnownDevice, 'features' | 'state'>>;
+
+const createDeviceNotFoundResult = (connectId?: string) => ({
+  success: false as const,
+  payload: {
+    code: 'DEVICE_NOT_FOUND',
+    error: connectId ? `Device not found: ${connectId}` : 'No device found',
+  },
+});
+
+const resolveSearchDevice = async (sdk: DeviceStateSdk, connectId?: string) => {
+  const searchResult = await sdk.searchDevices();
+  if (!searchResult.success) return searchResult;
+
+  const devices = searchResult.payload as DiscoveredDevice[];
+  const device = connectId ? devices.find(item => item.connectId === connectId) : devices[0];
+
+  if (!device?.connectId) return createDeviceNotFoundResult(connectId);
+  return { success: true as const, 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.
+ */
+export const getCanonicalDeviceState = async (
+  sdk: DeviceStateSdk,
+  connectId: string | undefined,
+  scope: DeviceStateScope
+) => {
+  const deviceResult = await resolveSearchDevice(sdk, connectId);
+  if (!deviceResult.success) return deviceResult;
+
+  if (scope === 'runtime' && deviceResult.payload.state) {
+    return { success: true as const, payload: deviceResult.payload.state };
+  }
+
+  const resolvedConnectId = deviceResult.payload.connectId ?? undefined;
+  if (!resolvedConnectId) return createDeviceNotFoundResult();
+  return sdk.getDeviceState(resolvedConnectId, { scope });
+};
+
+/**
+ * Legacy CLI only: retain getFeatures for V1 and reuse the discovery projection for V2.
+ * Public SDK.getFeatures remains V1-only.
+ */
+export const getCompatibleFeatures = async (sdk: DeviceStateSdk, connectId?: string) => {
+  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 as const,
+        payload: {
+          code: 'DEVICE_FEATURES_UNAVAILABLE',
+          error: 'Protocol V2 compatibility features are unavailable',
+        },
+      };
+    }
+    return { success: true as const, payload: device.features };
+  }
+
+  return sdk.getFeatures(device.connectId ?? '');
+};

package/src/pinentry.ts

@@ -73,6 +73,7 @@ export function findPinentry(): string | null {
 export interface PinentryResult {
   value: string;
   passphraseOnDevice: boolean;
+  attachPinOnDevice?: boolean;
 }
 
 // CLI-variant policy differs from app-monorepo: we fall back to on-device

package/src/sdk.ts

@@ -5,8 +5,8 @@
  * Passphrase flow aligns with app-monorepo CLI:
  *   - Standard wallet: --use-empty-passphrase, auto-respond
  *   - Hidden wallet: interactive 1/2/3 selection (standard / pinentry / on-device)
- *   - Session caching: passphraseState + sessionId stored in OS keychain,
- *     preloaded via preloadSessionCache on next invocation
+ *   - Legacy session caching: existing OS keychain entries may still be preloaded,
+ *     but public SDK responses never expose new device session ids
  */
 
 import * as readline from 'node:readline';
@@ -14,14 +14,17 @@ import HardwareSDK from '@onekeyfe/hd-common-connect-sdk';
 import { DEVICE, UI_EVENT, UI_REQUEST, UI_RESPONSE } from '@onekeyfe/hd-core';
 
 import { promptPassphraseViaPinentry } from './pinentry';
+import { createNobleBlePlugin } from './transports/nobleBlePlugin';
 
-import type { ConnectSettings } from '@onekeyfe/hd-core';
+import type { ConnectSettings, KnownDevice } from '@onekeyfe/hd-core';
 import type { PinentryResult } from './pinentry';
 
 export interface SDKOptions {
   connectId?: string;
   passphraseState?: string;
   useEmptyPassphrase?: boolean;
+  debug?: boolean;
+  transport?: 'usb' | 'ble';
 }
 
 /**
@@ -56,9 +59,15 @@ let sdkReadyPromise: Promise<typeof HardwareSDK> | null = null;
  *   2. Hidden wallet — enter passphrase via pinentry (secure OS dialog)
  *   3. Hidden wallet — enter passphrase on device screen
  */
-function resolvePassphraseByChoice(choice: '1' | '2' | '3'): Promise<PinentryResult> {
+export function resolvePassphraseByChoice(choice: '1' | '2' | '3' | '4'): Promise<PinentryResult> {
   if (choice === '1') return Promise.resolve({ value: '', passphraseOnDevice: false });
   if (choice === '2') return promptPassphraseViaPinentry();
+  if (choice === '4')
+    return Promise.resolve({
+      value: '',
+      passphraseOnDevice: false,
+      attachPinOnDevice: true,
+    });
   return Promise.resolve({ value: '', passphraseOnDevice: true });
 }
 
@@ -81,18 +90,19 @@ function promptPassphraseMode(): Promise<PinentryResult> {
           '  1. Standard wallet (no passphrase)',
           '  2. Hidden wallet — enter passphrase on this computer (pinentry)',
           '  3. Hidden wallet — enter passphrase on device screen',
+          '  4. Attach PIN wallet — enter Attach PIN on device screen',
           '',
         ].join('\n')
       );
 
       rl.question('Enter selection [1/2/3]: ', answer => {
-        const n = answer.trim() as '1' | '2' | '3';
-        if (n === '1' || n === '2' || n === '3') {
+        const n = answer.trim() as '1' | '2' | '3' | '4';
+        if (n === '1' || n === '2' || n === '3' || n === '4') {
           rl.close();
           resolvePassphraseByChoice(n).then(resolve);
           return;
         }
-        process.stderr.write('Invalid selection. Enter 1, 2, or 3.\n');
+        process.stderr.write('Invalid selection. Enter 1, 2, 3, or 4.\n');
         prompt();
       });
     };
@@ -140,6 +150,7 @@ function registerEventHandlers(sdk: typeof HardwareSDK): void {
             payload: {
               value: result.value,
               passphraseOnDevice: result.passphraseOnDevice,
+              attachPinOnDevice: result.attachPinOnDevice,
               save: false,
             },
           });
@@ -166,12 +177,12 @@ function registerEventHandlers(sdk: typeof HardwareSDK): void {
     }
   });
 
-  sdk.on(DEVICE.CONNECT, (device: any) => {
+  sdk.on(DEVICE.CONNECT, ({ device }: { device: KnownDevice }) => {
     const name = device?.label || device?.name;
     if (name) process.stderr.write(`[onekey-hw] Device connected: ${name}\n`);
   });
 
-  sdk.on(DEVICE.DISCONNECT, (device: any) => {
+  sdk.on(DEVICE.DISCONNECT, ({ device }: { device: KnownDevice }) => {
     const name = device?.label || device?.name;
     if (name) process.stderr.write(`[onekey-hw] Device disconnected: ${name}\n`);
   });
@@ -182,12 +193,17 @@ function registerEventHandlers(sdk: typeof HardwareSDK): void {
 // ---------------------------------------------------------------------------
 
 async function initSDK(): Promise<typeof HardwareSDK> {
+  const transport = currentOpts.transport ?? 'usb';
   const settings: Partial<ConnectSettings> = {
-    debug: false,
+    debug: currentOpts.debug ?? false,
     fetchConfig: true,
-    env: 'node-usb',
+    env: transport === 'ble' ? 'lowlevel' : 'node-usb',
   };
-  await HardwareSDK.init(settings);
+  await HardwareSDK.init(
+    settings,
+    undefined,
+    transport === 'ble' ? 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.
@@ -223,7 +239,7 @@ export async function disposeSDK(): Promise<void> {
   if (!sdkReadyPromise) return;
   try {
     const sdk = await sdkReadyPromise;
-    sdk.dispose();
+    await Promise.resolve(sdk.dispose());
   } catch {
     // ignore errors during cleanup
   } finally {

package/src/session.ts

@@ -1,11 +1,8 @@
 /**
  * Passphrase session management for hd-cli.
  *
- * Aligns with app-monorepo's CLI pattern:
- *   Login:   getPassphraseState → passphraseState + sessionId → keychain
- *   Command: keychain → preloadSessionCache → SDK call (no passphrase prompt)
- *   Stale:   error 112 → clear keychain → re-prompt → retry
- *   Logout:  keychain delete
+ * Existing keychain entries remain readable for compatibility, but the public
+ * SDK no longer exposes new device session ids for persistence.
  */
 
 import { preloadSessionCache } from '@onekeyfe/hd-core';
@@ -55,25 +52,6 @@ export async function preloadSessionFromKeychain(deviceId: string): Promise<stri
   return undefined;
 }
 
-/**
- * Save passphraseState + sessionId to keychain for next CLI invocation.
- */
-export async function saveSessionToKeychain(
-  deviceId: string,
-  passphraseState: string,
-  sessionId: string
-): Promise<void> {
-  try {
-    const storage = getStorage();
-    await Promise.all([
-      storage.set(psKey(deviceId), Buffer.from(passphraseState, 'utf-8')),
-      storage.set(sidKey(deviceId), Buffer.from(sessionId, 'utf-8')),
-    ]);
-  } catch {
-    // Non-fatal — session still works in-memory for this invocation
-  }
-}
-
 /**
  * Clear cached session from keychain.
  */