onekey-electron-demo 1.1.26-alpha.30

package/README.md

@@ -0,0 +1,22 @@
+
+# Q & A
+## The mac running message is damaged and cannot be opened. You should move it to the trash.
+### Intel Mac
+1. Open settings
+2. Security & Privacy
+3. Security
+4. Allow apps downloaded from: App Store and identified developers
+5. Open the app again
+
+### Apple Silicon Mac
+1. Open terminal
+2. Run the following command
+```bash
+sudo /usr/bin/xattr -c /Applications/YourAppName.app
+```
+
+### If the above command does not work, try the following command
+```bash
+sudo xattr -r -d com.apple.quarantine /Applications/YourAppName.app
+```
+

package/electron-builder.config.js

@@ -0,0 +1,123 @@
+/* eslint-disable no-template-curly-in-string */
+// eslint-disable-next-line import/no-import-module-exports, @typescript-eslint/no-var-requires
+const { version } = require('./package.json');
+
+module.exports = {
+  extraMetadata: {
+    main: 'dist/index.js',
+    version,
+  },
+  appId: 'so.onekey.example.hardware-desktop',
+  productName: 'HardwareExample',
+  copyright: 'Copyright © OeKey 2024',
+  asar: true,
+  // Unpack native modules so they can be loaded at runtime
+  asarUnpack: [
+    'node_modules/@stoprocent/noble/**',
+    'node_modules/@stoprocent/bluetooth-hci-socket/**',
+  ],
+  buildVersion: version,
+  directories: {
+    output: 'out',
+  },
+  files: [
+    'web-build',
+    'public',
+    'bin',
+    '!public/bin/**/*',
+    'dist/**/*.js',
+    '!dist/__**',
+    'package.json',
+    '!scripts/**',
+  ],
+  extraResources: [
+    {
+      from: 'public/icons/512x512.png',
+      to: 'icons/512x512.png',
+    },
+  ],
+  dmg: {
+    sign: false,
+    contents: [
+      {
+        x: 410,
+        y: 175,
+        type: 'link',
+        path: '/Applications',
+      },
+      {
+        x: 130,
+        y: 175,
+        type: 'file',
+      },
+    ],
+    background: 'public/icons/background.png',
+  },
+  nsis: {
+    oneClick: false,
+    installerSidebar: 'public/icons/installerSidebar.bmp',
+  },
+  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,
+    gatekeeperAssess: false,
+    darkModeSupport: false,
+    category: 'productivity',
+    target: [
+      { target: 'dmg', arch: ['x64', 'arm64'] },
+      // { target: 'zip', arch: ['x64', 'arm64'] },
+    ],
+    entitlements: 'entitlements.mac.plist',
+    extendInfo: {
+      NSCameraUsageDescription: 'Please allow OneKey to use your camera',
+    },
+  },
+  win: {
+    extraResources: [
+      {
+        from: 'public/bin/bridge/win-${arch}',
+        to: 'bin/bridge',
+      },
+    ],
+    icon: 'public/icons/512x512.png',
+    artifactName: 'Hardware-Example-win-${arch}.${ext}',
+    verifyUpdateCodeSignature: false,
+    target: [
+      {
+        target: 'nsis',
+        arch: ['x64'],
+      },
+    ],
+  },
+  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',
+    category: 'Utility',
+    target: ['AppImage'],
+  },
+  publish: [
+    {
+      provider: 'github',
+      owner: 'OneKeyHQ',
+      repo: 'hardware-js-sdk',
+      private: false,
+      vPrefixedTagName: true,
+    },
+  ],
+};

package/entitlements.mac.plist

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>com.apple.security.cs.allow-jit</key>
+    <true/>
+    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
+    <true/>
+  </dict>
+</plist>

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "onekey-electron-demo",
+  "productName": "OneKey Electron Demo",
+  "executableName": "onekey-electron-demo",
+  "version": "1.1.26-alpha.30",
+  "author": "OneKey",
+  "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 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",
+    "rebuild:deps": "electron-builder install-app-deps",
+    "make:mac": "yarn rebuild:deps && yarn clean:build && yarn build-electron-web && electron-builder build --mac --config electron-builder.config.js --publish always",
+    "make:win": "yarn rebuild:deps && yarn clean:build && yarn build-electron-web && electron-builder build --win --config electron-builder.config.js --publish always",
+    "lint": "eslint --ext .tsx --ext .ts ./",
+    "ts:check": "yarn tsc --noEmit"
+  },
+  "dependencies": {
+    "@onekeyfe/hd-transport-electron": "1.1.26-alpha.30",
+    "@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",
+    "fs-extra": "^11.2.0",
+    "node-fetch": "^2.6.7"
+  },
+  "devDependencies": {
+    "@types/webpack": "^5.28.5",
+    "@types/webpack-node-externals": "^3.0.4",
+    "clean-webpack-plugin": "^4.0.0",
+    "cross-env": "^7.0.3",
+    "electron": "^40.1.0",
+    "electron-builder": "^24.9.1",
+    "webpack": "^5.90.2",
+    "webpack-node-externals": "^3.0.0"
+  },
+  "resolutions": {
+    "**/node-gyp": "^10.0.1",
+    "tmp": "0.2.4"
+  },
+  "gitHead": "88ec305cb60347e09cf9e0c8e921d414f7fe3656"
+}

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

