hardware-example 0.3.40-alpha.1

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,99 @@
+module.exports = {
+  extraMetadata: {
+    main: 'dist/index.js',
+    version: '1',
+  },
+  appId: 'so.onekey.example.hardware-desktop',
+  productName: 'HardwareExample',
+  copyright: 'Copyright © OeKey 2024',
+  asar: true,
+  buildVersion: '1',
+  directories: {
+    output: 'out',
+  },
+  files: [
+    'web-build',
+    'public',
+    'bin',
+    '!public/bin/**/*',
+    'dist/**/*.js',
+    '!dist/__**',
+    'package.json',
+  ],
+  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: ['nsis'],
+  },
+  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'],
+  },
+};

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/forge.config.js

@@ -0,0 +1,65 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+const path = require('path');
+const fs = require('fs-extra');
+const d = require('debug');
+
+const debug = d('forge config');
+
+module.exports = {
+  packagerConfig: {
+    name: 'HardwareExample',
+    appBundleId: 'so.onekey.example.hardware-desktop',
+    executableName: process.platform === 'linux' ? 'onekey-hardware-example' : 'HardwareExample',
+    appCategoryType: 'public.app-category.developer-tools',
+    appCopyright: 'Copyright 2024 OneKey Ltd',
+    asar: true,
+    icon: path.resolve(__dirname, 'public', 'icons', 'icon'),
+  },
+  rebuildConfig: {},
+  hooks: {
+    packageAfterCopy: async (forgeConfig, buildPath, electronVersion, platform, arch) => {
+      let originDir;
+      let binName;
+      const destDir = path.resolve(buildPath, '../', 'bin', 'bridge');
+
+      switch (platform) {
+        case 'darwin':
+          originDir = path.resolve(buildPath, 'public', 'bin', 'bridge', `mac-${arch}`);
+          binName = 'onekeyd';
+          break;
+        case 'win32':
+          originDir = path.resolve(buildPath, 'public', 'bin', 'bridge', 'win-x64');
+          binName = 'onekeyd.exe';
+          break;
+        case 'linux':
+          originDir = path.resolve(buildPath, 'public', 'bin', 'bridge', `linux-${arch}`);
+          binName = 'onekeyd';
+          break;
+        default:
+          originDir = '';
+          binName = 'onekeyd';
+          break;
+      }
+
+      debug(`Copy bridge bin: originDir:${originDir}, platform:${platform}, arch:${arch}`);
+      await fs.ensureDir(destDir);
+      await fs.copy(path.resolve(originDir, binName), path.resolve(destDir, binName));
+    },
+    packageAfterPrune: async (forgeConfig, buildPath, electronVersion, platform, arch) => {
+      const bridgeDir = path.resolve(buildPath, 'public', 'bin');
+      const scrDir = path.resolve(buildPath, 'src');
+      const buildScriptDir = path.resolve(buildPath, 'scripts');
+
+      await fs.remove(bridgeDir);
+      await fs.remove(scrDir);
+      await fs.remove(buildScriptDir);
+      return null;
+    },
+  },
+  makers: [
+    {
+      name: '@electron-forge/maker-zip',
+      platforms: ['darwin', 'win32'],
+    },
+  ],
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "hardware-example",
+  "productName": "HardwareExample",
+  "executableName": "onekey-hardware-example",
+  "version": "0.3.40-alpha.1",
+  "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:package": "yarn build-electron-web && electron-forge package",
+    "build:main": "webpack --config webpack.config.ts",
+    "make": "yarn clean:build && yarn build-electron-web && electron-builder build -mw --config electron-builder.config.js --publish never",
+    "lint": "eslint --ext .tsx --ext .ts ./",
+    "ts:check": "yarn tsc --noEmit"
+  },
+  "dependencies": {
+    "debug": "4.3.4",
+    "electron-is-dev": "^3.0.1",
+    "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": "^28.0.0",
+    "electron-builder": "^24.9.1",
+    "webpack": "^5.90.2",
+    "webpack-node-externals": "^3.0.0"
+  },
+  "gitHead": "455e71107390795e90651ecb46ef32cd8c8be5e2"
+}

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/index.ts

@@ -0,0 +1,233 @@
+import { screen, app, BrowserWindow, session } from 'electron';
+import path from 'path';
+import isDevelopment from 'electron-is-dev';
+import { format as formatUrl } from 'url';
+import initProcess from './process';
+
+const isMac = process.platform === 'darwin';
+const isWin = process.platform === 'win32';
+
+const APP_NAME = 'OneKey Example';
+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,
+      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('SET_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 });
+  });
+
+  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
+      }
+    }
+  });
+
+  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();
+    }
+    initChildProcess();
+    showMainWindow();
+  });
+}
+
+// wuit 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,28 @@
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-unused-vars,@typescript-eslint/require-await */
+import { ipcRenderer, contextBridge } from 'electron';
+
+export type DesktopAPI = {
+  reloadBridgeProcess: () => void;
+};
+declare global {
+  interface Window {
+    desktopApi: DesktopAPI;
+    INJECT_PATH: string;
+  }
+}
+
+ipcRenderer.on('SET_ONEKEY_DESKTOP_GLOBALS', (_, globals) => {
+  // @ts-expect-error
+  window.ONEKEY_DESKTOP_GLOBALS = globals;
+  // contextBridge.exposeInMainWorld('ONEKEY_DESKTOP_GLOBALS', globals);
+});
+
+const desktopApi = {
+  reloadBridgeProcess: () => {
+    ipcRenderer.send('app/reloadBridgeProcess');
+  },
+};
+
+window.desktopApi = desktopApi;
+// contextBridge.exposeInMainWorld('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,61 @@
+/* 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: Object.keys({
+        ...pkg.dependencies,
+        ...pkg.devDependencies,
+      }),
+    }),
+  ],
+  output: {
+    path: path.resolve(__dirname, 'dist'),
+    filename: '[name].js',
+  },
+  plugins: [
+    new CleanWebpackPlugin(),
+    new webpack.DefinePlugin({
+      'process.env.COMMITHASH': JSON.stringify(gitRevision),
+    }),
+  ],
+};