hardware-example 1.2.0-alpha.66 → 1.2.0-alpha.67

package/README.md

@@ -1,26 +1,5 @@
 
-# Electron Connect Example
-
-此示例使用 `@onekeyfe/hd-common-connect-sdk` 的 `desktop-web-ble` 环境，并通过 Electron
-Noble BLE Transport 连接设备。示例不再启动 OneKey Bridge，也不再注入 `hd-web-sdk` iframe。
-
-Pro2 会在真实连接响应中完成 Protocol V2 探测；应用层不要根据 BLE 名称或设备型号猜测协议。
-连接后的 SDK 调用和自动化测试沿用 `expo-example` 的 Core API，因此 V1 与 V2 共用同一套生命周期。
-
-开发运行：
-
-```bash
-yarn example:desktop
-```
-
-打包前会先构建 Electron 主进程和 Expo Web 资源：
-
-```bash
-yarn build:example:desktop:mac
-```
-
-## Q & A
-
+# Q & A
 ## The mac running message is damaged and cannot be opened. You should move it to the trash.
 ### Intel Mac
 1. Open settings
@@ -40,3 +19,4 @@ sudo /usr/bin/xattr -c /Applications/YourAppName.app
 ```bash
 sudo xattr -r -d com.apple.quarantine /Applications/YourAppName.app
 ```
+

package/electron-builder.config.js