@@ -0,0 +1,12 @@
+export const ipcMessageKeys = {
+  // Updater
+  UPDATE_AVAILABLE: 'update/available',
+  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

@@ -0,0 +1,400 @@
+import { BrowserWindow, app, ipcMain, screen, session, shell } from 'electron';
+import path from 'path';
+import isDevelopment from 'electron-is-dev';
+import { format as formatUrl } from 'url';
+import log from 'electron-log';
+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
+log.transports.file.level = 'info';
+log.transports.console.level = 'info';
+autoUpdater.logger = log;
+
+const isMac = process.platform === 'darwin';
+const isWin = process.platform === 'win32';
+
+const APP_NAME = 'OneKey Electron Demo';
+app.name = APP_NAME;
+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;
+  }
+  mainWindow.show();
+  mainWindow.focus();
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function quitOrMinimizeApp(event?: Event) {
+  // On OS X it is common for applications and their menu bar
+  // to stay active until the user quits explicitly with Cmd + Q
+  if (isMac) {
+    // **** renderer app will reload after minimize, and keytar not working.
+    event?.preventDefault();
+    if (!mainWindow?.isDestroyed()) {
+      mainWindow?.hide();
+    }
+    // ****
+    // app.quit();
+  } else {
+    app.quit();
+  }
+}
+
+function createMainWindow() {
+  const display = screen.getPrimaryDisplay();
+  const dimensions = display.workAreaSize;
+  const ratio = 16 / 9;
+
+  const browserWindow = new BrowserWindow({
+    title: APP_NAME,
+    titleBarStyle: isWin ? 'default' : 'hidden',
+    trafficLightPosition: { x: 20, y: 12 },
+    autoHideMenuBar: true,
+    frame: true,
+    resizable: true,
+    width: Math.min(1920, dimensions.width),
+    height: Math.min(1920 / ratio, dimensions.height),
+    webPreferences: {
+      spellcheck: false,
+      webviewTag: true,
+      webSecurity: !isDevelopment,
+      // @ts-expect-error
+      nativeWindowOpen: true,
+      allowRunningInsecureContent: isDevelopment,
+      // 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,
+    },
+  });
+
+  if (isDevelopment) {
+    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({
+        pathname: 'index.html',
+        protocol: 'file',
+        slashes: true,
+      });
+
+  browserWindow.loadURL(src);
+
+  browserWindow.on('closed', () => {
+    mainWindow = null;
+    isAppReady = false;
+    console.log('set isAppReady on browserWindow closed', isAppReady);
+  });
+
+  browserWindow.webContents.on('devtools-opened', () => {
+    browserWindow.focus();
+    setImmediate(() => {
+      browserWindow.focus();
+    });
+  });
+
+  // dom-ready is fired after ipcMain:app/ready
+  browserWindow.webContents.on('dom-ready', () => {
+    isAppReady = true;
+    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) => {
+      log.debug('WebUSB: 权限检查被调用:', {
+        permission,
+        requestingOrigin,
+        details: JSON.stringify(details, null, 2),
+      });
+
+      // 允许所有 USB 权限请求
+      if (permission === 'usb') {
+        return true;
+      }
+      return false;
+    }
+  );
+
+  browserWindow.webContents.session.setDevicePermissionHandler(details => {
+    log.debug('WebUSB: 设备权限请求被调用:', {
+      deviceType: details.deviceType,
+      origin: details.origin,
+      device: JSON.stringify(details, null, 2),
+    });
+
+    // 允许所有 USB 设备请求
+    if (details.deviceType === 'usb') {
+      log.debug('WebUSB: 记录已授权的设备');
+      grantedDeviceThroughPermHandler = details.device;
+      return true;
+    }
+    return false;
+  });
+
+  browserWindow.webContents.session.setUSBProtectedClassesHandler(details =>
+    details.protectedClasses.filter(
+      usbClass =>
+        // Exclude classes except for audio classes
+        usbClass.indexOf('audio') === -1
+    )
+  );
+
+  // 添加设备选择处理程序
+  browserWindow.webContents.session.on('select-usb-device', (event, details, callback) => {
+    log.debug('WebUSB: select-usb-device 事件触发');
+    log.debug('WebUSB: 可用设备列表:', JSON.stringify(details.deviceList, null, 2));
+
+    // 阻止默认行为，以便我们可以自动选择设备
+    // 这是 Electron 的优势：不像浏览器必须显示弹窗，桌面应用可以自动化处理
+    event.preventDefault();
+
+    // 直接选择第一个设备
+    if (details.deviceList && details.deviceList.length > 0) {
+      console.debug(`WebUSB: 选择了第一个设备:`, JSON.stringify(details.deviceList[0], null, 2));
+      callback(details.deviceList[0].deviceId);
+    } else {
+      console.debug('WebUSB: 没有设备可选择，返回空');
+      callback();
+    }
+  });
+
+  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);
+      callback(url);
+    });
+
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    browserWindow.webContents.on('did-fail-load', (_, __, ___, validatedURL) => {
+      const redirectPath = validatedURL.replace(`${PROTOCOL}://`, '');
+      if (validatedURL.startsWith(PROTOCOL) && !redirectPath.includes('.')) {
+        browserWindow.loadURL(src);
+      }
+    });
+  }
+
+  // @ts-expect-error
+  browserWindow.on('close', (event: Event) => {
+    // hide() instead of close() on MAC
+    if (isMac) {
+      event.preventDefault();
+      if (!browserWindow.isDestroyed()) {
+        browserWindow.blur();
+        browserWindow.hide(); // hide window only
+        // browserWindow.minimize(); // hide window and minimize to Docker
+      }
+    }
+  });
+
+  ipcMain.on(ipcMessageKeys.APP_RESTART, () => {
+    browserWindow?.reload();
+  });
+
+  return browserWindow;
+}
+
+const singleInstance = app.requestSingleInstanceLock();
+
+if (!singleInstance && !process.mas) {
+  quitOrMinimizeApp();
+} else {
+  app.on('second-instance', (e, argv) => {
+    if (mainWindow) {
+      if (mainWindow.isMinimized()) mainWindow.restore();
+      showMainWindow();
+    }
+  });
+
+  app.name = APP_NAME;
+  app.on('ready', () => {
+    if (!mainWindow) {
+      mainWindow = createMainWindow();
+    }
+
+    try {
+      log.info('Initializing Noble BLE support...');
+      initNobleBleSupport(mainWindow.webContents);
+      log.info('Noble BLE support initialized successfully.');
+    } catch (e) {
+      log.error('Failed to initialize Noble BLE support:', e);
+    }
+
+    initChildProcess();
+    showMainWindow();
+    console.log('日志文件位置:', log.transports.file.getFile().path);
+  });
+}
+
+ipcMain.on(ipcMessageKeys.UPDATE_RESTART, () => {
+  log.info('App Quit And Install');
+  autoUpdater.quitAndInstall();
+});
+
+ipcMain.on(ipcMessageKeys.APP_RELOAD_BRIDGE_PROCESS, () => {
+  restartBridge();
+});
+
+// Simplified Bluetooth System API Implementation
+class BluetoothSystemManager {
+  openBluetoothSettings(): void {
+    try {
+      if (process.platform === 'darwin') {
+        exec('open "/System/Library/PreferencePanes/Bluetooth.prefPane"');
+      } else if (process.platform === 'win32') {
+        shell.openExternal('ms-settings:bluetooth');
+      } else {
+        log.warn('Opening Bluetooth settings not supported on this platform');
+      }
+    } catch (error) {
+      log.error('Failed to open Bluetooth settings:', error);
+    }
+  }
+
+  openPrivacySettings(): void {
+    try {
+      if (process.platform === 'darwin') {
+        exec('open "x-apple.systempreferences:com.apple.preference.security?Privacy_Bluetooth"');
+      } else if (process.platform === 'win32') {
+        shell.openExternal('ms-settings:privacy-bluetooth');
+      } else {
+        log.warn('Opening privacy settings not supported on this platform');
+      }
+    } catch (error) {
+      log.error('Failed to open privacy settings:', error);
+    }
+  }
+}
+
+// Create global instance
+const bluetoothManager = new BluetoothSystemManager();
+
+// Register simplified IPC handlers for Bluetooth system API
+ipcMain.handle('bluetooth-open-bluetooth-settings', () => {
+  bluetoothManager.openBluetoothSettings();
+});
+
+ipcMain.handle('bluetooth-open-privacy-settings', () => {
+  bluetoothManager.openPrivacySettings();
+});
+
+// 配置 GitHub 发布提供者
+autoUpdater.setFeedURL({
+  provider: 'github',
+  owner: 'OneKeyHQ',
+  repo: 'hardware-js-sdk',
+  private: false,
+  releaseType: 'release',
+});
+
+// 检查更新
+app.on('ready', () => {
+  autoUpdater.on('update-available', () => {
+    log.info('Update available.');
+    mainWindow?.webContents?.send(ipcMessageKeys.UPDATE_AVAILABLE);
+  });
+
+  autoUpdater.on('update-downloaded', () => {
+    log.info('Update downloaded.');
+    mainWindow?.webContents?.send(ipcMessageKeys.UPDATE_DOWNLOADED);
+  });
+
+  setTimeout(() => {
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    autoUpdater.checkForUpdatesAndNotify();
+  }, 5000);
+});
+
+// quit when all windows are closed, except on macOS. There, it's common
+// for applications and their menu bar to stay active until the user quits
+// explicitly with Cmd + Q
+app.on('window-all-closed', (event: Event) => {
+  quitOrMinimizeApp(event);
+});
+
+app.on('activate', () => {
+  if (!mainWindow) {
+    mainWindow = createMainWindow();
+  }
+  showMainWindow();
+});
+
+app.on('before-quit', () => {
+  if (mainWindow) {
+    mainWindow?.removeAllListeners();
+    mainWindow?.removeAllListeners('close');
+    mainWindow?.close();
+  }
+});

package/src/preload.ts

@@ -0,0 +1,133 @@
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-unused-vars,@typescript-eslint/require-await */
+import { contextBridge, ipcRenderer } from 'electron';
+import { EOneKeyBleMessageKeys } from '@onekeyfe/hd-shared';
+
+import { ipcMessageKeys } from './config';
+
+import type { DesktopAPI as BaseDesktopAPI, NobleBleAPI } from '@onekeyfe/hd-transport-electron';
+
+// Simplified Bluetooth system API - only for opening settings
+export interface BluetoothSystemAPI {
+  // System integration
+  openBluetoothSettings: () => void;
+  openPrivacySettings: () => void;
+}
+
+// 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>;
+  on: (channel: string, callback: (...args: any[]) => void) => () => void;
+  off?: (channel: string, callback?: (...args: any[]) => void) => void;
+
+  // Make nobleBle required for this app
+  nobleBle: NobleBleAPI;
+
+  // Simplified Bluetooth system management
+  bluetoothSystem: BluetoothSystemAPI;
+}
+
+declare global {
+  interface Window {
+    desktopApi: DesktopAPI;
+    INJECT_PATH: string;
+  }
+}
+
+const validChannels = [
+  // Update events
+  ipcMessageKeys.UPDATE_AVAILABLE,
+  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),
+  on: (channel: string, func: (...args: any[]) => any) => {
+    if (validChannels.includes(channel)) {
+      ipcRenderer.on(channel, (_, ...args) => func(...args));
+    }
+    // For other channels, set up listener and return cleanup function
+    const listener = (_: any, ...args: any[]) => func(...args);
+    ipcRenderer.on(channel, listener);
+    return () => {
+      ipcRenderer.removeListener(channel, listener);
+    };
+  },
+  restart: () => {
+    ipcRenderer.send(ipcMessageKeys.APP_RESTART);
+  },
+  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),
+    getDevice: (uuid: string) =>
+      ipcRenderer.invoke(EOneKeyBleMessageKeys.NOBLE_BLE_GET_DEVICE, uuid),
+    connect: (uuid: string) => ipcRenderer.invoke(EOneKeyBleMessageKeys.NOBLE_BLE_CONNECT, uuid),
+    disconnect: (uuid: string) =>
+      ipcRenderer.invoke(EOneKeyBleMessageKeys.NOBLE_BLE_DISCONNECT, uuid),
+    subscribe: (uuid: string) =>
+      ipcRenderer.invoke(EOneKeyBleMessageKeys.NOBLE_BLE_SUBSCRIBE, uuid),
+    unsubscribe: (uuid: string) =>
+      ipcRenderer.invoke(EOneKeyBleMessageKeys.NOBLE_BLE_UNSUBSCRIBE, uuid),
+    write: (uuid: string, data: string) =>
+      ipcRenderer.invoke(EOneKeyBleMessageKeys.NOBLE_BLE_WRITE, uuid, data),
+    onNotification: (callback: (deviceId: string, data: string) => void) => {
+      const subscription = (_: unknown, deviceId: string, data: string) => {
+        callback(deviceId, data);
+      };
+      ipcRenderer.on(EOneKeyBleMessageKeys.NOBLE_BLE_NOTIFICATION, subscription);
+      return () => {
+        ipcRenderer.removeListener(EOneKeyBleMessageKeys.NOBLE_BLE_NOTIFICATION, subscription);
+      };
+    },
+    onDeviceDisconnected: (callback: (device: { id: string; name: string }) => void) => {
+      const subscription = (_: unknown, device: { id: string; name: string }) => {
+        callback(device);
+      };
+      ipcRenderer.on(EOneKeyBleMessageKeys.BLE_DEVICE_DISCONNECTED, subscription);
+      return () => {
+        ipcRenderer.removeListener(EOneKeyBleMessageKeys.BLE_DEVICE_DISCONNECTED, subscription);
+      };
+    },
+    checkAvailability: () => ipcRenderer.invoke(EOneKeyBleMessageKeys.BLE_AVAILABILITY_CHECK),
+  },
+
+  // Simplified Bluetooth system management
+  bluetoothSystem: {
+    // Open Bluetooth settings when Bluetooth is off
+    openBluetoothSettings: () => ipcRenderer.invoke('bluetooth-open-bluetooth-settings'),
+    // Open Privacy & Security settings for Bluetooth permission
+    openPrivacySettings: () => ipcRenderer.invoke('bluetooth-open-privacy-settings'),
+  },
+};
+
+// Use contextBridge to safely expose the API
+try {
+  contextBridge.exposeInMainWorld('desktopApi', desktopApi);
+} catch (error) {
+  // Fallback for development or when contextBridge is not available
+  console.warn('Failed to expose desktopApi via contextBridge:', error);
+  (window as any).desktopApi = desktopApi;
+}

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;

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "allowSyntheticDefaultImports": true,
+    "jsx": "preserve",
+    "lib": [
+      "dom",
+      "esnext"
+    ],
+    "moduleResolution": "node",
+    "noEmit": true,
+    "resolveJsonModule": true,
+    "target": "esnext",
+    "esModuleInterop": true,
+    "module": "esnext",
+    "allowJs": true // Seems to be needed for index.js
+  },
+  "include": [
+    "**/*.ts",
+    "**/*.tsx",
+    "src/preload.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "web-build/**/*",
+    "out/**/*",
+    "dist/**/*",
+    "public/**/*"
+  ]
+}