@@ -20,7 +20,16 @@ module.exports = {
   directories: {
     output: 'out',
   },
-  files: ['web-build', 'public', 'dist/**/*.js', '!dist/__**', 'package.json', '!scripts/**'],
+  files: [
+    'web-build',
+    'public',
+    'bin',
+    '!public/bin/**/*',
+    'dist/**/*.js',
+    '!dist/__**',
+    'package.json',
+    '!scripts/**',
+  ],
   extraResources: [
     {
       from: 'public/icons/512x512.png',
@@ -51,6 +60,12 @@ module.exports = {
   mac: {
     // skip code signing
     identity: null,
+    extraResources: [
+      {
+        from: 'public/bin/bridge/mac-${arch}',
+        to: 'bin/bridge',
+      },
+    ],
     icon: 'public/icons/512x512.png',
     artifactName: 'Hardware-Example-mac-${arch}.${ext}',
     hardenedRuntime: true,
@@ -67,6 +82,12 @@ module.exports = {
     },
   },
   win: {
+    extraResources: [
+      {
+        from: 'public/bin/bridge/win-${arch}',
+        to: 'bin/bridge',
+      },
+    ],
     icon: 'public/icons/512x512.png',
     artifactName: 'Hardware-Example-win-${arch}.${ext}',
     verifyUpdateCodeSignature: false,
@@ -78,6 +99,12 @@ module.exports = {
     ],
   },
   linux: {
+    extraResources: [
+      {
+        from: 'public/bin/bridge/linux-${arch}',
+        to: 'bin/bridge',
+      },
+    ],
     icon: 'public/icons/512x512.png',
     artifactName: 'Hardware-Example-linux-${arch}.${ext}',
     executableName: 'onekey-hardware-example',

package/package.json

@@ -2,15 +2,16 @@
   "name": "hardware-example",
   "productName": "HardwareExample",
   "executableName": "onekey-hardware-example",
-  "version": "1.2.0-alpha.66",
+  "version": "1.2.0-alpha.67",
   "author": "OneKey",
-  "description": "OneKey Hardware SDK Electron BLE example",
+  "description": "End-to-end encrypted workspaces for teams",
   "main": "dist/index.js",
   "license": "GPL-3.0-only",
   "scripts": {
+    "copy:inject": "node scripts/copy-injected.js",
     "clean:build": "rimraf out",
-    "dev-electron-web": "cross-env NODE_ENV=development yarn build:main && cd ../expo-example && yarn dev:electron-web",
-    "build-electron-web": "yarn build:main && cd ../expo-example && yarn build:electron-web",
+    "dev-electron-web": "cross-env NODE_ENV=development yarn copy:inject && yarn build:main && cd ../expo-example && yarn dev:electron-web",
+    "build-electron-web": "yarn copy:inject && yarn build:main && cd ../expo-example && yarn build:electron-web",
     "dev": "npx concurrently \"yarn dev:electron\" \"cross-env TRANSFORM_REGENERATOR_DISABLED=true BROWSER=none yarn dev-electron-web\"",
     "dev:electron": "electron --inspect=5858 dist/index.js",
     "build:main": "webpack --config webpack.config.ts",
@@ -21,12 +22,14 @@
     "ts:check": "yarn tsc --noEmit"
   },
   "dependencies": {
-    "@onekeyfe/hd-transport-electron": "1.2.0-alpha.66",
+    "@onekeyfe/hd-transport-electron": "1.1.34-alpha.1",
     "@stoprocent/noble": "2.3.16",
     "debug": "4.3.4",
     "electron-is-dev": "^3.0.1",
     "electron-log": "^5.1.5",
-    "electron-updater": "^6.2.1"
+    "electron-updater": "^6.2.1",
+    "fs-extra": "^11.2.0",
+    "node-fetch": "^2.6.7"
   },
   "devDependencies": {
     "@types/webpack": "^5.28.5",
@@ -42,5 +45,5 @@
     "**/node-gyp": "^10.0.1",
     "tmp": "0.2.4"
   },
-  "gitHead": "81629c086665bb92ce4d52087ae47f084976da79"
+  "gitHead": "5fea66e8c65a1fab2ccc099b2811c8749b2487e0"
 }

package/scripts/copy-injected.js

@@ -0,0 +1,38 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+const fs = require('fs-extra');
+const path = require('path');
+
+const rootDir = path.join(__dirname, '../../../../');
+
+const sourceDir = path.join(rootDir, 'node_modules/@onekeyfe/hd-web-sdk/build/');
+const targetDir = path.join(rootDir, 'packages/connect-examples/electron-example/public/js-sdk/');
+
+async function copyFiles() {
+  try {
+    await fs.remove(targetDir);
+    await fs.ensureDir(targetDir);
+    console.log(`Target directory ${targetDir} is ensured`);
+
+    await fs.copy(sourceDir, targetDir, {
+      recursive: true,
+      overwrite: true,
+      filter: (src, dest) => {
+        // Don't copy onekey-js-sdk
+        if (src.endsWith('onekey-js-sdk.min.js') || src.endsWith('onekey-js-sdk.js')) {
+          return false;
+        }
+
+        // Don't copy source maps
+        if (src.endsWith('.map')) {
+          return false;
+        }
+        return true;
+      },
+    });
+    console.log(`Files copied from ${sourceDir} to ${targetDir}`);
+  } catch (error) {
+    console.error('Error copying files:', error);
+  }
+}
+
+copyFiles();

package/src/config.ts

@@ -4,5 +4,9 @@ export const ipcMessageKeys = {
   UPDATE_DOWNLOADED: 'update/downloaded',
   UPDATE_RESTART: 'update/restartApp',
 
+  APP_RELOAD_BRIDGE_PROCESS: 'app/reloadBridgeProcess',
+
+  INJECT_ONEKEY_DESKTOP_GLOBALS: 'inject/onekeyDesktop',
+
   APP_RESTART: 'app/restart',
 };

package/src/index.ts

@@ -7,6 +7,7 @@ import { autoUpdater } from 'electron-updater';
 import { exec } from 'child_process';
 import { initNobleBleSupport } from '@onekeyfe/hd-transport-electron';
 
+import initProcess, { restartBridge } from './process';
 import { ipcMessageKeys } from './config';
 
 // Set log level
@@ -23,6 +24,21 @@ let mainWindow: BrowserWindow | null;
 
 let isAppReady = false;
 
+(global as any).resourcesPath = isDevelopment
+  ? path.join(__dirname, '../public')
+  : path.join(process.resourcesPath, 'app');
+const staticPath = isDevelopment
+  ? path.join(__dirname, '../public')
+  : path.join((global as any).resourcesPath, 'public');
+
+const sdkConnectSrc = isDevelopment
+  ? `file://${path.join(staticPath, 'js-sdk/')}`
+  : path.join('public', 'js-sdk/');
+
+function initChildProcess() {
+  return initProcess({ isDevelopment });
+}
+
 function showMainWindow() {
   if (!mainWindow) {
     return;
@@ -64,11 +80,13 @@ function createMainWindow() {
     height: Math.min(1920 / ratio, dimensions.height),
     webPreferences: {
       spellcheck: false,
+      webviewTag: true,
       webSecurity: !isDevelopment,
       // @ts-expect-error
       nativeWindowOpen: true,
       allowRunningInsecureContent: isDevelopment,
-      contextIsolation: true,
+      // webview injected js needs isolation=false, because property can not be exposeInMainWorld() when isolation enabled.
+      contextIsolation: false,
       preload: path.join(__dirname, 'preload.js'),
       sandbox: false,
     },
@@ -78,6 +96,15 @@ function createMainWindow() {
     browserWindow.webContents.openDevTools();
   }
 
+  browserWindow.webContents.on('did-finish-load', () => {
+    console.log('browserWindow >>>> did-finish-load');
+    browserWindow.webContents.send(ipcMessageKeys.INJECT_ONEKEY_DESKTOP_GLOBALS, {
+      resourcesPath: (global as any).resourcesPath,
+      staticPath: `file://${staticPath}`,
+      sdkConnectSrc,
+    });
+  });
+
   const src = isDevelopment
     ? 'http://localhost:19006/'
     : formatUrl({
@@ -107,9 +134,25 @@ function createMainWindow() {
     console.log('set isAppReady on browserWindow dom-ready', isAppReady);
   });
 
+  const filter = {
+    urls: ['http://127.0.0.1:21320/*', 'http://localhost:21320/*'],
+  };
+
+  session.defaultSession.webRequest.onBeforeSendHeaders(filter, (details, callback) => {
+    const { url } = details;
+    if (url.startsWith('http://127.0.0.1:21320/') || url.startsWith('http://localhost:21320/')) {
+      // resolve onekey bridge CORS error
+      details.requestHeaders.Origin = 'https://jssdk.onekey.so';
+    }
+
+    callback({ cancel: false, requestHeaders: details.requestHeaders });
+  });
+
   // 记录已授权的设备
+  let grantedDeviceThroughPermHandler = null;
+
   browserWindow.webContents.session.setPermissionCheckHandler(
-    (_webContents, permission, requestingOrigin, details) => {
+    (webContents, permission, requestingOrigin, details) => {
       log.debug('WebUSB: 权限检查被调用:', {
         permission,
         requestingOrigin,
@@ -134,6 +177,7 @@ function createMainWindow() {
     // 允许所有 USB 设备请求
     if (details.deviceType === 'usb') {
       log.debug('WebUSB: 记录已授权的设备');
+      grantedDeviceThroughPermHandler = details.device;
       return true;
     }
     return false;
@@ -169,6 +213,24 @@ function createMainWindow() {
   if (!isDevelopment) {
     const PROTOCOL = 'file';
     session.defaultSession.protocol.interceptFileProtocol(PROTOCOL, (request, callback) => {
+      const isJsSdkFile = request.url.indexOf('/public/js-sdk') > -1;
+      const isIFrameHtml = request.url.indexOf('/public/js-sdk/iframe.html') > -1;
+
+      // resolve iframe path
+      if (isJsSdkFile && isIFrameHtml) {
+        callback({
+          path: path.join(__dirname, '..', 'public', 'js-sdk', 'iframe.html'),
+        });
+        return;
+      }
+
+      // resolve jssdk path
+      if (isJsSdkFile) {
+        const url = request.url.substr(PROTOCOL.length + 1);
+        callback(path.join(__dirname, '..', url));
+        return;
+      }
+
       // resolve main app path
       let url = request.url.substr(PROTOCOL.length + 1);
       url = path.join(__dirname, '..', 'web-build', url);
@@ -209,7 +271,7 @@ const singleInstance = app.requestSingleInstanceLock();
 if (!singleInstance && !process.mas) {
   quitOrMinimizeApp();
 } else {
-  app.on('second-instance', (_event, _argv) => {
+  app.on('second-instance', (e, argv) => {
     if (mainWindow) {
       if (mainWindow.isMinimized()) mainWindow.restore();
       showMainWindow();
@@ -230,6 +292,7 @@ if (!singleInstance && !process.mas) {
       log.error('Failed to initialize Noble BLE support:', e);
     }
 
+    initChildProcess();
     showMainWindow();
     console.log('日志文件位置:', log.transports.file.getFile().path);
   });
@@ -240,6 +303,10 @@ ipcMain.on(ipcMessageKeys.UPDATE_RESTART, () => {
   autoUpdater.quitAndInstall();
 });
 
+ipcMain.on(ipcMessageKeys.APP_RELOAD_BRIDGE_PROCESS, () => {
+  restartBridge();
+});
+
 // Simplified Bluetooth System API Implementation
 class BluetoothSystemManager {
   openBluetoothSettings(): void {

package/src/preload.ts

@@ -17,6 +17,7 @@ export interface BluetoothSystemAPI {
 // Extend the base DesktopAPI with this specific application's needs
 export interface DesktopAPI extends BaseDesktopAPI {
   restart: () => void;
+  reloadBridgeProcess: () => void;
 
   // Generic IPC methods
   invoke: (channel: string, ...args: any[]) => Promise<any>;
@@ -43,6 +44,17 @@ const validChannels = [
   ipcMessageKeys.UPDATE_DOWNLOADED,
 ];
 
+ipcRenderer.on(ipcMessageKeys.INJECT_ONEKEY_DESKTOP_GLOBALS, (_, globals) => {
+  try {
+    contextBridge.exposeInMainWorld('ONEKEY_DESKTOP_GLOBALS', globals);
+  } catch (error) {
+    // @ts-expect-error
+    window.ONEKEY_DESKTOP_GLOBALS = globals;
+    // Fallback for development or when contextBridge is not available
+    console.warn('Failed to expose ONEKEY_DESKTOP_GLOBALS via contextBridge:', error);
+  }
+});
+
 const desktopApi = {
   // Generic IPC methods
   invoke: (channel: string, ...args: any[]) => ipcRenderer.invoke(channel, ...args),
@@ -63,6 +75,10 @@ const desktopApi = {
   updateReload: () => {
     ipcRenderer.send(ipcMessageKeys.UPDATE_RESTART);
   },
+  reloadBridgeProcess: () => {
+    ipcRenderer.send(ipcMessageKeys.APP_RELOAD_BRIDGE_PROCESS);
+  },
+
   // Noble BLE specific methods
   nobleBle: {
     enumerate: () => ipcRenderer.invoke(EOneKeyBleMessageKeys.NOBLE_BLE_ENUMERATE),

package/src/process/BaseProcess.ts

@@ -0,0 +1,212 @@
+import { spawn } from 'child_process';
+import electron from 'electron';
+import path from 'path';
+
+import type { ChildProcess } from 'child_process';
+
+export type Status = {
+  service: boolean;
+  process: boolean;
+};
+
+export type Options = {
+  startupThrottleTime?: number;
+  stopWaitTimes?: number;
+  autoRestart?: number;
+};
+
+const defaultOptions: Options = {
+  startupThrottleTime: 0,
+  stopWaitTimes: 10,
+  autoRestart: 2,
+} as const;
+
+export default abstract class BaseProcess {
+  process: ChildProcess | null;
+
+  resource: string;
+
+  processName: string;
+
+  options: Options;
+
+  launchThrottle: ReturnType<typeof setTimeout> | null;
+
+  supportedSystems = ['mac-x64', 'win-x64', 'linux-arm64', 'linux-x64'];
+
+  stopped = false;
+
+  constructor(resource: string, processName: string, options: Options = defaultOptions) {
+    this.process = null;
+    this.launchThrottle = null;
+    this.resource = resource;
+    this.processName = processName;
+    this.options = {
+      ...defaultOptions,
+      ...options,
+    };
+
+    const { system } = this.getPlatformInfo();
+    if (!this.isSystemSupported(system)) {
+      console.error('Unsupported system:', system);
+    }
+  }
+
+  abstract getStatus(): Promise<{ service: boolean; process: boolean }>;
+
+  async start(params: string[] = [], isDev = false) {
+    const { system, ext } = this.getPlatformInfo();
+    if (this.launchThrottle) {
+      console.debug('Throttling launch, cancel process');
+      return;
+    }
+
+    const status = await this.getStatus();
+
+    if (status.service) {
+      console.debug('Service already running');
+      return;
+    }
+
+    if (status.process) {
+      console.debug('Process already running, service not');
+      return;
+    }
+
+    if (this.options.startupThrottleTime && this.options.startupThrottleTime > 0) {
+      console.debug('Throttling startup');
+
+      this.launchThrottle = setTimeout(() => {
+        console.debug('Cleaning up launch throttle');
+        this.launchThrottle = null;
+      }, this.options.startupThrottleTime * 1000);
+    }
+
+    this.stopped = false;
+
+    const appPath = electron.app.getAppPath();
+    let processDir;
+    if (isDev) {
+      processDir = path.resolve(appPath, '../', 'public', 'bin', this.resource, system);
+    } else {
+      processDir = path.resolve(appPath, '../', 'bin', this.resource);
+    }
+
+    const processPath = path.join(processDir, `${this.processName}${ext}`);
+    const processEnv = { ...process.env };
+    // library search path for macOS
+    processEnv.DYLD_LIBRARY_PATH = processEnv.DYLD_LIBRARY_PATH
+      ? `${processEnv.DYLD_LIBRARY_PATH}:${processDir}`
+      : `${processDir}`;
+    // library search path for Linux
+    processEnv.LD_LIBRARY_PATH = processEnv.LD_LIBRARY_PATH
+      ? `${processEnv.LD_LIBRARY_PATH}:${processDir}`
+      : `${processDir}`;
+
+    console.info([
+      'Starting process:',
+      `- Path: ${processPath}`,
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      `- Params: ${params}`,
+      `- CWD: ${processDir}`,
+    ]);
+    this.process = spawn(processPath, params, {
+      cwd: processDir,
+      env: processEnv,
+      stdio: ['ignore', 'ignore', 'ignore'],
+    });
+    this.process.on('error', err => this.onError(err));
+    this.process.on('exit', code => this.onExit(code));
+  }
+
+  /**
+   * Stops the process
+   */
+  stop() {
+    return new Promise<void>(resolve => {
+      this.stopped = true;
+
+      if (!this.process) {
+        console.warn('process already stopped');
+        resolve();
+        return;
+      }
+
+      console.debug('Stopping process');
+      this.process.kill();
+
+      let timeout = 0;
+      const interval = setInterval(() => {
+        if (!this.process || this.process.killed) {
+          console.info('Process killed successfully');
+          clearInterval(interval);
+          this.process = null;
+          resolve();
+          return;
+        }
+
+        if (this.options.stopWaitTimes && timeout < this.options.stopWaitTimes) {
+          console.info('Process Still alive, checking again...');
+          timeout += 1;
+        } else {
+          console.info('Process Still alive, going for the SIGKILL');
+          this.process.kill('SIGKILL');
+        }
+      }, 1000);
+    });
+  }
+
+  async restart() {
+    console.info('Restarting');
+    await this.stop();
+    await this.start();
+  }
+
+  onError(err: Error) {
+    console.error('Process exit error: ', err.message);
+  }
+
+  onExit(code: number | null) {
+    console.info(
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      `Exited, code: ${code ?? 'unknown'} (Stopped: ${this.stopped})`
+    );
+    this.process = null;
+
+    if (this.options.autoRestart && this.options.autoRestart > 0 && !this.stopped) {
+      console.debug('restarting...');
+      let restartDelay = this.options.autoRestart;
+
+      // Add throttle delay to prevent the process from never restarting if the throttle is hit
+      if (this.launchThrottle && this.options.startupThrottleTime) {
+        restartDelay += this.options.startupThrottleTime;
+      }
+
+      setTimeout(() => this.start(), restartDelay * 1000);
+    }
+  }
+
+  isSystemSupported(system: string) {
+    return this.supportedSystems.includes(system);
+  }
+
+  getPlatformInfo() {
+    const { arch } = process;
+    const platform = this.getPlatform();
+    const ext = platform === 'win' ? '.exe' : '';
+    const system = `${platform}-${arch}`;
+    console.debug('arch: ', arch);
+    return { system, platform, arch, ext };
+  }
+
+  getPlatform() {
+    switch (process.platform) {
+      case 'darwin':
+        return 'mac';
+      case 'win32':
+        return 'win';
+      default:
+        return process.platform;
+    }
+  }
+}

package/src/process/Bridge.ts

@@ -0,0 +1,93 @@
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+import fetch from 'node-fetch';
+
+import BaseProcess from './BaseProcess';
+
+import type { Status } from './BaseProcess';
+
+class BridgeProcess extends BaseProcess {
+  constructor() {
+    super('bridge', 'onekeyd', {
+      startupThrottleTime: 3,
+    });
+    console.info('logger file name =====> :');
+  }
+
+  async getStatus(): Promise<Status> {
+    try {
+      const resp = await fetch(`http://127.0.0.1:21320/`, {
+        method: 'POST',
+        headers: {
+          Origin: 'https://electron.onekey.so',
+        },
+      });
+      console.debug(`Checking status (${resp.status})`);
+      if (resp.status === 200) {
+        const data = await resp.json();
+        if (data?.version) {
+          return {
+            service: true,
+            process: true,
+          };
+        }
+      }
+    } catch (err: any) {
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      console.error(`Status error: ${err.message}`);
+    }
+
+    // process
+    return {
+      service: false,
+      process: Boolean(this.process),
+    };
+  }
+}
+
+async function fetchWithTimeout(url: string, options: RequestInit & { timeout: number }) {
+  const { timeout = 3000 } = options;
+
+  const controller = new AbortController();
+  const id = setTimeout(() => controller.abort(), timeout);
+  // @ts-expect-error
+  const response = await fetch(url, {
+    ...options,
+    signal: controller.signal as any,
+  });
+  clearTimeout(id);
+  return response;
+}
+
+export const BridgeHeart = {
+  timer: null as ReturnType<typeof setInterval> | null,
+  start: (callback: () => void) => {
+    const checkBridge = async () => {
+      try {
+        const localBridgeUrl = 'http://127.0.0.1:21320/';
+        const resp = await fetchWithTimeout(localBridgeUrl, {
+          method: 'POST',
+          headers: {
+            Origin: 'https://electron.onekey.so',
+          },
+          timeout: 3000,
+        });
+
+        if (resp.status !== 200) {
+          console.debug(`Bridge Heart Checking ${localBridgeUrl} (${resp.status})`);
+          // check bridge failed, restart it
+          callback?.();
+        }
+      } catch (err: any) {
+        console.error(
+          // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+          `Bridge heart check error, will restart bridge process: ${err.message}`
+        );
+        callback?.();
+      }
+    };
+
+    BridgeHeart.timer = setInterval(checkBridge, 10000);
+  },
+};
+
+export default BridgeProcess;

package/src/process/index.ts

@@ -0,0 +1,36 @@
+import { app } from 'electron';
+
+import BridgeProcess, { BridgeHeart } from './Bridge';
+
+let bridgeInstance: BridgeProcess;
+export const launchBridge = async (isDevelopment: boolean) => {
+  const bridge = new BridgeProcess();
+
+  try {
+    console.info('bridge: Staring');
+    await bridge.start([], isDevelopment);
+    bridgeInstance = bridge;
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    BridgeHeart.start(() => restartBridge());
+  } catch (err) {
+    console.error(`bridge: Start failed: ${(err as Error).message}`);
+    console.error(err);
+  }
+
+  app.on('before-quit', () => {
+    console.info('bridge', 'Stopping when app quit');
+    bridge.stop();
+  });
+};
+
+export const restartBridge = async () => {
+  console.debug('bridge: ', 'Restarting');
+  await bridgeInstance?.restart();
+};
+
+const init = async ({ isDevelopment }: { isDevelopment: boolean }) => {
+  console.info('Electron main process log path: ');
+  await launchBridge(isDevelopment);
+};
+
+export default init;