package/webpack.config.ts

@@ -0,0 +1,71 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+/* eslint-disable import/no-import-module-exports */
+import path from 'path';
+import webpack from 'webpack';
+import nodeExternals from 'webpack-node-externals';
+import { CleanWebpackPlugin } from 'clean-webpack-plugin';
+import childProcess from 'child_process';
+
+const pkg = require('./package.json');
+
+const gitRevision = childProcess.execSync('git rev-parse HEAD').toString().trim();
+
+module.exports = {
+  mode: 'production',
+  entry: {
+    index: path.resolve(__dirname, 'src/index.ts'),
+    preload: path.resolve(__dirname, 'src/preload.ts'),
+  },
+  target: 'electron-main', // 针对Electron主进程
+  module: {
+    rules: [
+      {
+        test: /\.js$/,
+        exclude: /node_modules/,
+        use: ['babel-loader'],
+      },
+      {
+        test: /\.ts$/,
+        exclude: /node_modules/,
+        use: {
+          loader: 'babel-loader',
+          options: {
+            presets: ['@babel/preset-typescript'],
+            plugins: ['@babel/plugin-proposal-optional-chaining'],
+          },
+        },
+      },
+    ],
+  },
+  resolve: {
+    extensions: ['.ts', '.js'],
+  },
+  externals: [
+    nodeExternals({
+      allowlist: [
+        // Include all @onekeyfe packages to handle transitive dependencies
+        /^@onekeyfe\//,
+        ...Object.keys({
+          ...pkg.dependencies,
+          ...pkg.devDependencies,
+        }),
+      ],
+    }),
+    {
+      '@stoprocent/noble': 'commonjs @stoprocent/noble',
+      '@stoprocent/bluetooth-hci-socket': 'commonjs @stoprocent/bluetooth-hci-socket',
+      bufferutil: 'commonjs bufferutil',
+      'utf-8-validate': 'commonjs utf-8-validate',
+    },
+  ],
+  output: {
+    path: path.resolve(__dirname, 'dist'),
+    filename: '[name].js',
+  },
+  plugins: [
+    new CleanWebpackPlugin(),
+    new webpack.DefinePlugin({
+      'process.env.COMMITHASH': JSON.stringify(gitRevision),
+    }),
+  ],
+};