v1.1.1

* add chains[0] display

* add metadata.process to connections

.github/workflows/alpha.yml

@@ -0,0 +1,84 @@
+name: Alpha CI
+
+on:
+  push:
+    branches: [alpha]
+
+env:
+  CARGO_INCREMENTAL: 0
+  RUST_BACKTRACE: short
+
+jobs:
+  release:
+    strategy:
+      matrix:
+        os: [windows-latest, ubuntu-latest, macos-latest]
+    runs-on: ${{ matrix.os }}
+    if: startsWith(github.repository, 'zzzgydi')
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          profile: minimal
+          override: true
+
+      - name: Rust Cache
+        uses: Swatinem/rust-cache@ce325b60658c1b38465c06cc965b79baf32c1e72
+        with:
+          working-directory: src-tauri
+
+      - name: Install Node
+        uses: actions/setup-node@v1
+        with:
+          node-version: 14
+
+      - name: Install Dependencies (ubuntu only)
+        if: matrix.os == 'ubuntu-latest'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libappindicator3-dev librsvg2-dev libayatana-appindicator3-dev
+
+      - name: Get yarn cache dir path
+        id: yarn-cache-dir-path
+        run: echo "::set-output name=dir::$(yarn cache dir)"
+
+      - name: Yarn Cache
+        uses: actions/cache@v2
+        id: yarn-cache
+        with:
+          path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
+          key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-yarn-
+
+      - name: Yarn install and check
+        run: |
+          yarn install --network-timeout 1000000
+          yarn run check
+
+      - name: Tauri build
+        uses: tauri-apps/tauri-action@743a37fd53cbdd122910b818b9bef7b7aa019134
+        # enable cache even though failed
+        continue-on-error: true
+        env:
+          VITE_MULTI_CORE: 1
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+        with:
+          tagName: alpha
+          releaseName: "Clash Verge Alpha"
+          releaseBody: "Alpha Version"
+          releaseDraft: true
+          prerelease: true
+
+      # - name: Portable Bundle
+      #   if: matrix.os == 'windows-latest'
+      #   run: |
+      #     yarn run portable
+      #   env:
+      #     GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/ci.yml

@@ -1,4 +1,4 @@
-name: CI
+name: Release CI
 
 on: [push]
 
@@ -10,7 +10,7 @@ jobs:
   release:
     strategy:
       matrix:
-        os: [windows-latest, macos-11]
+        os: [windows-latest, ubuntu-latest, macos-latest]
     runs-on: ${{ matrix.os }}
     if: |
       startsWith(github.repository, 'zzzgydi') &&
@@ -28,12 +28,20 @@ jobs:
 
       - name: Rust Cache
         uses: Swatinem/rust-cache@ce325b60658c1b38465c06cc965b79baf32c1e72
+        with:
+          working-directory: src-tauri
 
       - name: Install Node
         uses: actions/setup-node@v1
         with:
           node-version: 14
 
+      - name: Install Dependencies (ubuntu only)
+        if: startsWith(matrix.os, 'ubuntu-')
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libappindicator3-dev librsvg2-dev libayatana-appindicator3-dev
+
       - name: Get yarn cache dir path
         id: yarn-cache-dir-path
         run: echo "::set-output name=dir::$(yarn cache dir)"
@@ -53,21 +61,35 @@ jobs:
           yarn run check
 
       - name: Tauri build
-        uses: tauri-apps/tauri-action@v0
+        uses: tauri-apps/tauri-action@0e558392ccadcb49bcc89e7df15a400e8f0c954d
         # enable cache even though failed
-        continue-on-error: true
+        # continue-on-error: true
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
         with:
           tagName: v__VERSION__
           releaseName: "Clash Verge v__VERSION__"
-          releaseBody: "Clash Verge now supports Windows and macos(intel)."
+          releaseBody: "More new features are now supported."
           releaseDraft: false
           prerelease: true
 
+      - name: Portable Bundle
+        if: matrix.os == 'windows-latest'
+        # rebuild with env settings
+        run: |
+          yarn build
+          yarn run portable
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+          VITE_WIN_PORTABLE: 1
+
   release-update:
     needs: release
-    runs-on: macos-11
+    runs-on: macos-latest
     if: |
       startsWith(github.repository, 'zzzgydi') &&
       startsWith(github.ref, 'refs/tags/v')
@@ -89,10 +111,9 @@ jobs:
             ${{ runner.os }}-yarn-
 
       - name: Yarn install
-        run: yarn
+        run: yarn install
 
-      - name: Release update.json
-        run: yarn run release
-        continue-on-error: true
+      - name: Release updater file
+        run: yarn run updater
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/test.yml

@@ -0,0 +1,82 @@
+name: Test CI
+
+on:
+  workflow_dispatch:
+    inputs:
+      os:
+        description: "Runs on OS"
+        required: true
+        default: windows-latest
+        type: choice
+        options:
+          - windows-latest
+          - ubuntu-latest
+          - macos-latest
+          - ubuntu-18.04
+          - ubuntu-20.04
+          - ubuntu-22.04
+          - macos-10.15
+          - macos-11
+          - macos-12
+          - windows-2019
+          - windows-2022
+
+env:
+  CARGO_INCREMENTAL: 0
+  RUST_BACKTRACE: short
+
+jobs:
+  release:
+    runs-on: ${{ github.event.inputs.os }}
+    if: startsWith(github.repository, 'zzzgydi')
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          profile: minimal
+          override: true
+
+      - name: Rust Cache
+        uses: Swatinem/rust-cache@v1
+        with:
+          working-directory: src-tauri
+
+      - name: Install Node
+        uses: actions/setup-node@v1
+        with:
+          node-version: 14
+
+      - name: Install Dependencies (ubuntu only)
+        if: startsWith(github.event.inputs.os, 'ubuntu-')
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libappindicator3-dev librsvg2-dev libayatana-appindicator3-dev
+
+      - name: Get yarn cache dir path
+        id: yarn-cache-dir-path
+        run: echo "::set-output name=dir::$(yarn cache dir)"
+
+      - name: Yarn Cache
+        uses: actions/cache@v2
+        id: yarn-cache
+        with:
+          path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
+          key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-yarn-
+
+      - name: Yarn install and check
+        run: |
+          yarn install --network-timeout 1000000
+          yarn run check
+
+      - name: Tauri build
+        uses: tauri-apps/tauri-action@0e558392ccadcb49bcc89e7df15a400e8f0c954d
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}

.github/workflows/updater.yml

@@ -0,0 +1,32 @@
+name: Updater CI
+
+on: workflow_dispatch
+
+jobs:
+  release-update:
+    runs-on: macos-latest
+    if: startsWith(github.repository, 'zzzgydi')
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+
+      - name: Get yarn cache dir path
+        id: yarn-cache-dir-path
+        run: echo "::set-output name=dir::$(yarn cache dir)"
+
+      - name: Yarn Cache
+        uses: actions/cache@v2
+        id: yarn-cache
+        with:
+          path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
+          key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-yarn-
+
+      - name: Yarn install
+        run: yarn install
+
+      - name: Release updater file
+        run: yarn run updater
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -4,3 +4,4 @@ dist
 dist-ssr
 *.local
 update.json
+scripts/_env.sh

README.md

@@ -11,19 +11,29 @@ A <a href="https://github.com/Dreamacro/clash">Clash</a> GUI based on <a href="h
 
 ## Features
 
-Now it's no different from the others, even fewer. (WIP)
+- Full `clash` config supported, Partial `clash premium` config supported.
+- Profiles management and enhancement (by yaml and Javascript). [Doc](https://github.com/zzzgydi/clash-verge/wiki/%E4%BD%BF%E7%94%A8%E6%8C%87%E5%8D%97)
+- Simple UI and supports custom theme color.
+- Built-in support [Clash.Meta](https://github.com/MetaCubeX/Clash.Meta) core.
+- System proxy setting and guard.
+
+## Install
+
+Download from [release](https://github.com/zzzgydi/clash-verge/releases). Supports Windows x64, Linux x86_64 and macOS 11+
+
+Or you can build it yourself. Supports Windows, Linux and macOS 10.15+
+
+Notes: If you could not start the app on Windows, please check that you have [Webview2](https://developer.microsoft.com/en-us/microsoft-edge/webview2/#download-section) installed.
 
 ## Development
 
-You should install Rust and Nodejs. Then install tauri cli and packages.
+You should install Rust and Nodejs, see [here](https://tauri.studio/docs/getting-started/prerequisites) for more details. Then install Nodejs packages.
 
 ```shell
-cargo install tauri-cli --git https://github.com/tauri-apps/tauri
-
 yarn install
 ```
 
-Then download the clash binary... Or you can download it from [clash premium release](https://github.com/Dreamacro/clash/releases/tag/premium) and rename it according to [tauri config](https://tauri.studio/en/docs/api/config#tauri.bundle.externalBin).
+Then download the clash binary... Or you can download it from [clash premium release](https://github.com/Dreamacro/clash/releases/tag/premium) and rename it according to [tauri config](https://tauri.studio/docs/api/config/#tauri.bundle.externalBin).
 
 ```shell
 yarn run check
@@ -35,6 +45,12 @@ Then run
 yarn dev
 ```
 
+Or you can build it
+
+```shell
+yarn build
+```
+
 ## Todos
 
 > This keng is a little big...
@@ -50,13 +66,24 @@ yarn dev
   <img src="./docs/demo6.png" alt="demo6" width="32%" />
 </div>
 
+### Custom Theme
+
+<div align="center">
+  <img src="./docs/color1.png" alt="demo1" width="16%" />
+  <img src="./docs/color2.png" alt="demo2" width="16%" />
+  <img src="./docs/color3.png" alt="demo3" width="16%" />
+  <img src="./docs/color4.png" alt="demo4" width="16%" />
+  <img src="./docs/color5.png" alt="demo5" width="16%" />
+  <img src="./docs/color6.png" alt="demo6" width="16%" />
+</div>
+
 ## Disclaimer
 
 This is a learning project for Rust practice.
 
 ## Contributions
 
-PR welcome!
+Issue and PR welcome!
 
 ## Acknowledgement
 
@@ -64,6 +91,7 @@ Clash Verge was based on or inspired by these projects and so on:
 
 - [tauri-apps/tauri](https://github.com/tauri-apps/tauri): Build smaller, faster, and more secure desktop applications with a web frontend.
 - [Dreamacro/clash](https://github.com/Dreamacro/clash): A rule-based tunnel in Go.
+- [MetaCubeX/Clash.Meta](https://github.com/MetaCubeX/Clash.Meta): A rule-based tunnel in Go.
 - [Fndroid/clash_for_windows_pkg](https://github.com/Fndroid/clash_for_windows_pkg): A Windows/macOS GUI based on Clash.
 - [vitejs/vite](https://github.com/vitejs/vite): Next generation frontend tooling. It's fast!
 

UPDATELOG.md

@@ -0,0 +1,236 @@
+## v1.1.1
+
+### Features
+
+- optimize clash config feedback
+- hide macOS dock icon
+- use clash meta compatible version (Linux)
+
+### Bug Fixes
+
+- fix some other glitches
+
+---
+
+## v1.1.0
+
+### Features
+
+- add rule page
+- supports proxy providers delay check
+- add proxy delay check loading status
+- supports hotkey/shortcut management
+- supports displaying connections data in table layout(refer to yacd)
+
+### Bug Fixes
+
+- supports yaml merge key in clash config
+- detect the network interface and set the system proxy(macOS)
+- fix some other glitches
+
+---
+
+## v1.0.6
+
+### Features
+
+- update clash and clash.meta
+
+### Bug Fixes
+
+- only script profile display console
+- automatic configuration update on demand at launch
+
+---
+
+## v1.0.5
+
+### Features
+
+- reimplement profile enhanced mode with quick-js
+- optimize the runtime config generation process
+- support web ui management
+- support clash field management
+- support viewing the runtime config
+- adjust some pages style
+
+### Bug Fixes
+
+- fix silent start
+- fix incorrectly reset system proxy on exit
+
+---
+
+## v1.0.4
+
+### Features
+
+- update clash core and clash meta version
+- support switch clash mode on system tray
+- theme mode support follows system
+
+### Bug Fixes
+
+- config load error on first use
+
+---
+
+## v1.0.3
+
+### Features
+
+- save some states such as URL test, filter, etc
+- update clash core and clash-meta core
+- new icon for macOS
+
+---
+
+## v1.0.2
+
+### Features
+
+- supports for switching clash core
+- supports release UI processes
+- supports script mode setting
+
+### Bug Fixes
+
+- fix service mode bug (Windows)
+
+---
+
+## v1.0.1
+
+### Features
+
+- adjust default theme settings
+- reduce gpu usage of traffic graph when hidden
+- supports more remote profile response header setting
+- check remote profile data format when imported
+
+### Bug Fixes
+
+- service mode install and start issue (Windows)
+- fix launch panic (Some Windows)
+
+---
+
+## v1.0.0
+
+### Features
+
+- update clash core
+- optimize traffic graph animation
+- supports interval update profiles
+- supports service mode (Windows)
+
+### Bug Fixes
+
+- reset system proxy when exit from dock (macOS)
+- adjust clash dns config process strategy
+
+---
+
+## v0.0.29
+
+### Features
+
+- sort proxy node
+- custom proxy test url
+- logs page filter
+- connections page filter
+- default user agent for subscription
+- system tray add tun mode toggle
+- enable to change the config dir (Windows only)
+
+---
+
+## v0.0.28
+
+### Features
+
+- enable to use clash config fields (UI)
+
+### Bug Fixes
+
+- remove the character
+- fix some icon color
+
+---
+
+## v0.0.27
+
+### Features
+
+- supports custom theme color
+- tun mode setting control the final config
+
+### Bug Fixes
+
+- fix transition flickers (macOS)
+- reduce proxy page render
+
+---
+
+## v0.0.26
+
+### Features
+
+- silent start
+- profile editor
+- profile enhance mode supports more fields
+- optimize profile enhance mode strategy
+
+### Bug Fixes
+
+- fix csp restriction on macOS
+- window controllers on Linux
+
+---
+
+## v0.0.25
+
+### Features
+
+- update clash core version
+
+### Bug Fixes
+
+- app updater error
+- display window controllers on Linux
+
+### Notes
+
+If you can't update the app properly, please consider downloading the latest version from github release.
+
+---
+
+## v0.0.24
+
+### Features
+
+- Connections page
+- add wintun.dll (Windows)
+- supports create local profile with selected file (Windows)
+- system tray enable set system proxy
+
+### Bug Fixes
+
+- open dir error
+- auto launch path (Windows)
+- fix some clash config error
+- reduce the impact of the enhanced mode
+
+---
+
+## v0.0.23
+
+### Features
+
+- i18n supports
+- Remote profile User Agent supports
+
+### Bug Fixes
+
+- clash config file case ignore
+- clash `external-controller` only port

package.json

@@ -1,51 +1,65 @@
 {
   "name": "clash-verge",
-  "version": "0.0.14",
+  "version": "1.1.1",
   "license": "GPL-3.0",
   "scripts": {
-    "dev": "cargo tauri dev",
-    "build": "cargo tauri build",
+    "dev": "tauri dev",
+    "dev:diff": "tauri dev -f verge-dev",
+    "build": "tauri build",
     "tauri": "tauri",
     "web:dev": "vite",
     "web:build": "tsc && vite build",
     "web:serve": "vite preview",
+    "aarch": "node scripts/aarch.mjs",
     "check": "node scripts/check.mjs",
+    "updater": "node scripts/updater.mjs",
     "publish": "node scripts/publish.mjs",
-    "release": "node scripts/release.mjs",
+    "portable": "node scripts/portable.mjs",
     "prepare": "husky install"
   },
   "dependencies": {
-    "@emotion/react": "^11.7.0",
-    "@emotion/styled": "^11.6.0",
-    "@mui/icons-material": "^5.2.1",
-    "@mui/material": "^5.2.3",
-    "@tauri-apps/api": "^1.0.0-beta.8",
-    "ahooks": "^3.1.7",
-    "axios": "^0.24.0",
-    "dayjs": "^1.10.7",
-    "react": "^17.0.0",
-    "react-dom": "^17.0.0",
-    "react-router-dom": "^6.0.2",
-    "react-virtuoso": "^2.3.1",
-    "recoil": "^0.5.2",
-    "swr": "^1.1.2-beta.0"
+    "@emotion/react": "^11.10.4",
+    "@emotion/styled": "^11.10.4",
+    "@mui/icons-material": "^5.10.3",
+    "@mui/material": "^5.10.3",
+    "@mui/x-data-grid": "^5.17.4",
+    "@tauri-apps/api": "^1.1.0",
+    "ahooks": "^3.7.0",
+    "axios": "^0.27.2",
+    "dayjs": "^1.11.5",
+    "i18next": "^21.9.1",
+    "monaco-editor": "^0.34.0",
+    "react": "^17.0.2",
+    "react-dom": "^17.0.2",
+    "react-i18next": "^11.17.4",
+    "react-router-dom": "^6.3.0",
+    "react-virtuoso": "^2.17.2",
+    "recoil": "^0.7.5",
+    "snarkdown": "^2.0.0",
+    "swr": "^1.3.0"
   },
   "devDependencies": {
-    "@actions/github": "^5.0.0",
-    "@tauri-apps/cli": "^1.0.0-beta.10",
+    "@actions/github": "^5.0.3",
+    "@tauri-apps/cli": "^1.1.1",
     "@types/fs-extra": "^9.0.13",
-    "@types/js-cookie": "^3.0.1",
+    "@types/js-cookie": "^3.0.2",
+    "@types/lodash": "^4.14.180",
     "@types/react": "^17.0.0",
     "@types/react-dom": "^17.0.0",
-    "@vitejs/plugin-react": "^1.1.1",
+    "@vitejs/plugin-react": "^2.0.1",
     "adm-zip": "^0.5.9",
+    "cross-env": "^7.0.3",
     "fs-extra": "^10.0.0",
+    "https-proxy-agent": "^5.0.1",
     "husky": "^7.0.0",
-    "node-fetch": "^3.1.0",
+    "node-fetch": "^3.2.6",
+    "prettier": "^2.7.1",
     "pretty-quick": "^3.1.3",
-    "sass": "^1.44.0",
-    "typescript": "^4.5.2",
-    "vite": "^2.7.1"
+    "sass": "^1.54.0",
+    "typescript": "^4.7.4",
+    "vite": "^3.0.9",
+    "vite-plugin-monaco-editor": "^1.1.0",
+    "vite-plugin-svgr": "^2.2.1"
   },
   "prettier": {
     "tabWidth": 2,
@@ -53,4 +67,4 @@
     "singleQuote": false,
     "endOfLine": "lf"
   }
-}
+}

scripts/aarch.mjs

@@ -0,0 +1,104 @@
+/**
+ * Build and upload assets for macOS(aarch)
+ */
+import fs from "fs-extra";
+import path from "path";
+import { exit } from "process";
+import { createRequire } from "module";
+import { getOctokit, context } from "@actions/github";
+
+const require = createRequire(import.meta.url);
+
+async function resolve() {
+  if (!process.env.GITHUB_TOKEN) {
+    throw new Error("GITHUB_TOKEN is required");
+  }
+  if (!process.env.GITHUB_REPOSITORY) {
+    throw new Error("GITHUB_REPOSITORY is required");
+  }
+  if (!process.env.TAURI_PRIVATE_KEY) {
+    throw new Error("TAURI_PRIVATE_KEY is required");
+  }
+  if (!process.env.TAURI_KEY_PASSWORD) {
+    throw new Error("TAURI_KEY_PASSWORD is required");
+  }
+
+  const { version } = require("../package.json");
+
+  const cwd = process.cwd();
+  const bundlePath = path.join(cwd, "src-tauri/target/release/bundle");
+  const join = (p) => path.join(bundlePath, p);
+
+  const appPathList = [
+    join("macos/Clash Verge.aarch64.app.tar.gz"),
+    join("macos/Clash Verge.aarch64.app.tar.gz.sig"),
+  ];
+
+  for (const appPath of appPathList) {
+    if (fs.pathExistsSync(appPath)) {
+      fs.removeSync(appPath);
+    }
+  }
+
+  fs.copyFileSync(join("macos/Clash Verge.app.tar.gz"), appPathList[0]);
+  fs.copyFileSync(join("macos/Clash Verge.app.tar.gz.sig"), appPathList[1]);
+
+  const options = { owner: context.repo.owner, repo: context.repo.repo };
+  const github = getOctokit(process.env.GITHUB_TOKEN);
+
+  const { data: release } = await github.rest.repos.getReleaseByTag({
+    ...options,
+    tag: `v${version}`,
+  });
+
+  if (!release.id) throw new Error("failed to find the release");
+
+  await uploadAssets(release.id, [
+    join(`dmg/Clash Verge_${version}_aarch64.dmg`),
+    ...appPathList,
+  ]);
+}
+
+// From tauri-apps/tauri-action
+// https://github.com/tauri-apps/tauri-action/blob/dev/packages/action/src/upload-release-assets.ts
+async function uploadAssets(releaseId, assets) {
+  const github = getOctokit(process.env.GITHUB_TOKEN);
+
+  // Determine content-length for header to upload asset
+  const contentLength = (filePath) => fs.statSync(filePath).size;
+
+  for (const assetPath of assets) {
+    const headers = {
+      "content-type": "application/zip",
+      "content-length": contentLength(assetPath),
+    };
+
+    const ext = path.extname(assetPath);
+    const filename = path.basename(assetPath).replace(ext, "");
+    const assetName = path.dirname(assetPath).includes(`target${path.sep}debug`)
+      ? `${filename}-debug${ext}`
+      : `${filename}${ext}`;
+
+    console.log(`[INFO]: Uploading ${assetName}...`);
+
+    try {
+      await github.rest.repos.uploadReleaseAsset({
+        headers,
+        name: assetName,
+        data: fs.readFileSync(assetPath),
+        owner: context.repo.owner,
+        repo: context.repo.repo,
+        release_id: releaseId,
+      });
+    } catch (error) {
+      console.log(error.message);
+    }
+  }
+}
+
+if (process.platform === "darwin" && process.arch === "arm64") {
+  resolve();
+} else {
+  console.error("invalid");
+  exit(1);
+}

scripts/check.mjs

@@ -3,13 +3,14 @@ import zlib from "zlib";
 import path from "path";
 import AdmZip from "adm-zip";
 import fetch from "node-fetch";
+import proxyAgent from "https-proxy-agent";
 import { execSync } from "child_process";
 
 const cwd = process.cwd();
+const TEMP_DIR = path.join(cwd, "node_modules/.verge");
 
-const CLASH_URL_PREFIX =
-  "https://github.com/Dreamacro/clash/releases/download/premium/";
-const CLASH_LATEST_DATE = "2022.01.27";
+const FORCE = process.argv.includes("--force");
+const NO_META = process.argv.includes("--no-meta") || false;
 
 /**
  * get the correct clash release infomation
@@ -17,11 +18,17 @@ const CLASH_LATEST_DATE = "2022.01.27";
 function resolveClash() {
   const { platform, arch } = process;
 
+  const CLASH_URL_PREFIX =
+    "https://github.com/Dreamacro/clash/releases/download/premium/";
+  const CLASH_LATEST_DATE = "2022.08.26";
+
   // todo
   const map = {
-    "win32-x64": "clash-windows-386",
+    "win32-x64": "clash-windows-amd64",
     "darwin-x64": "clash-darwin-amd64",
     "darwin-arm64": "clash-darwin-arm64",
+    "linux-x64": "clash-linux-amd64",
+    "linux-arm64": "clash-linux-armv8",
   };
 
   const name = map[`${platform}-${arch}`];
@@ -39,54 +46,213 @@ function resolveClash() {
   return { url, zip, exefile, zipfile };
 }
 
+/**
+ * get the correct Clash.Meta release infomation
+ */
+async function resolveClashMeta() {
+  const { platform, arch } = process;
+
+  const urlPrefix = `https://github.com/MetaCubeX/Clash.Meta/releases/download/`;
+  const latestVersion = "v1.13.1";
+
+  const map = {
+    "win32-x64": "Clash.Meta-windows-amd64",
+    "darwin-x64": "Clash.Meta-darwin-amd64",
+    "darwin-arm64": "Clash.Meta-darwin-arm64",
+    "linux-x64": "Clash.Meta-linux-amd64-compatible",
+    "linux-arm64": "Clash.Meta-linux-arm64",
+  };
+
+  const name = map[`${platform}-${arch}`];
+
+  if (!name) {
+    throw new Error(`unsupport platform "${platform}-${arch}"`);
+  }
+
+  const isWin = platform === "win32";
+  const ext = isWin ? "zip" : "gz";
+  const url = `${urlPrefix}${latestVersion}/${name}-${latestVersion}.${ext}`;
+  const exefile = `${name}${isWin ? ".exe" : ""}`;
+  const zipfile = `${name}-${latestVersion}.${ext}`;
+
+  return { url, zip: ext, exefile, zipfile };
+}
+
 /**
  * get the sidecar bin
+ * clash and Clash Meta
  */
 async function resolveSidecar() {
   const sidecarDir = path.join(cwd, "src-tauri", "sidecar");
 
-  const host = execSync("rustc -vV | grep host").toString().slice(6).trim();
+  const host = execSync("rustc -vV")
+    .toString()
+    .match(/(?<=host: ).+(?=\s*)/g)[0];
+
   const ext = process.platform === "win32" ? ".exe" : "";
-  const sidecarFile = `clash-${host}${ext}`;
-  const sidecarPath = path.join(sidecarDir, sidecarFile);
 
-  if (!(await fs.pathExists(sidecarDir))) await fs.mkdir(sidecarDir);
-  if (await fs.pathExists(sidecarPath)) return;
+  await clash();
+  if (!NO_META) await clashMeta();
 
-  // download sidecar
-  const binInfo = resolveClash();
-  const tempDir = path.join(cwd, "pre-dev-temp");
-  const tempZip = path.join(tempDir, binInfo.zipfile);
-  const tempExe = path.join(tempDir, binInfo.exefile);
+  async function clash() {
+    const sidecarFile = `clash-${host}${ext}`;
+    const sidecarPath = path.join(sidecarDir, sidecarFile);
 
-  if (!(await fs.pathExists(tempDir))) await fs.mkdir(tempDir);
-  if (!(await fs.pathExists(tempZip))) await downloadFile(binInfo.url, tempZip);
+    await fs.mkdirp(sidecarDir);
+    if (!FORCE && (await fs.pathExists(sidecarPath))) return;
 
-  if (binInfo.zip === "zip") {
-    const zip = new AdmZip(tempZip);
-    zip.getEntries().forEach((entry) => {
-      console.log("[INFO]: entry name", entry.entryName);
-    });
-    zip.extractAllTo(tempDir, true);
-    // save as sidecar
-    await fs.rename(tempExe, sidecarPath);
-    console.log(`[INFO]: unzip finished`);
-  } else {
-    // gz
-    const readStream = fs.createReadStream(tempZip);
-    const writeStream = fs.createWriteStream(sidecarPath);
-    readStream
-      .pipe(zlib.createGunzip())
-      .pipe(writeStream)
-      .on("finish", () => {
-        console.log(`[INFO]: gunzip finished`);
-        execSync(`chmod 755 ${sidecarPath}`);
-        console.log(`[INFO]: chmod binary finished`);
+    // download sidecar
+    const binInfo = resolveClash();
+    const tempDir = path.join(TEMP_DIR, "clash");
+    const tempZip = path.join(tempDir, binInfo.zipfile);
+    const tempExe = path.join(tempDir, binInfo.exefile);
+
+    await fs.mkdirp(tempDir);
+    if (!(await fs.pathExists(tempZip)))
+      await downloadFile(binInfo.url, tempZip);
+
+    if (binInfo.zip === "zip") {
+      const zip = new AdmZip(tempZip);
+      zip.getEntries().forEach((entry) => {
+        console.log("[INFO]: entry name", entry.entryName);
       });
+      zip.extractAllTo(tempDir, true);
+      // save as sidecar
+      await fs.rename(tempExe, sidecarPath);
+      console.log(`[INFO]: unzip finished`);
+    } else {
+      // gz
+      const readStream = fs.createReadStream(tempZip);
+      const writeStream = fs.createWriteStream(sidecarPath);
+      readStream
+        .pipe(zlib.createGunzip())
+        .pipe(writeStream)
+        .on("finish", () => {
+          console.log(`[INFO]: gunzip finished`);
+          execSync(`chmod 755 ${sidecarPath}`);
+          console.log(`[INFO]: chmod binary finished`);
+        })
+        .on("error", (error) => console.error(error));
+    }
+
+    // delete temp dir
+    await fs.remove(tempDir);
   }
 
-  // delete temp dir
+  async function clashMeta() {
+    const sidecarFile = `clash-meta-${host}${ext}`;
+    const sidecarPath = path.join(sidecarDir, sidecarFile);
+
+    await fs.mkdirp(sidecarDir);
+    if (!FORCE && (await fs.pathExists(sidecarPath))) return;
+
+    // download sidecar
+    const binInfo = await resolveClashMeta();
+    const tempDir = path.join(TEMP_DIR, "clash-meta");
+    const tempZip = path.join(tempDir, binInfo.zipfile);
+    const tempExe = path.join(tempDir, binInfo.exefile);
+
+    await fs.mkdirp(tempDir);
+    if (!(await fs.pathExists(tempZip)))
+      await downloadFile(binInfo.url, tempZip);
+
+    if (binInfo.zip === "zip") {
+      const zip = new AdmZip(tempZip);
+      zip.getEntries().forEach((entry) => {
+        console.log("[INFO]: entry name", entry.entryName);
+      });
+      zip.extractAllTo(tempDir, true);
+      // save as sidecar
+      await fs.rename(tempExe, sidecarPath);
+      console.log(`[INFO]: unzip finished`);
+    } else {
+      // gz
+      const readStream = fs.createReadStream(tempZip);
+      const writeStream = fs.createWriteStream(sidecarPath);
+      readStream
+        .pipe(zlib.createGunzip())
+        .pipe(writeStream)
+        .on("finish", () => {
+          console.log(`[INFO]: gunzip finished`);
+          execSync(`chmod 755 ${sidecarPath}`);
+          console.log(`[INFO]: chmod binary finished`);
+        })
+        .on("error", (error) => console.error(error));
+    }
+
+    // delete temp dir
+    await fs.remove(tempDir);
+  }
+}
+
+/**
+ * only Windows
+ * get the wintun.dll (not required)
+ */
+async function resolveWintun() {
+  const { platform } = process;
+
+  if (platform !== "win32") return;
+
+  const url = "https://www.wintun.net/builds/wintun-0.14.1.zip";
+
+  const tempDir = path.join(TEMP_DIR, "wintun");
+  const tempZip = path.join(tempDir, "wintun.zip");
+
+  const wintunPath = path.join(tempDir, "wintun/bin/amd64/wintun.dll");
+  const targetPath = path.join(cwd, "src-tauri/resources", "wintun.dll");
+
+  if (!FORCE && (await fs.pathExists(targetPath))) return;
+
+  await fs.mkdirp(tempDir);
+
+  if (!(await fs.pathExists(tempZip))) {
+    await downloadFile(url, tempZip);
+  }
+
+  // unzip
+  const zip = new AdmZip(tempZip);
+  zip.extractAllTo(tempDir, true);
+
+  if (!(await fs.pathExists(wintunPath))) {
+    throw new Error(`path not found "${wintunPath}"`);
+  }
+
+  await fs.rename(wintunPath, targetPath);
   await fs.remove(tempDir);
+
+  console.log(`[INFO]: resolve wintun.dll finished`);
+}
+
+/**
+ * only Windows
+ * get the clash-verge-service.exe
+ */
+async function resolveService() {
+  const { platform } = process;
+
+  if (platform !== "win32") return;
+
+  const resDir = path.join(cwd, "src-tauri/resources");
+
+  const repo =
+    "https://github.com/zzzgydi/clash-verge-service/releases/download/latest";
+
+  async function help(bin) {
+    const targetPath = path.join(resDir, bin);
+
+    if (!FORCE && (await fs.pathExists(targetPath))) return;
+
+    const url = `${repo}/${bin}`;
+    await downloadFile(url, targetPath);
+  }
+
+  await fs.mkdirp(resDir);
+  await help("clash-verge-service.exe");
+  await help("install-service.exe");
+  await help("uninstall-service.exe");
+
+  console.log(`[INFO]: resolve Service finished`);
 }
 
 /**
@@ -94,10 +260,14 @@ async function resolveSidecar() {
  */
 async function resolveMmdb() {
   const url =
-    "https://github.com/Dreamacro/maxmind-geoip/releases/latest/download/Country.mmdb";
+    "https://github.com/Dreamacro/maxmind-geoip/releases/download/20220812/Country.mmdb";
 
-  const resPath = path.join(cwd, "src-tauri", "resources", "Country.mmdb");
-  if (await fs.pathExists(resPath)) return;
+  const resDir = path.join(cwd, "src-tauri", "resources");
+  const resPath = path.join(resDir, "Country.mmdb");
+
+  if (!FORCE && (await fs.pathExists(resPath))) return;
+
+  await fs.mkdirp(resDir);
   await downloadFile(url, resPath);
 }
 
@@ -107,7 +277,20 @@ async function resolveMmdb() {
 async function downloadFile(url, path) {
   console.log(`[INFO]: downloading from "${url}"`);
 
+  const options = {};
+
+  const httpProxy =
+    process.env.HTTP_PROXY ||
+    process.env.http_proxy ||
+    process.env.HTTPS_PROXY ||
+    process.env.https_proxy;
+
+  if (httpProxy) {
+    options.agent = proxyAgent(httpProxy);
+  }
+
   const response = await fetch(url, {
+    ...options,
     method: "GET",
     headers: { "Content-Type": "application/octet-stream" },
   });
@@ -118,5 +301,7 @@ async function downloadFile(url, path) {
 }
 
 /// main
-resolveSidecar();
-resolveMmdb();
+resolveSidecar().catch(console.error);
+resolveWintun().catch(console.error);
+resolveMmdb().catch(console.error);
+resolveService().catch(console.error);

scripts/portable.mjs

@@ -0,0 +1,109 @@
+import fs from "fs-extra";
+import path from "path";
+import AdmZip from "adm-zip";
+import { createRequire } from "module";
+import { getOctokit, context } from "@actions/github";
+
+const META = process.argv.includes("--meta"); // use Clash.Meta
+
+/// Script for ci
+/// 打包绿色版/便携版 (only Windows)
+async function resolvePortable() {
+  if (process.platform !== "win32") return;
+
+  const releaseDir = "./src-tauri/target/release";
+
+  if (!(await fs.pathExists(releaseDir))) {
+    throw new Error("could not found the release dir");
+  }
+
+  const zip = new AdmZip();
+
+  zip.addLocalFile(path.join(releaseDir, "Clash Verge.exe"));
+  zip.addLocalFile(path.join(releaseDir, "clash.exe"));
+  zip.addLocalFile(path.join(releaseDir, "clash-meta.exe"));
+  zip.addLocalFolder(path.join(releaseDir, "resources"), "resources");
+
+  const require = createRequire(import.meta.url);
+  const packageJson = require("../package.json");
+  const { version } = packageJson;
+
+  const zipFile = `Clash.Verge_${version}_x64_portable.zip`;
+  zip.writeZip(zipFile);
+
+  console.log("[INFO]: create portable zip successfully");
+
+  // push release assets
+  if (process.env.GITHUB_TOKEN === undefined) {
+    throw new Error("GITHUB_TOKEN is required");
+  }
+
+  const options = { owner: context.repo.owner, repo: context.repo.repo };
+  const github = getOctokit(process.env.GITHUB_TOKEN);
+
+  const { data: release } = await github.rest.repos.getReleaseByTag({
+    ...options,
+    tag: `v${version}`,
+  });
+
+  console.log(release.name);
+
+  await github.rest.repos.uploadReleaseAsset({
+    ...options,
+    release_id: release.id,
+    name: zipFile,
+    data: zip.toBuffer(),
+  });
+}
+
+/// 打包包含Clash.Meta的 (only Windows)
+async function resolvePortableMeta() {
+  if (process.platform !== "win32") return;
+
+  const releaseDir = "./src-tauri/target/release";
+
+  if (!(await fs.pathExists(releaseDir))) {
+    throw new Error("could not found the release dir");
+  }
+
+  const zip = new AdmZip();
+
+  zip.addLocalFile(path.join(releaseDir, "Clash Verge.exe"));
+  zip.addLocalFile(path.join(releaseDir, "clash.exe"));
+  zip.addLocalFile(path.join(releaseDir, "clash-meta.exe"));
+  zip.addLocalFolder(path.join(releaseDir, "resources"), "resources");
+
+  const require = createRequire(import.meta.url);
+  const packageJson = require("../package.json");
+  const { version } = packageJson;
+
+  const zipFile = `Clash.Verge.Meta_${version}_x64_portable.zip`;
+  zip.writeZip(zipFile);
+
+  console.log("[INFO]: create portable zip successfully");
+
+  // push release assets
+  if (process.env.GITHUB_TOKEN === undefined) {
+    throw new Error("GITHUB_TOKEN is required");
+  }
+
+  const options = { owner: context.repo.owner, repo: context.repo.repo };
+  const github = getOctokit(process.env.GITHUB_TOKEN);
+
+  const { data: release } = await github.rest.repos.getReleaseByTag({
+    ...options,
+    tag: `v${version}`,
+  });
+
+  console.log(release.name);
+
+  await github.rest.repos.uploadReleaseAsset({
+    ...options,
+    release_id: release.id,
+    name: zipFile,
+    data: zip.toBuffer(),
+  });
+}
+
+if (META) resolvePortableMeta().catch(console.error);
+else resolvePortable().catch(console.error);

scripts/publish.mjs

@@ -1,9 +1,11 @@
 import fs from "fs-extra";
 import { createRequire } from "module";
 import { execSync } from "child_process";
+import { resolveUpdateLog } from "./updatelog.mjs";
 
 const require = createRequire(import.meta.url);
 
+// publish
 async function resolvePublish() {
   const flag = process.argv[2] ?? "patch";
   const packageJson = require("../package.json");
@@ -26,6 +28,10 @@ async function resolvePublish() {
   packageJson.version = nextVersion;
   tauriJson.package.version = nextVersion;
 
+  // 发布更新前先写更新日志
+  const nextTag = `v${nextVersion}`;
+  await resolveUpdateLog(nextTag);
+
   await fs.writeFile(
     "./package.json",
     JSON.stringify(packageJson, undefined, 2)

scripts/release.mjs

@@ -1,68 +0,0 @@
-import { createRequire } from "module";
-import { getOctokit, context } from "@actions/github";
-
-const require = createRequire(import.meta.url);
-
-/// generate update.json
-/// upload to update tag's release asset
-async function resolveRelease() {
-  if (process.env.GITHUB_TOKEN === undefined) {
-    throw new Error("GITHUB_TOKEN is required");
-  }
-
-  const packageJson = require("../package.json");
-
-  const { version } = packageJson;
-  const urlPrefix = "https://github.com/zzzgydi/clash-verge/releases/download";
-  const updateData = {
-    name: `v${version}`,
-    notes: `Version ${version} is available now!!!`,
-    pub_date: new Date().toISOString(),
-    platforms: {
-      win64: {
-        signature: "",
-        url: `${urlPrefix}/v${version}/clash-verge_${version}_x64.msi.zip`,
-      },
-      darwin: {
-        signature: "",
-        url: `${urlPrefix}/v${version}/clash-verge.app.tar.gz`,
-      },
-    },
-  };
-
-  console.log(`Generating Version "${version}" update.json`);
-
-  const github = getOctokit(process.env.GITHUB_TOKEN);
-
-  const { data: release } = await github.rest.repos.getReleaseByTag({
-    owner: context.repo.owner,
-    repo: context.repo.repo,
-    tag: "updater",
-  });
-  const { data: assets } = await github.rest.repos.listReleaseAssets({
-    owner: context.repo.owner,
-    repo: context.repo.repo,
-    release_id: release.id,
-  });
-
-  for (let asset of assets) {
-    if (asset.name === "update.json") {
-      await github.rest.repos.deleteReleaseAsset({
-        owner: context.repo.owner,
-        repo: context.repo.repo,
-        asset_id: asset.id,
-      });
-      break;
-    }
-  }
-
-  await github.rest.repos.uploadReleaseAsset({
-    owner: context.repo.owner,
-    repo: context.repo.repo,
-    release_id: release.id,
-    name: "update.json",
-    data: JSON.stringify(updateData, null, 2),
-  });
-}
-
-resolveRelease();

scripts/updatelog.mjs

@@ -0,0 +1,44 @@
+import fs from "fs-extra";
+import path from "path";
+
+const UPDATE_LOG = "UPDATELOG.md";
+
+// parse the UPDATELOG.md
+export async function resolveUpdateLog(tag) {
+  const cwd = process.cwd();
+
+  const reTitle = /^## v[\d\.]+/;
+  const reEnd = /^---/;
+
+  const file = path.join(cwd, UPDATE_LOG);
+
+  if (!(await fs.pathExists(file))) {
+    throw new Error("could not found UPDATELOG.md");
+  }
+
+  const data = await fs.readFile(file).then((d) => d.toString("utf8"));
+
+  const map = {};
+  let p = "";
+
+  data.split("\n").forEach((line) => {
+    if (reTitle.test(line)) {
+      p = line.slice(3).trim();
+      if (!map[p]) {
+        map[p] = [];
+      } else {
+        throw new Error(`Tag ${p} dup`);
+      }
+    } else if (reEnd.test(line)) {
+      p = "";
+    } else if (p) {
+      map[p].push(line);
+    }
+  });
+
+  if (!map[tag]) {
+    throw new Error(`could not found "${tag}" in UPDATELOG.md`);
+  }
+
+  return map[tag].join("\n").trim();
+}

scripts/updater.mjs

@@ -0,0 +1,177 @@
+import fetch from "node-fetch";
+import { getOctokit, context } from "@actions/github";
+import { resolveUpdateLog } from "./updatelog.mjs";
+
+const UPDATE_TAG_NAME = "updater";
+const UPDATE_JSON_FILE = "update.json";
+const UPDATE_JSON_PROXY = "update-proxy.json";
+
+/// generate update.json
+/// upload to update tag's release asset
+async function resolveUpdater() {
+  if (process.env.GITHUB_TOKEN === undefined) {
+    throw new Error("GITHUB_TOKEN is required");
+  }
+
+  const options = { owner: context.repo.owner, repo: context.repo.repo };
+  const github = getOctokit(process.env.GITHUB_TOKEN);
+
+  const { data: tags } = await github.rest.repos.listTags({
+    ...options,
+    per_page: 10,
+    page: 1,
+  });
+
+  // get the latest publish tag
+  const tag = tags.find((t) => t.name.startsWith("v"));
+
+  console.log(tag);
+  console.log();
+
+  const { data: latestRelease } = await github.rest.repos.getReleaseByTag({
+    ...options,
+    tag: tag.name,
+  });
+
+  const updateData = {
+    name: tag.name,
+    notes: await resolveUpdateLog(tag.name), // use updatelog.md
+    pub_date: new Date().toISOString(),
+    platforms: {
+      win64: { signature: "", url: "" }, // compatible with older formats
+      linux: { signature: "", url: "" }, // compatible with older formats
+      darwin: { signature: "", url: "" }, // compatible with older formats
+      "darwin-aarch64": { signature: "", url: "" },
+      "darwin-intel": { signature: "", url: "" },
+      "linux-x86_64": { signature: "", url: "" },
+      "windows-x86_64": { signature: "", url: "" },
+      "windows-i686": { signature: "", url: "" }, // no supported
+    },
+  };
+
+  const promises = latestRelease.assets.map(async (asset) => {
+    const { name, browser_download_url } = asset;
+
+    // win64 url
+    if (name.endsWith(".msi.zip") && name.includes("en-US")) {
+      updateData.platforms.win64.url = browser_download_url;
+      updateData.platforms["windows-x86_64"].url = browser_download_url;
+    }
+    // win64 signature
+    if (name.endsWith(".msi.zip.sig") && name.includes("en-US")) {
+      const sig = await getSignature(browser_download_url);
+      updateData.platforms.win64.signature = sig;
+      updateData.platforms["windows-x86_64"].signature = sig;
+    }
+
+    // darwin url (intel)
+    if (name.endsWith(".app.tar.gz") && !name.includes("aarch")) {
+      updateData.platforms.darwin.url = browser_download_url;
+      updateData.platforms["darwin-intel"].url = browser_download_url;
+    }
+    // darwin signature (intel)
+    if (name.endsWith(".app.tar.gz.sig") && !name.includes("aarch")) {
+      const sig = await getSignature(browser_download_url);
+      updateData.platforms.darwin.signature = sig;
+      updateData.platforms["darwin-intel"].signature = sig;
+    }
+
+    // darwin url (aarch)
+    if (name.endsWith("aarch64.app.tar.gz")) {
+      updateData.platforms["darwin-aarch64"].url = browser_download_url;
+    }
+    // darwin signature (aarch)
+    if (name.endsWith("aarch64.app.tar.gz.sig")) {
+      const sig = await getSignature(browser_download_url);
+      updateData.platforms["darwin-aarch64"].signature = sig;
+    }
+
+    // linux url
+    if (name.endsWith(".AppImage.tar.gz")) {
+      updateData.platforms.linux.url = browser_download_url;
+      updateData.platforms["linux-x86_64"].url = browser_download_url;
+    }
+    // linux signature
+    if (name.endsWith(".AppImage.tar.gz.sig")) {
+      const sig = await getSignature(browser_download_url);
+      updateData.platforms.linux.signature = sig;
+      updateData.platforms["linux-x86_64"].signature = sig;
+    }
+  });
+
+  await Promise.allSettled(promises);
+  console.log(updateData);
+
+  // maybe should test the signature as well
+  // delete the null field
+  Object.entries(updateData.platforms).forEach(([key, value]) => {
+    if (!value.url) {
+      console.log(`[Error]: failed to parse release for "${key}"`);
+      delete updateData.platforms[key];
+    }
+  });
+
+  // 生成一个代理github的更新文件
+  // 使用 https://hub.fastgit.xyz/ 做github资源的加速
+  const updateDataNew = JSON.parse(JSON.stringify(updateData));
+
+  Object.entries(updateDataNew.platforms).forEach(([key, value]) => {
+    if (value.url) {
+      updateDataNew.platforms[key].url = value.url.replace(
+        "https://github.com/",
+        "https://hub.fastgit.xyz/"
+      );
+    } else {
+      console.log(`[Error]: updateDataNew.platforms.${key} is null`);
+    }
+  });
+
+  // update the update.json
+  const { data: updateRelease } = await github.rest.repos.getReleaseByTag({
+    ...options,
+    tag: UPDATE_TAG_NAME,
+  });
+
+  // delete the old assets
+  for (let asset of updateRelease.assets) {
+    if (asset.name === UPDATE_JSON_FILE) {
+      await github.rest.repos.deleteReleaseAsset({
+        ...options,
+        asset_id: asset.id,
+      });
+    }
+
+    if (asset.name === UPDATE_JSON_PROXY) {
+      await github.rest.repos
+        .deleteReleaseAsset({ ...options, asset_id: asset.id })
+        .catch(console.error); // do not break the pipeline
+    }
+  }
+
+  // upload new assets
+  await github.rest.repos.uploadReleaseAsset({
+    ...options,
+    release_id: updateRelease.id,
+    name: UPDATE_JSON_FILE,
+    data: JSON.stringify(updateData, null, 2),
+  });
+
+  await github.rest.repos.uploadReleaseAsset({
+    ...options,
+    release_id: updateRelease.id,
+    name: UPDATE_JSON_PROXY,
+    data: JSON.stringify(updateDataNew, null, 2),
+  });
+}
+
+// get the signature file content
+async function getSignature(url) {
+  const response = await fetch(url, {
+    method: "GET",
+    headers: { "Content-Type": "application/octet-stream" },
+  });
+
+  return response.text();
+}
+
+resolveUpdater().catch(console.error);

src-tauri/.gitignore

@@ -2,5 +2,5 @@
 # will have compiled files and executables
 /target/
 WixTools
-resources/Country.mmdb
+resources
 sidecar

src-tauri/Cargo.toml

@@ -10,32 +10,51 @@ edition = "2021"
 build = "build.rs"
 
 [build-dependencies]
-tauri-build = { version = "1.0.0-beta.4" }
+tauri-build = { version = "1", features = [] }
 
 [dependencies]
-dirs = "4.0.0"
-chrono = "0.4.19"
-serde_json = "1.0"
-serde_yaml = "0.8"
-serde = { version = "1.0", features = ["derive"] }
-# tauri = { version = "1.0.0-beta.8", features = ["api-all", "system-tray"] }
-# tauri = { git = "https://github.com/tauri-apps/tauri", rev = "5e0d59ec", features = ["api-all", "system-tray"] }
-tauri = { git = "https://github.com/tauri-apps/tauri", branch = "next",  features = ["api-all", "system-tray", "updater"] }
-tauri-plugin-shadows = { git = "https://github.com/tauri-apps/tauri-plugin-shadows", features = ["tauri-impl"] }
-tauri-plugin-vibrancy = { git = "https://github.com/tauri-apps/tauri-plugin-vibrancy", features = ["tauri-impl"] }
-
-reqwest = { version = "0.11", features = ["json"] }
-tokio = { version = "1", features = ["full"] }
-log = "0.4.14"
-log4rs = "1.0.0"
 warp = "0.3"
 which = "4.2.2"
-auto-launch = "0.2"
+anyhow = "1.0"
+dirs = "4.0.0"
+open = "3.0.3"
+log = "0.4.14"
+ctrlc = "3.2.3"
+dunce = "1.0.2"
+log4rs = "1.0.0"
+nanoid = "0.4.0"
+chrono = "0.4.19"
+sysinfo = "0.26.2"
+sysproxy = "0.1"
+serde_json = "1.0"
+serde_yaml = "0.9"
+auto-launch = "0.4"
+once_cell = "1.14.0"
 port_scanner = "0.1.5"
+delay_timer = "0.11.1"
+parking_lot = "0.12.0"
+tokio = { version = "1", features = ["full"] }
+serde = { version = "1.0", features = ["derive"] }
+reqwest = { version = "0.11", features = ["json"] }
+tauri = { version = "1.1.1", features = ["global-shortcut-all", "process-all", "shell-all", "system-tray", "updater", "window-all"] }
+rquickjs = { version = "0.1.7" }
+window-shadows = { version = "0.2.0" }
+window-vibrancy = { version = "0.3.0" }
 
 [target.'cfg(windows)'.dependencies]
+runas = "0.2.1"
+deelevate = "0.2.0"
 winreg = { version = "0.10", features = ["transactions"] }
+windows-sys = { version = "0.36", features = ["Win32_System_LibraryLoader", "Win32_System_SystemInformation"] }
 
 [features]
-default = [ "custom-protocol" ]
-custom-protocol = [ "tauri/custom-protocol" ]
+default = ["custom-protocol"]
+custom-protocol = ["tauri/custom-protocol"]
+verge-dev = []
+debug-yml = []
+
+[profile.release]
+panic = "abort"
+codegen-units = 1
+lto = true
+opt-level = "s"

src-tauri/resources/config_tmp.yaml

@@ -1,8 +0,0 @@
-# Default Config For Clash Core
-
-mixed-port: 7890
-log-level: info
-allow-lan: false
-external-controller: 127.0.0.1:9090
-mode: rule
-secret: ""

src-tauri/resources/item_tmp.yaml

@@ -1,16 +0,0 @@
-# Profile Template for clash verge
-
-# the profile's name
-name: New Profile
-
-# the description of this profile(optional)
-description:
-
-# proxies defination (optional, the same as clash)
-proxies:
-
-# proxy-groups (optional, the same as clash)
-proxy-groups:
-
-# rules (optional, the same as clash)
-rules:

src-tauri/resources/profiles_tmp.yaml

@@ -1,3 +0,0 @@
-# Profiles Config for Clash Verge
-
-current: 0

src-tauri/resources/verge_tmp.yaml

@@ -1,6 +0,0 @@
-# Defaulf Config For Clash Verge
-
-theme_mode: light
-enable_self_startup: false
-enable_system_proxy: false
-system_proxy_bypass: localhost;127.*;10.*;172.16.*;172.17.*;172.18.*;172.19.*;172.20.*;172.21.*;172.22.*;172.23.*;172.24.*;172.25.*;172.26.*;172.27.*;172.28.*;172.29.*;172.30.*;172.31.*;192.168.*;<local>

src-tauri/src/cmds.rs

@@ -1,299 +1,361 @@
 use crate::{
-  core::{ClashInfo, ProfileItem, Profiles, VergeConfig},
-  states::{ClashState, ProfilesState, VergeState},
-  utils::{dirs::app_home_dir, fetch::fetch_profile, sysopt::SysProxyConfig},
+  core::Core,
+  data::{ClashInfo, Data, PrfItem, PrfOption, Profiles, Verge},
+  utils::{dirs, help},
 };
+use crate::{log_if_err, ret_err, wrap_err};
+use anyhow::Result;
 use serde_yaml::Mapping;
-use std::process::Command;
-use tauri::State;
+use std::collections::{HashMap, VecDeque};
+use sysproxy::Sysproxy;
+
+type CmdResult<T = ()> = Result<T, String>;
 
 /// get all profiles from `profiles.yaml`
-/// do not acquire the lock of ProfileLock
 #[tauri::command]
-pub fn get_profiles(profiles_state: State<'_, ProfilesState>) -> Result<Profiles, String> {
-  match profiles_state.0.lock() {
-    Ok(profiles) => Ok(profiles.clone()),
-    Err(_) => Err("failed to get profiles lock".into()),
-  }
+pub fn get_profiles() -> CmdResult<Profiles> {
+  let global = Data::global();
+  let profiles = global.profiles.lock();
+  Ok(profiles.clone())
 }
 
-/// synchronize data irregularly
+/// manually exec enhanced profile
 #[tauri::command]
-pub fn sync_profiles(profiles_state: State<'_, ProfilesState>) -> Result<(), String> {
-  match profiles_state.0.lock() {
-    Ok(mut profiles) => profiles.sync_file(),
-    Err(_) => Err("failed to get profiles lock".into()),
-  }
+pub fn enhance_profiles() -> CmdResult {
+  let core = Core::global();
+  wrap_err!(core.activate())
 }
 
 /// import the profile from url
 /// and save to `profiles.yaml`
 #[tauri::command]
-pub async fn import_profile(
-  url: String,
-  with_proxy: bool,
-  profiles_state: State<'_, ProfilesState>,
-) -> Result<(), String> {
-  match fetch_profile(&url, with_proxy).await {
-    Some(result) => {
-      let mut profiles = profiles_state.0.lock().unwrap();
-      profiles.import_from_url(url, result)
-    }
-    None => Err(format!("failed to fetch profile from `{}`", url)),
-  }
+pub async fn import_profile(url: String, option: Option<PrfOption>) -> CmdResult {
+  let item = wrap_err!(PrfItem::from_url(&url, None, None, option).await)?;
+
+  let global = Data::global();
+  let mut profiles = global.profiles.lock();
+  wrap_err!(profiles.append_item(item))
 }
 
 /// new a profile
 /// append a temp profile item file to the `profiles` dir
 /// view the temp profile file by using vscode or other editor
 #[tauri::command]
-pub async fn new_profile(
-  name: String,
-  desc: String,
-  profiles_state: State<'_, ProfilesState>,
-) -> Result<(), String> {
-  let mut profiles = profiles_state.0.lock().unwrap();
+pub async fn create_profile(item: PrfItem, file_data: Option<String>) -> CmdResult {
+  let item = wrap_err!(PrfItem::from(item, file_data).await)?;
 
-  let (_, path) = profiles.append_item(name, desc)?;
-
-  if !path.exists() {
-    return Err("the file not found".into());
-  }
-
-  // use vscode first
-  if let Ok(code) = which::which("code") {
-    return match Command::new(code).arg(path).status() {
-      Ok(_) => Ok(()),
-      Err(_) => Err("failed to open file by VScode".into()),
-    };
-  }
-
-  // use `open` command
-  if let Ok(open) = which::which("open") {
-    return match Command::new(open).arg(path).status() {
-      Ok(_) => Ok(()),
-      Err(_) => Err("failed to open file by `open`".into()),
-    };
-  }
-
-  return Err("failed to open the file, please edit the file manually".into());
+  let global = Data::global();
+  let mut profiles = global.profiles.lock();
+  wrap_err!(profiles.append_item(item))
 }
 
 /// Update the profile
 #[tauri::command]
-pub async fn update_profile(
-  index: usize,
-  with_proxy: bool,
-  clash_state: State<'_, ClashState>,
-  profiles_state: State<'_, ProfilesState>,
-) -> Result<(), String> {
-  // maybe we can get the url from the web app directly
-  let url = match profiles_state.0.lock() {
-    Ok(mut profile) => {
-      let items = profile.items.take().unwrap_or(vec![]);
-      if index >= items.len() {
-        return Err("the index out of bound".into());
-      }
-      let url = match &items[index].url {
-        Some(u) => u.clone(),
-        None => return Err("failed to update profile for `invalid url`".into()),
-      };
-      profile.items = Some(items);
-      url
-    }
-    Err(_) => return Err("failed to get profiles lock".into()),
-  };
-
-  match fetch_profile(&url, with_proxy).await {
-    Some(result) => match profiles_state.0.lock() {
-      Ok(mut profiles) => {
-        profiles.update_item(index, result)?;
-
-        // reactivate the profile
-        let current = profiles.current.clone().unwrap_or(0);
-        if current == index {
-          let clash = clash_state.0.lock().unwrap();
-          profiles.activate(&clash)
-        } else {
-          Ok(())
-        }
-      }
-      Err(_) => Err("failed to get profiles lock".into()),
-    },
-    None => Err(format!("failed to fetch profile from `{}`", url)),
-  }
+pub async fn update_profile(index: String, option: Option<PrfOption>) -> CmdResult {
+  let core = Core::global();
+  wrap_err!(core.update_profile_item(index, option).await)
 }
 
 /// change the current profile
 #[tauri::command]
-pub fn select_profile(
-  index: usize,
-  clash_state: State<'_, ClashState>,
-  profiles_state: State<'_, ProfilesState>,
-) -> Result<(), String> {
-  let mut profiles = profiles_state.0.lock().unwrap();
+pub fn select_profile(index: String) -> CmdResult {
+  let global = Data::global();
+  let mut profiles = global.profiles.lock();
+  wrap_err!(profiles.put_current(index))?;
+  drop(profiles);
 
-  match profiles.put_current(index) {
-    Ok(()) => {
-      let clash = clash_state.0.lock().unwrap();
-      profiles.activate(&clash)
-    }
-    Err(err) => Err(err),
-  }
+  let core = Core::global();
+  wrap_err!(core.activate())
+}
+
+/// change the profile chain
+#[tauri::command]
+pub fn change_profile_chain(chain: Option<Vec<String>>) -> CmdResult {
+  let global = Data::global();
+  let mut profiles = global.profiles.lock();
+  wrap_err!(profiles.put_chain(chain))?;
+  drop(profiles);
+
+  let core = Core::global();
+  wrap_err!(core.activate())
+}
+
+/// change the profile valid fields
+#[tauri::command]
+pub fn change_profile_valid(valid: Option<Vec<String>>) -> CmdResult {
+  let global = Data::global();
+  let mut profiles = global.profiles.lock();
+  wrap_err!(profiles.put_valid(valid))?;
+  drop(profiles);
+
+  let core = Core::global();
+  wrap_err!(core.activate())
 }
 
 /// delete profile item
 #[tauri::command]
-pub fn delete_profile(
-  index: usize,
-  clash_state: State<'_, ClashState>,
-  profiles_state: State<'_, ProfilesState>,
-) -> Result<(), String> {
-  let mut profiles = profiles_state.0.lock().unwrap();
-  match profiles.delete_item(index) {
-    Ok(change) => match change {
-      true => {
-        let clash = clash_state.0.lock().unwrap();
-        profiles.activate(&clash)
-      }
-      false => Ok(()),
-    },
-    Err(err) => Err(err),
+pub fn delete_profile(index: String) -> CmdResult {
+  let global = Data::global();
+  let mut profiles = global.profiles.lock();
+  if wrap_err!(profiles.delete_item(index))? {
+    drop(profiles);
+
+    let core = Core::global();
+    log_if_err!(core.activate());
   }
+  Ok(())
 }
 
 /// patch the profile config
 #[tauri::command]
-pub fn patch_profile(
-  index: usize,
-  profile: ProfileItem,
-  profiles_state: State<'_, ProfilesState>,
-) -> Result<(), String> {
-  match profiles_state.0.lock() {
-    Ok(mut profiles) => profiles.patch_item(index, profile),
-    Err(_) => Err("can not get profiles lock".into()),
-  }
+pub fn patch_profile(index: String, profile: PrfItem) -> CmdResult {
+  let global = Data::global();
+  let mut profiles = global.profiles.lock();
+  wrap_err!(profiles.patch_item(index, profile))?;
+  drop(profiles);
+
+  // update cron task
+  let core = Core::global();
+  let mut timer = core.timer.lock();
+  wrap_err!(timer.refresh())
 }
 
 /// run vscode command to edit the profile
 #[tauri::command]
-pub fn view_profile(index: usize, profiles_state: State<'_, ProfilesState>) -> Result<(), String> {
-  let mut profiles = profiles_state.0.lock().unwrap();
-  let items = profiles.items.take().unwrap_or(vec![]);
+pub fn view_profile(index: String) -> CmdResult {
+  let global = Data::global();
+  let profiles = global.profiles.lock();
+  let item = wrap_err!(profiles.get_item(&index))?;
 
-  if index >= items.len() {
-    profiles.items = Some(items);
-    return Err("the index out of bound".into());
+  let file = item.file.clone();
+  if file.is_none() {
+    ret_err!("file is null");
   }
 
-  let file = items[index].file.clone().unwrap_or("".into());
-  profiles.items = Some(items);
-
-  let path = app_home_dir().join("profiles").join(file);
+  let path = dirs::app_profiles_dir().join(file.unwrap());
   if !path.exists() {
-    return Err("the file not found".into());
+    ret_err!("file not found");
   }
 
-  // use vscode first
-  if let Ok(code) = which::which("code") {
-    return match Command::new(code).arg(path).status() {
-      Ok(_) => Ok(()),
-      Err(_) => Err("failed to open file by VScode".into()),
-    };
-  }
-
-  // use `open` command
-  if let Ok(open) = which::which("open") {
-    return match Command::new(open).arg(path).status() {
-      Ok(_) => Ok(()),
-      Err(_) => Err("failed to open file by `open`".into()),
-    };
-  }
-
-  // recommand to use vscode
-  // todo: support other editors
-  return Err("please install VScode".into());
+  wrap_err!(help::open_file(path))
 }
 
-/// restart the sidecar
+/// read the profile item file data
 #[tauri::command]
-pub fn restart_sidecar(
-  clash_state: State<'_, ClashState>,
-  profiles_state: State<'_, ProfilesState>,
-) -> Result<(), String> {
-  let mut clash = clash_state.0.lock().unwrap();
-  let mut profiles = profiles_state.0.lock().unwrap();
+pub fn read_profile_file(index: String) -> CmdResult<String> {
+  let global = Data::global();
+  let profiles = global.profiles.lock();
+  let item = wrap_err!(profiles.get_item(&index))?;
+  let data = wrap_err!(item.read_file())?;
+  Ok(data)
+}
 
-  match clash.restart_sidecar(&mut profiles) {
-    Ok(_) => Ok(()),
-    Err(err) => {
-      log::error!("{}", err);
-      Err(err)
-    }
+/// save the profile item file data
+#[tauri::command]
+pub fn save_profile_file(index: String, file_data: Option<String>) -> CmdResult {
+  if file_data.is_none() {
+    return Ok(());
   }
+
+  let global = Data::global();
+  let profiles = global.profiles.lock();
+  let item = wrap_err!(profiles.get_item(&index))?;
+  wrap_err!(item.save_file(file_data.unwrap()))
 }
 
 /// get the clash core info from the state
 /// the caller can also get the infomation by clash's api
 #[tauri::command]
-pub fn get_clash_info(clash_state: State<'_, ClashState>) -> Result<ClashInfo, String> {
-  match clash_state.0.lock() {
-    Ok(clash) => Ok(clash.info.clone()),
-    Err(_) => Err("failed to get clash lock".into()),
-  }
+pub fn get_clash_info() -> CmdResult<ClashInfo> {
+  let global = Data::global();
+  let clash = global.clash.lock();
+  Ok(clash.info.clone())
+}
+
+/// get the runtime clash config mapping
+#[tauri::command]
+pub fn get_runtime_config() -> CmdResult<Option<Mapping>> {
+  let core = Core::global();
+  let rt = core.runtime.lock();
+  Ok(rt.config.clone())
+}
+
+/// get the runtime clash config yaml string
+#[tauri::command]
+pub fn get_runtime_yaml() -> CmdResult<Option<String>> {
+  let core = Core::global();
+  let rt = core.runtime.lock();
+  Ok(rt.config_yaml.clone())
+}
+
+/// get the runtime config exists keys
+#[tauri::command]
+pub fn get_runtime_exists() -> CmdResult<Vec<String>> {
+  let core = Core::global();
+  let rt = core.runtime.lock();
+  Ok(rt.exists_keys.clone())
+}
+
+/// get the runtime enhanced chain log
+#[tauri::command]
+pub fn get_runtime_logs() -> CmdResult<HashMap<String, Vec<(String, String)>>> {
+  let core = Core::global();
+  let rt = core.runtime.lock();
+  Ok(rt.chain_logs.clone())
 }
 
 /// update the clash core config
 /// after putting the change to the clash core
 /// then we should save the latest config
 #[tauri::command]
-pub fn patch_clash_config(
-  payload: Mapping,
-  clash_state: State<'_, ClashState>,
-  verge_state: State<'_, VergeState>,
-  profiles_state: State<'_, ProfilesState>,
-) -> Result<(), String> {
-  let mut clash = clash_state.0.lock().unwrap();
-  let mut verge = verge_state.0.lock().unwrap();
-  let mut profiles = profiles_state.0.lock().unwrap();
-  clash.patch_config(payload, &mut verge, &mut profiles)
+pub fn patch_clash_config(payload: Mapping) -> CmdResult {
+  let core = Core::global();
+  wrap_err!(core.patch_clash(payload))
 }
 
-/// get the system proxy
 #[tauri::command]
-pub fn get_sys_proxy() -> Result<SysProxyConfig, String> {
-  match SysProxyConfig::get_sys() {
-    Ok(value) => Ok(value),
-    Err(err) => Err(err.to_string()),
-  }
-}
-
-/// get the current proxy config
-/// which may not the same as system proxy
-#[tauri::command]
-pub fn get_cur_proxy(verge_state: State<'_, VergeState>) -> Result<Option<SysProxyConfig>, String> {
-  match verge_state.0.lock() {
-    Ok(verge) => Ok(verge.cur_sysproxy.clone()),
-    Err(_) => Err("failed to get verge lock".into()),
-  }
-}
-
-/// get the verge config
-#[tauri::command]
-pub fn get_verge_config(verge_state: State<'_, VergeState>) -> Result<VergeConfig, String> {
-  match verge_state.0.lock() {
-    Ok(arc) => Ok(arc.config.clone()),
-    Err(_) => Err("failed to get verge lock".into()),
-  }
+pub fn get_verge_config() -> CmdResult<Verge> {
+  let global = Data::global();
+  let verge = global.verge.lock();
+  Ok(verge.clone())
 }
 
 /// patch the verge config
 /// this command only save the config and not responsible for other things
 #[tauri::command]
-pub async fn patch_verge_config(
-  payload: VergeConfig,
-  verge_state: State<'_, VergeState>,
-) -> Result<(), String> {
-  let mut verge = verge_state.0.lock().unwrap();
-  verge.patch_config(payload)
+pub fn patch_verge_config(payload: Verge) -> CmdResult {
+  let core = Core::global();
+  wrap_err!(core.patch_verge(payload))
+}
+
+#[tauri::command]
+pub fn update_hotkeys(hotkeys: Vec<String>) -> CmdResult {
+  let core = Core::global();
+  let mut hotkey = core.hotkey.lock();
+  wrap_err!(hotkey.update(hotkeys))
+}
+
+/// change clash core
+#[tauri::command]
+pub fn change_clash_core(clash_core: Option<String>) -> CmdResult {
+  let core = Core::global();
+  wrap_err!(core.change_core(clash_core))
+}
+
+/// restart the sidecar
+#[tauri::command]
+pub fn restart_sidecar() -> CmdResult {
+  let core = Core::global();
+  wrap_err!(core.restart_clash())
+}
+
+/// kill all sidecars when update app
+#[tauri::command]
+pub fn kill_sidecar() {
+  tauri::api::process::kill_children();
+}
+
+/// get the system proxy
+#[tauri::command]
+pub fn get_sys_proxy() -> CmdResult<Mapping> {
+  let current = wrap_err!(Sysproxy::get_system_proxy())?;
+
+  let mut map = Mapping::new();
+  map.insert("enable".into(), current.enable.into());
+  map.insert(
+    "server".into(),
+    format!("{}:{}", current.host, current.port).into(),
+  );
+  map.insert("bypass".into(), current.bypass.into());
+
+  Ok(map)
+}
+
+#[tauri::command]
+pub fn get_clash_logs() -> CmdResult<VecDeque<String>> {
+  let core = Core::global();
+  let service = core.service.lock();
+  Ok(service.get_logs())
+}
+
+/// open app config dir
+#[tauri::command]
+pub fn open_app_dir() -> CmdResult<()> {
+  let app_dir = dirs::app_home_dir();
+  wrap_err!(open::that(app_dir))
+}
+
+/// open logs dir
+#[tauri::command]
+pub fn open_logs_dir() -> CmdResult<()> {
+  let log_dir = dirs::app_logs_dir();
+  wrap_err!(open::that(log_dir))
+}
+
+/// open url
+#[tauri::command]
+pub fn open_web_url(url: String) -> CmdResult<()> {
+  wrap_err!(open::that(url))
+}
+
+/// service mode
+#[cfg(windows)]
+pub mod service {
+  use super::*;
+  use crate::core::win_service::JsonResponse;
+
+  #[tauri::command]
+  pub async fn start_service() -> CmdResult<()> {
+    wrap_err!(crate::core::Service::start_service().await)
+  }
+
+  #[tauri::command]
+  pub async fn stop_service() -> CmdResult<()> {
+    wrap_err!(crate::core::Service::stop_service().await)
+  }
+
+  #[tauri::command]
+  pub async fn check_service() -> CmdResult<JsonResponse> {
+    // no log
+    match crate::core::Service::check_service().await {
+      Ok(res) => Ok(res),
+      Err(err) => Err(err.to_string()),
+    }
+  }
+
+  #[tauri::command]
+  pub async fn install_service() -> CmdResult<()> {
+    wrap_err!(crate::core::Service::install_service().await)
+  }
+
+  #[tauri::command]
+  pub async fn uninstall_service() -> CmdResult<()> {
+    wrap_err!(crate::core::Service::uninstall_service().await)
+  }
+}
+
+#[cfg(not(windows))]
+pub mod service {
+  use super::*;
+
+  #[tauri::command]
+  pub async fn start_service() -> CmdResult<()> {
+    Ok(())
+  }
+  #[tauri::command]
+  pub async fn stop_service() -> CmdResult<()> {
+    Ok(())
+  }
+  #[tauri::command]
+  pub async fn check_service() -> CmdResult<()> {
+    Ok(())
+  }
+  #[tauri::command]
+  pub async fn install_service() -> CmdResult<()> {
+    Ok(())
+  }
+  #[tauri::command]
+  pub async fn uninstall_service() -> CmdResult<()> {
+    Ok(())
+  }
 }

src-tauri/src/config/field.rs

@@ -0,0 +1,118 @@
+use serde_yaml::{Mapping, Value};
+
+pub const HANDLE_FIELDS: [&str; 9] = [
+  "port",
+  "socks-port",
+  "mixed-port",
+  "mode",
+  "ipv6",
+  "log-level",
+  "allow-lan",
+  "external-controller",
+  "secret",
+];
+
+pub const DEFAULT_FIELDS: [&str; 5] = [
+  "proxies",
+  "proxy-groups",
+  "rules",
+  "proxy-providers",
+  "rule-providers",
+];
+
+pub const OTHERS_FIELDS: [&str; 20] = [
+  "tun",
+  "dns",
+  "ebpf",
+  "hosts",
+  "script",
+  "profile",
+  "payload",
+  "auto-redir",
+  "experimental",
+  "interface-name",
+  "routing-mark",
+  "redir-port",
+  "tproxy-port",
+  "iptables",
+  "external-ui",
+  "bind-address",
+  "authentication",
+  "sniffer",        // meta
+  "geodata-mode",   // meta
+  "tcp-concurrent", // meta
+];
+
+pub fn use_clash_fields() -> Vec<String> {
+  DEFAULT_FIELDS
+    .into_iter()
+    .chain(HANDLE_FIELDS)
+    .chain(OTHERS_FIELDS)
+    .map(|s| s.to_string())
+    .collect()
+}
+
+pub fn use_valid_fields(mut valid: Vec<String>) -> Vec<String> {
+  let others = Vec::from(OTHERS_FIELDS);
+
+  valid.iter_mut().for_each(|s| s.make_ascii_lowercase());
+  valid
+    .into_iter()
+    .filter(|s| others.contains(&s.as_str()))
+    .chain(DEFAULT_FIELDS.iter().map(|s| s.to_string()))
+    .collect()
+}
+
+pub fn use_filter(config: Mapping, filter: &Vec<String>) -> Mapping {
+  let mut ret = Mapping::new();
+
+  for (key, value) in config.into_iter() {
+    if let Some(key) = key.as_str() {
+      if filter.contains(&key.to_string()) {
+        ret.insert(Value::from(key), value);
+      }
+    }
+  }
+  ret
+}
+
+pub fn use_lowercase(config: Mapping) -> Mapping {
+  let mut ret = Mapping::new();
+
+  for (key, value) in config.into_iter() {
+    if let Some(key_str) = key.as_str() {
+      let mut key_str = String::from(key_str);
+      key_str.make_ascii_lowercase();
+      ret.insert(Value::from(key_str), value);
+    }
+  }
+  ret
+}
+
+pub fn use_sort(config: Mapping) -> Mapping {
+  let mut ret = Mapping::new();
+
+  HANDLE_FIELDS
+    .into_iter()
+    .chain(OTHERS_FIELDS)
+    .chain(DEFAULT_FIELDS)
+    .for_each(|key| {
+      let key = Value::from(key);
+      config.get(&key).map(|value| {
+        ret.insert(key, value.clone());
+      });
+    });
+  ret
+}
+
+pub fn use_keys(config: &Mapping) -> Vec<String> {
+  config
+    .iter()
+    .filter_map(|(key, _)| key.as_str())
+    .map(|s| {
+      let mut s = s.to_string();
+      s.make_ascii_lowercase();
+      return s;
+    })
+    .collect()
+}

src-tauri/src/config/merge.rs

@@ -0,0 +1,93 @@
+use super::{use_filter, use_lowercase};
+use serde_yaml::{self, Mapping, Sequence, Value};
+
+#[allow(unused)]
+const MERGE_FIELDS: [&str; 6] = [
+  "prepend-rules",
+  "append-rules",
+  "prepend-proxies",
+  "append-proxies",
+  "prepend-proxy-groups",
+  "append-proxy-groups",
+];
+
+pub fn use_merge(merge: Mapping, mut config: Mapping) -> Mapping {
+  // 直接覆盖原字段
+  use_lowercase(merge.clone())
+    .into_iter()
+    .for_each(|(key, value)| {
+      config.insert(key, value);
+    });
+
+  let merge_list = MERGE_FIELDS.iter().map(|s| s.to_string());
+  let merge = use_filter(merge, &merge_list.collect());
+
+  ["rules", "proxies", "proxy-groups"]
+    .iter()
+    .for_each(|key_str| {
+      let key_val = Value::from(key_str.to_string());
+
+      let mut list = Sequence::default();
+      list = config.get(&key_val).map_or(list.clone(), |val| {
+        val.as_sequence().map_or(list, |v| v.clone())
+      });
+
+      let pre_key = Value::from(format!("prepend-{key_str}"));
+      let post_key = Value::from(format!("append-{key_str}"));
+
+      if let Some(pre_val) = merge.get(&pre_key) {
+        if pre_val.is_sequence() {
+          let mut pre_val = pre_val.as_sequence().unwrap().clone();
+          pre_val.extend(list);
+          list = pre_val;
+        }
+      }
+
+      if let Some(post_val) = merge.get(&post_key) {
+        if post_val.is_sequence() {
+          list.extend(post_val.as_sequence().unwrap().clone());
+        }
+      }
+
+      config.insert(key_val, Value::from(list));
+    });
+  config
+}
+
+#[test]
+fn test_merge() -> anyhow::Result<()> {
+  let merge = r"
+    prepend-rules:
+      - prepend
+      - 1123123
+    append-rules:
+      - append
+    prepend-proxies:
+      - 9999
+    append-proxies:
+      - 1111
+    rules:
+      - replace
+    proxy-groups: 
+      - 123781923810
+    tun:
+      enable: true
+    dns:
+      enable: true
+  ";
+
+  let config = r"
+    rules:
+      - aaaaa
+    script1: test
+  ";
+
+  let merge = serde_yaml::from_str::<Mapping>(merge)?;
+  let config = serde_yaml::from_str::<Mapping>(config)?;
+
+  let result = serde_yaml::to_string(&use_merge(merge, config))?;
+
+  println!("{result}");
+
+  Ok(())
+}

src-tauri/src/config/mod.rs

@@ -0,0 +1,69 @@
+mod field;
+mod merge;
+mod script;
+mod tun;
+
+pub(self) use self::field::*;
+use self::merge::*;
+use self::script::*;
+use self::tun::*;
+use crate::data::ChainItem;
+use crate::data::ChainType;
+use serde_yaml::Mapping;
+use std::collections::HashMap;
+use std::collections::HashSet;
+
+type ResultLog = Vec<(String, String)>;
+
+pub fn enhance_config(
+  clash_config: Mapping,
+  profile_config: Mapping,
+  chain: Vec<ChainItem>,
+  valid: Vec<String>,
+  tun_mode: bool,
+) -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
+  let mut config = profile_config;
+  let mut result_map = HashMap::new();
+  let mut exists_keys = use_keys(&config);
+
+  let valid = use_valid_fields(valid);
+
+  chain.into_iter().for_each(|item| match item.data {
+    ChainType::Merge(merge) => {
+      exists_keys.extend(use_keys(&merge));
+      config = use_merge(merge, config.to_owned());
+      config = use_filter(config.to_owned(), &valid);
+    }
+    ChainType::Script(script) => {
+      let mut logs = vec![];
+
+      match use_script(script, config.to_owned()) {
+        Ok((res_config, res_logs)) => {
+          exists_keys.extend(use_keys(&res_config));
+          config = use_filter(res_config, &valid);
+          logs.extend(res_logs);
+        }
+        Err(err) => logs.push(("exception".into(), err.to_string())),
+      }
+
+      result_map.insert(item.uid, logs);
+    }
+  });
+
+  config = use_filter(config, &valid);
+
+  for (key, value) in clash_config.into_iter() {
+    config.insert(key, value);
+  }
+
+  let clash_fields = use_clash_fields();
+  config = use_filter(config, &clash_fields);
+  config = use_tun(config, tun_mode);
+  config = use_sort(config);
+
+  let mut exists_set = HashSet::new();
+  exists_set.extend(exists_keys.into_iter().filter(|s| clash_fields.contains(s)));
+  exists_keys = exists_set.into_iter().collect();
+
+  (config, exists_keys, result_map)
+}

src-tauri/src/config/script.rs

@@ -0,0 +1,94 @@
+use super::use_lowercase;
+use anyhow::Result;
+use serde_yaml::Mapping;
+
+pub fn use_script(script: String, config: Mapping) -> Result<(Mapping, Vec<(String, String)>)> {
+  use rquickjs::{Context, Func, Runtime};
+  use std::sync::{Arc, Mutex};
+
+  let runtime = Runtime::new().unwrap();
+  let context = Context::full(&runtime).unwrap();
+  let outputs = Arc::new(Mutex::new(vec![]));
+
+  let copy_outputs = outputs.clone();
+  let result = context.with(|ctx| -> Result<Mapping> {
+    ctx.globals().set(
+      "__verge_log__",
+      Func::from(move |level: String, data: String| {
+        let mut out = copy_outputs.lock().unwrap();
+        out.push((level, data));
+      }),
+    )?;
+
+    ctx.eval(
+      r#"var console = Object.freeze({
+        log(data){__verge_log__("log",JSON.stringify(data))}, 
+        info(data){__verge_log__("info",JSON.stringify(data))}, 
+        error(data){__verge_log__("error",JSON.stringify(data))},
+        debug(data){__verge_log__("debug",JSON.stringify(data))},
+      });"#,
+    )?;
+
+    let config = use_lowercase(config.clone());
+    let config_str = serde_json::to_string(&config)?;
+
+    let code = format!(
+      r#"try{{
+        {script};
+        JSON.stringify(main({config_str})||'')
+      }} catch(err) {{
+        `__error_flag__ ${{err.toString()}}`
+      }}"#
+    );
+    let result: String = ctx.eval(code.as_str())?;
+    if result.starts_with("__error_flag__") {
+      anyhow::bail!(result[15..].to_owned());
+    }
+    if result == "\"\"" {
+      anyhow::bail!("main function should return object");
+    }
+    return Ok(serde_json::from_str::<Mapping>(result.as_str())?);
+  });
+
+  let mut out = outputs.lock().unwrap();
+  match result {
+    Ok(config) => Ok((use_lowercase(config), out.to_vec())),
+    Err(err) => {
+      out.push(("exception".into(), err.to_string()));
+      Ok((config, out.to_vec()))
+    }
+  }
+}
+
+#[test]
+fn test_script() {
+  let script = r#"
+    function main(config) {
+      if (Array.isArray(config.rules)) {
+        config.rules = [...config.rules, "add"];
+      }
+      console.log(config);
+      config.proxies = ["111"];
+      return config;
+    }
+  "#;
+
+  let config = r#"
+    rules:
+      - 111
+      - 222
+    tun:
+      enable: false
+    dns:
+      enable: false
+  "#;
+
+  let config = serde_yaml::from_str(config).unwrap();
+  let (config, results) = use_script(script.into(), config).unwrap();
+
+  let config_str = serde_yaml::to_string(&config).unwrap();
+
+  println!("{config_str}");
+
+  dbg!(results);
+}

src-tauri/src/config/tun.rs

@@ -0,0 +1,81 @@
+use serde_yaml::{Mapping, Value};
+
+macro_rules! revise {
+  ($map: expr, $key: expr, $val: expr) => {
+    let ret_key = Value::String($key.into());
+    $map.insert(ret_key, Value::from($val));
+  };
+}
+
+// if key not exists then append value
+macro_rules! append {
+  ($map: expr, $key: expr, $val: expr) => {
+    let ret_key = Value::String($key.into());
+    if !$map.contains_key(&ret_key) {
+      $map.insert(ret_key, Value::from($val));
+    }
+  };
+}
+
+pub fn use_tun(mut config: Mapping, enable: bool) -> Mapping {
+  let tun_key = Value::from("tun");
+  let tun_val = config.get(&tun_key);
+
+  if !enable && tun_val.is_none() {
+    return config;
+  }
+
+  let mut tun_val = tun_val.map_or(Mapping::new(), |val| {
+    val.as_mapping().cloned().unwrap_or(Mapping::new())
+  });
+
+  revise!(tun_val, "enable", enable);
+  if enable {
+    append!(tun_val, "stack", "gvisor");
+    append!(tun_val, "dns-hijack", vec!["198.18.0.2:53"]);
+    append!(tun_val, "auto-route", true);
+    append!(tun_val, "auto-detect-interface", true);
+  }
+
+  revise!(config, "tun", tun_val);
+
+  if enable {
+    use_dns_for_tun(config)
+  } else {
+    config
+  }
+}
+
+fn use_dns_for_tun(mut config: Mapping) -> Mapping {
+  let dns_key = Value::from("dns");
+  let dns_val = config.get(&dns_key);
+
+  let mut dns_val = dns_val.map_or(Mapping::new(), |val| {
+    val.as_mapping().cloned().unwrap_or(Mapping::new())
+  });
+
+  // 开启tun将同时开启dns
+  revise!(dns_val, "enable", true);
+
+  // 借鉴cfw的默认配置
+  append!(dns_val, "enhanced-mode", "fake-ip");
+  append!(
+    dns_val,
+    "nameserver",
+    vec!["114.114.114.114", "223.5.5.5", "8.8.8.8"]
+  );
+  append!(dns_val, "fallback", vec![] as Vec<&str>);
+
+  #[cfg(target_os = "windows")]
+  append!(
+    dns_val,
+    "fake-ip-filter",
+    vec![
+      "dns.msftncsi.com",
+      "www.msftncsi.com",
+      "www.msftconnecttest.com"
+    ]
+  );
+  revise!(config, "dns", dns_val);
+  config
+}

src-tauri/src/core/clash.rs

@@ -1,220 +0,0 @@
-use super::{Profiles, Verge};
-use crate::utils::{config, dirs};
-use serde::{Deserialize, Serialize};
-use serde_yaml::{Mapping, Value};
-use tauri::api::process::{Command, CommandChild, CommandEvent};
-
-#[derive(Default, Debug, Clone, Deserialize, Serialize)]
-pub struct ClashInfo {
-  /// clash sidecar status
-  pub status: String,
-
-  /// clash core port
-  pub port: Option<String>,
-
-  /// same as `external-controller`
-  pub server: Option<String>,
-
-  /// clash secret
-  pub secret: Option<String>,
-}
-
-#[derive(Debug)]
-pub struct Clash {
-  /// maintain the clash config
-  pub config: Mapping,
-
-  /// some info
-  pub info: ClashInfo,
-
-  /// clash sidecar
-  pub sidecar: Option<CommandChild>,
-}
-
-static CLASH_CONFIG: &str = "config.yaml";
-
-// todo: be able to change config field
-impl Clash {
-  pub fn new() -> Clash {
-    let config = Clash::get_config();
-    let info = Clash::get_info(&config);
-
-    Clash {
-      config,
-      info,
-      sidecar: None,
-    }
-  }
-
-  /// parse the clash's config.yaml
-  /// get some information
-  fn get_info(clash_config: &Mapping) -> ClashInfo {
-    let key_port_1 = Value::String("port".to_string());
-    let key_port_2 = Value::String("mixed-port".to_string());
-    let key_server = Value::String("external-controller".to_string());
-    let key_secret = Value::String("secret".to_string());
-
-    let port = match clash_config.get(&key_port_1) {
-      Some(value) => match value {
-        Value::String(val_str) => Some(val_str.clone()),
-        Value::Number(val_num) => Some(val_num.to_string()),
-        _ => None,
-      },
-      _ => None,
-    };
-    let port = match port {
-      Some(_) => port,
-      None => match clash_config.get(&key_port_2) {
-        Some(value) => match value {
-          Value::String(val_str) => Some(val_str.clone()),
-          Value::Number(val_num) => Some(val_num.to_string()),
-          _ => None,
-        },
-        _ => None,
-      },
-    };
-
-    let server = match clash_config.get(&key_server) {
-      Some(value) => match value {
-        Value::String(val_str) => Some(val_str.clone()),
-        _ => None,
-      },
-      _ => None,
-    };
-    let secret = match clash_config.get(&key_secret) {
-      Some(value) => match value {
-        Value::String(val_str) => Some(val_str.clone()),
-        Value::Bool(val_bool) => Some(val_bool.to_string()),
-        Value::Number(val_num) => Some(val_num.to_string()),
-        _ => None,
-      },
-      _ => None,
-    };
-
-    ClashInfo {
-      status: "init".into(),
-      port,
-      server,
-      secret,
-    }
-  }
-
-  /// run clash sidecar
-  pub fn run_sidecar(&mut self) -> Result<(), String> {
-    let app_dir = dirs::app_home_dir();
-    let app_dir = app_dir.as_os_str().to_str().unwrap();
-
-    match Command::new_sidecar("clash") {
-      Ok(cmd) => match cmd.args(["-d", app_dir]).spawn() {
-        Ok((mut rx, cmd_child)) => {
-          self.sidecar = Some(cmd_child);
-
-          // clash log
-          tauri::async_runtime::spawn(async move {
-            while let Some(event) = rx.recv().await {
-              match event {
-                CommandEvent::Stdout(line) => log::info!("[stdout]: {}", line),
-                CommandEvent::Stderr(err) => log::error!("[stderr]: {}", err),
-                _ => {}
-              }
-            }
-          });
-          Ok(())
-        }
-        Err(err) => Err(err.to_string()),
-      },
-      Err(err) => Err(err.to_string()),
-    }
-  }
-
-  /// drop clash sidecar
-  pub fn drop_sidecar(&mut self) -> Result<(), String> {
-    if let Some(sidecar) = self.sidecar.take() {
-      if let Err(err) = sidecar.kill() {
-        return Err(format!("failed to drop clash for \"{}\"", err));
-      }
-    }
-    Ok(())
-  }
-
-  /// restart clash sidecar
-  /// should reactivate profile after restart
-  pub fn restart_sidecar(&mut self, profiles: &mut Profiles) -> Result<(), String> {
-    self.update_config();
-    self.drop_sidecar()?;
-    self.run_sidecar()?;
-    profiles.activate(&self)
-  }
-
-  /// update the clash info
-  pub fn update_config(&mut self) {
-    self.config = Clash::get_config();
-    self.info = Clash::get_info(&self.config);
-  }
-
-  /// get clash config
-  fn get_config() -> Mapping {
-    config::read_yaml::<Mapping>(dirs::app_home_dir().join(CLASH_CONFIG))
-  }
-
-  /// save the clash config
-  fn save_config(&self) -> Result<(), String> {
-    config::save_yaml(
-      dirs::app_home_dir().join(CLASH_CONFIG),
-      &self.config,
-      Some("# Default Config For Clash Core\n\n"),
-    )
-  }
-
-  /// patch update the clash config
-  pub fn patch_config(
-    &mut self,
-    patch: Mapping,
-    verge: &mut Verge,
-    profiles: &mut Profiles,
-  ) -> Result<(), String> {
-    for (key, value) in patch.iter() {
-      let value = value.clone();
-      let key_str = key.as_str().clone().unwrap_or("");
-
-      // restart the clash
-      if key_str == "mixed-port" {
-        self.restart_sidecar(profiles)?;
-
-        let port = if value.is_number() {
-          match value.as_i64().clone() {
-            Some(num) => Some(format!("{num}")),
-            None => None,
-          }
-        } else {
-          match value.as_str().clone() {
-            Some(num) => Some(num.into()),
-            None => None,
-          }
-        };
-        verge.init_sysproxy(port);
-      }
-
-      if self.config.contains_key(key) {
-        self.config[key] = value;
-      } else {
-        self.config.insert(key.clone(), value);
-      }
-    }
-    self.save_config()
-  }
-}
-
-impl Default for Clash {
-  fn default() -> Self {
-    Clash::new()
-  }
-}
-
-impl Drop for Clash {
-  fn drop(&mut self) {
-    if let Err(err) = self.drop_sidecar() {
-      log::error!("{}", err);
-    }
-  }
-}

src-tauri/src/core/handle.rs

@@ -0,0 +1,107 @@
+use crate::data::*;
+use crate::log_if_err;
+use anyhow::{bail, Result};
+use serde_yaml::Value;
+use tauri::{AppHandle, Manager, Window};
+
+#[derive(Debug, Default, Clone)]
+pub struct Handle {
+  pub app_handle: Option<AppHandle>,
+}
+
+impl Handle {
+  pub fn set_inner(&mut self, app_handle: AppHandle) {
+    self.app_handle = Some(app_handle);
+  }
+
+  pub fn get_window(&self) -> Option<Window> {
+    self
+      .app_handle
+      .as_ref()
+      .map_or(None, |a| a.get_window("main"))
+  }
+
+  pub fn refresh_clash(&self) {
+    if let Some(window) = self.get_window() {
+      log_if_err!(window.emit("verge://refresh-clash-config", "yes"));
+    }
+  }
+
+  pub fn refresh_verge(&self) {
+    if let Some(window) = self.get_window() {
+      log_if_err!(window.emit("verge://refresh-verge-config", "yes"));
+    }
+  }
+
+  #[allow(unused)]
+  pub fn refresh_profiles(&self) {
+    if let Some(window) = self.get_window() {
+      log_if_err!(window.emit("verge://refresh-profiles-config", "yes"));
+    }
+  }
+
+  pub fn notice_message(&self, status: String, msg: String) {
+    if let Some(window) = self.get_window() {
+      log_if_err!(window.emit("verge://notice-message", (status, msg)));
+    }
+  }
+
+  // update system tray state (clash config)
+  pub fn update_systray_clash(&self) -> Result<()> {
+    if self.app_handle.is_none() {
+      bail!("update_systray_clash unhandle error");
+    }
+
+    let app_handle = self.app_handle.as_ref().unwrap();
+
+    let global = Data::global();
+    let clash = global.clash.lock();
+    let mode = clash
+      .config
+      .get(&Value::from("mode"))
+      .map(|val| val.as_str().unwrap_or("rule"))
+      .unwrap_or("rule");
+
+    let tray = app_handle.tray_handle();
+
+    tray.get_item("rule_mode").set_selected(mode == "rule")?;
+    tray
+      .get_item("global_mode")
+      .set_selected(mode == "global")?;
+    tray
+      .get_item("direct_mode")
+      .set_selected(mode == "direct")?;
+    tray
+      .get_item("script_mode")
+      .set_selected(mode == "script")?;
+
+    Ok(())
+  }
+
+  /// update the system tray state (verge config)
+  pub fn update_systray(&self) -> Result<()> {
+    if self.app_handle.is_none() {
+      bail!("update_systray unhandle error");
+    }
+
+    let app_handle = self.app_handle.as_ref().unwrap();
+    let tray = app_handle.tray_handle();
+
+    let global = Data::global();
+    let verge = global.verge.lock();
+    let system_proxy = verge.enable_system_proxy.as_ref();
+    let tun_mode = verge.enable_tun_mode.as_ref();
+
+    tray
+      .get_item("system_proxy")
+      .set_selected(*system_proxy.unwrap_or(&false))?;
+    tray
+      .get_item("tun_mode")
+      .set_selected(*tun_mode.unwrap_or(&false))?;
+
+    // update verge config
+    self.refresh_verge();
+
+    Ok(())
+  }
+}

src-tauri/src/core/hotkey.rs

@@ -0,0 +1,153 @@
+use crate::{data::*, feat, log_if_err};
+use anyhow::{bail, Result};
+use std::collections::HashMap;
+use tauri::{AppHandle, GlobalShortcutManager};
+
+pub struct Hotkey {
+  current: Vec<String>, // 保存当前的热键设置
+  manager: Option<AppHandle>,
+}
+
+impl Hotkey {
+  pub fn new() -> Hotkey {
+    Hotkey {
+      current: Vec::new(),
+      manager: None,
+    }
+  }
+
+  pub fn init(&mut self, app_handle: AppHandle) -> Result<()> {
+    self.manager = Some(app_handle);
+    let data = Data::global();
+    let verge = data.verge.lock();
+
+    if let Some(hotkeys) = verge.hotkeys.as_ref() {
+      for hotkey in hotkeys.iter() {
+        let mut iter = hotkey.split(',');
+        let func = iter.next();
+        let key = iter.next();
+
+        if func.is_some() && key.is_some() {
+          log_if_err!(self.register(key.unwrap(), func.unwrap()));
+        } else {
+          log::error!(target: "app", "invalid hotkey \"{}\":\"{}\"", key.unwrap_or("None"), func.unwrap_or("None"));
+        }
+      }
+      self.current = hotkeys.clone();
+    }
+
+    Ok(())
+  }
+
+  fn get_manager(&self) -> Result<impl GlobalShortcutManager> {
+    if self.manager.is_none() {
+      bail!("failed to get hotkey manager");
+    }
+    Ok(self.manager.as_ref().unwrap().global_shortcut_manager())
+  }
+
+  fn register(&mut self, hotkey: &str, func: &str) -> Result<()> {
+    let mut manager = self.get_manager()?;
+
+    if manager.is_registered(hotkey)? {
+      manager.unregister(hotkey)?;
+    }
+
+    let f = match func.trim() {
+      "clash_mode_rule" => || feat::change_clash_mode("rule"),
+      "clash_mode_global" => || feat::change_clash_mode("global"),
+      "clash_mode_direct" => || feat::change_clash_mode("direct"),
+      "clash_mode_script" => || feat::change_clash_mode("script"),
+      "toggle_system_proxy" => || feat::toggle_system_proxy(),
+      "enable_system_proxy" => || feat::enable_system_proxy(),
+      "disable_system_proxy" => || feat::disable_system_proxy(),
+      "toggle_tun_mode" => || feat::toggle_tun_mode(),
+      "enable_tun_mode" => || feat::enable_tun_mode(),
+      "disable_tun_mode" => || feat::disable_tun_mode(),
+
+      _ => bail!("invalid function \"{func}\""),
+    };
+
+    manager.register(hotkey, f)?;
+    log::info!(target: "app", "register hotkey {hotkey} {func}");
+    Ok(())
+  }
+
+  fn unregister(&mut self, hotkey: &str) -> Result<()> {
+    self.get_manager()?.unregister(&hotkey)?;
+    log::info!(target: "app", "unregister hotkey {hotkey}");
+    Ok(())
+  }
+
+  pub fn update(&mut self, new_hotkeys: Vec<String>) -> Result<()> {
+    let current = self.current.to_owned();
+    let old_map = Self::get_map_from_vec(&current);
+    let new_map = Self::get_map_from_vec(&new_hotkeys);
+
+    let (del, add) = Self::get_diff(old_map, new_map);
+
+    del.iter().for_each(|key| {
+      let _ = self.unregister(key);
+    });
+
+    add.iter().for_each(|(key, func)| {
+      log_if_err!(self.register(key, func));
+    });
+
+    self.current = new_hotkeys;
+    Ok(())
+  }
+
+  fn get_map_from_vec<'a>(hotkeys: &'a Vec<String>) -> HashMap<&'a str, &'a str> {
+    let mut map = HashMap::new();
+
+    hotkeys.iter().for_each(|hotkey| {
+      let mut iter = hotkey.split(',');
+      let func = iter.next();
+      let key = iter.next();
+
+      if func.is_some() && key.is_some() {
+        let func = func.unwrap().trim();
+        let key = key.unwrap().trim();
+        map.insert(key, func);
+      }
+    });
+    map
+  }
+
+  fn get_diff<'a>(
+    old_map: HashMap<&'a str, &'a str>,
+    new_map: HashMap<&'a str, &'a str>,
+  ) -> (Vec<&'a str>, Vec<(&'a str, &'a str)>) {
+    let mut del_list = vec![];
+    let mut add_list = vec![];
+
+    old_map.iter().for_each(|(&key, func)| {
+      match new_map.get(key) {
+        Some(new_func) => {
+          if new_func != func {
+            del_list.push(key);
+            add_list.push((key, *new_func));
+          }
+        }
+        None => del_list.push(key),
+      };
+    });
+
+    new_map.iter().for_each(|(&key, &func)| {
+      if old_map.get(key).is_none() {
+        add_list.push((key, func));
+      }
+    });
+
+    (del_list, add_list)
+  }
+}
+
+impl Drop for Hotkey {
+  fn drop(&mut self) {
+    if let Ok(mut manager) = self.get_manager() {
+      let _ = manager.unregister_all();
+    }
+  }
+}

src-tauri/src/core/mod.rs

@@ -1,7 +1,341 @@
-mod clash;
-mod profiles;
-mod verge;
+use self::handle::Handle;
+use self::hotkey::Hotkey;
+use self::sysopt::Sysopt;
+use self::timer::Timer;
+use crate::config::enhance_config;
+use crate::data::*;
+use crate::log_if_err;
+use anyhow::{bail, Result};
+use once_cell::sync::Lazy;
+use parking_lot::Mutex;
+use serde_yaml::{Mapping, Value};
+use std::sync::Arc;
 
-pub use self::clash::*;
-pub use self::profiles::*;
-pub use self::verge::*;
+mod handle;
+mod hotkey;
+mod service;
+mod sysopt;
+mod timer;
+
+pub use self::service::*;
+
+static CORE: Lazy<Core> = Lazy::new(|| Core {
+  service: Arc::new(Mutex::new(Service::new())),
+  sysopt: Arc::new(Mutex::new(Sysopt::new())),
+  timer: Arc::new(Mutex::new(Timer::new())),
+  hotkey: Arc::new(Mutex::new(Hotkey::new())),
+  runtime: Arc::new(Mutex::new(RuntimeResult::default())),
+  handle: Arc::new(Mutex::new(Handle::default())),
+});
+
+#[derive(Clone)]
+pub struct Core {
+  pub service: Arc<Mutex<Service>>,
+  pub sysopt: Arc<Mutex<Sysopt>>,
+  pub timer: Arc<Mutex<Timer>>,
+  pub hotkey: Arc<Mutex<Hotkey>>,
+  pub runtime: Arc<Mutex<RuntimeResult>>,
+  pub handle: Arc<Mutex<Handle>>,
+}
+
+impl Core {
+  pub fn global() -> Core {
+    CORE.clone()
+  }
+
+  /// initialize the core state
+  pub fn init(&self, app_handle: tauri::AppHandle) {
+    // kill old clash process
+    Service::kill_old_clash();
+
+    let mut handle = self.handle.lock();
+    handle.set_inner(app_handle.clone());
+    drop(handle);
+
+    let mut service = self.service.lock();
+    log_if_err!(service.start());
+    drop(service);
+
+    log_if_err!(self.activate());
+
+    let mut sysopt = self.sysopt.lock();
+    log_if_err!(sysopt.init_launch());
+    log_if_err!(sysopt.init_sysproxy());
+    drop(sysopt);
+
+    let handle = self.handle.lock();
+    log_if_err!(handle.update_systray());
+    log_if_err!(handle.update_systray_clash());
+    drop(handle);
+
+    let mut hotkey = self.hotkey.lock();
+    log_if_err!(hotkey.init(app_handle));
+    drop(hotkey);
+
+    // timer initialize
+    let mut timer = self.timer.lock();
+    log_if_err!(timer.restore());
+  }
+
+  /// restart the clash sidecar
+  pub fn restart_clash(&self) -> Result<()> {
+    let mut service = self.service.lock();
+    service.restart()?;
+    drop(service);
+    self.activate()
+  }
+
+  /// change the clash core
+  pub fn change_core(&self, clash_core: Option<String>) -> Result<()> {
+    let clash_core = clash_core.unwrap_or("clash".into());
+
+    if &clash_core != "clash" && &clash_core != "clash-meta" {
+      bail!("invalid clash core name \"{clash_core}\"");
+    }
+
+    let global = Data::global();
+    let mut verge = global.verge.lock();
+    verge.patch_config(Verge {
+      clash_core: Some(clash_core.clone()),
+      ..Verge::default()
+    })?;
+    drop(verge);
+
+    let mut service = self.service.lock();
+    service.clear_logs();
+    service.restart()?;
+    drop(service);
+
+    self.activate()
+  }
+
+  /// Patch Clash
+  /// handle the clash config changed
+  pub fn patch_clash(&self, patch: Mapping) -> Result<()> {
+    let has_port = patch.contains_key(&Value::from("mixed-port"));
+    let has_mode = patch.contains_key(&Value::from("mode"));
+
+    let port = {
+      let global = Data::global();
+      let mut clash = global.clash.lock();
+      clash.patch_config(patch)?;
+      clash.info.port.clone()
+    };
+
+    // todo: port check
+    if has_port && port.is_some() {
+      let mut service = self.service.lock();
+      service.restart()?;
+      drop(service);
+
+      self.activate()?;
+
+      let mut sysopt = self.sysopt.lock();
+      sysopt.init_sysproxy()?;
+    }
+
+    if has_mode {
+      let handle = self.handle.lock();
+      handle.update_systray_clash()?;
+    }
+
+    Ok(())
+  }
+
+  /// Patch Verge
+  pub fn patch_verge(&self, patch: Verge) -> Result<()> {
+    // save the patch
+    let global = Data::global();
+    let mut verge = global.verge.lock();
+    verge.patch_config(patch.clone())?;
+    drop(verge);
+
+    let tun_mode = patch.enable_tun_mode;
+    let auto_launch = patch.enable_auto_launch;
+    let system_proxy = patch.enable_system_proxy;
+    let proxy_bypass = patch.system_proxy_bypass;
+    let proxy_guard = patch.enable_proxy_guard;
+
+    #[cfg(target_os = "windows")]
+    {
+      let service_mode = patch.enable_service_mode;
+
+      // 重启服务
+      if service_mode.is_some() {
+        let mut service = self.service.lock();
+        service.restart()?;
+        drop(service);
+      }
+
+      if tun_mode.is_some() && *tun_mode.as_ref().unwrap_or(&false) {
+        let wintun_dll = crate::utils::dirs::app_home_dir().join("wintun.dll");
+        if !wintun_dll.exists() {
+          bail!("failed to enable TUN for missing `wintun.dll`");
+        }
+      }
+
+      if service_mode.is_some() || tun_mode.is_some() {
+        self.activate()?;
+      }
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    if tun_mode.is_some() {
+      self.activate()?;
+    }
+
+    let mut sysopt = self.sysopt.lock();
+
+    if auto_launch.is_some() {
+      sysopt.update_launch()?;
+    }
+    if system_proxy.is_some() || proxy_bypass.is_some() {
+      sysopt.update_sysproxy()?;
+      sysopt.guard_proxy();
+    }
+    if proxy_guard.unwrap_or(false) {
+      sysopt.guard_proxy();
+    }
+
+    if system_proxy.is_some() || tun_mode.is_some() {
+      let handle = self.handle.lock();
+      handle.update_systray()?;
+    }
+
+    if patch.hotkeys.is_some() {
+      let mut hotkey = self.hotkey.lock();
+      hotkey.update(patch.hotkeys.unwrap())?;
+    }
+
+    Ok(())
+  }
+
+  // update rule/global/direct/script mode
+  pub fn update_mode(&self, mode: &str) -> Result<()> {
+    // save config to file
+    let info = {
+      let global = Data::global();
+      let mut clash = global.clash.lock();
+      clash.config.insert(Value::from("mode"), Value::from(mode));
+      clash.save_config()?;
+      clash.info.clone()
+    };
+
+    let mut mapping = Mapping::new();
+    mapping.insert(Value::from("mode"), Value::from(mode));
+
+    let handle = self.handle.clone();
+
+    tauri::async_runtime::spawn(async move {
+      log_if_err!(Service::patch_config(info, mapping.to_owned()).await);
+
+      // update tray
+      let handle = handle.lock();
+      handle.refresh_clash();
+      log_if_err!(handle.update_systray_clash());
+    });
+
+    Ok(())
+  }
+
+  /// activate the profile
+  /// auto activate enhanced profile
+  /// 触发clash配置更新
+  pub fn activate(&self) -> Result<()> {
+    let global = Data::global();
+
+    let verge = global.verge.lock();
+    let clash = global.clash.lock();
+    let profiles = global.profiles.lock();
+
+    let tun_mode = verge.enable_tun_mode.clone().unwrap_or(false);
+    let profile_activate = profiles.gen_activate()?;
+
+    let clash_config = clash.config.clone();
+    let clash_info = clash.info.clone();
+
+    drop(clash);
+    drop(verge);
+    drop(profiles);
+
+    let (config, exists_keys, logs) = enhance_config(
+      clash_config,
+      profile_activate.current,
+      profile_activate.chain,
+      profile_activate.valid,
+      tun_mode,
+    );
+
+    let mut runtime = self.runtime.lock();
+    *runtime = RuntimeResult {
+      config: Some(config.clone()),
+      config_yaml: Some(serde_yaml::to_string(&config).unwrap_or("".into())),
+      exists_keys,
+      chain_logs: logs,
+    };
+    drop(runtime);
+
+    let mut service = self.service.lock();
+    service.check_start()?;
+    drop(service);
+
+    let handle = self.handle.clone();
+    tauri::async_runtime::spawn(async move {
+      match Service::set_config(clash_info, config).await {
+        Ok(_) => {
+          let handle = handle.lock();
+          handle.refresh_clash();
+          handle.notice_message("set_config::ok".into(), "ok".into());
+        }
+        Err(err) => {
+          let handle = handle.lock();
+          handle.notice_message("set_config::error".into(), format!("{err}"));
+          log::error!(target: "app", "last {err}")
+        }
+      }
+    });
+
+    Ok(())
+  }
+
+  /// Static function
+  /// update profile item
+  pub async fn update_profile_item(&self, uid: String, option: Option<PrfOption>) -> Result<()> {
+    let global = Data::global();
+
+    let (url, opt) = {
+      let profiles = global.profiles.lock();
+      let item = profiles.get_item(&uid)?;
+
+      if let Some(typ) = item.itype.as_ref() {
+        // maybe only valid for `local` profile
+        if *typ != "remote" {
+          // reactivate the config
+          if Some(uid) == profiles.get_current() {
+            drop(profiles);
+            self.activate()?;
+          }
+          return Ok(());
+        }
+      }
+      if item.url.is_none() {
+        bail!("failed to get the profile item url");
+      }
+      (item.url.clone().unwrap(), item.option.clone())
+    };
+
+    let merged_opt = PrfOption::merge(opt, option);
+    let item = PrfItem::from_url(&url, None, None, merged_opt).await?;
+
+    let mut profiles = global.profiles.lock();
+    profiles.update_item(uid.clone(), item)?;
+
+    // reactivate the profile
+    if Some(uid) == profiles.get_current() {
+      drop(profiles);
+      self.activate()?;
+    }
+
+    Ok(())
+  }
+}

src-tauri/src/core/profiles.rs

@@ -1,397 +0,0 @@
-use super::{Clash, ClashInfo};
-use crate::utils::{config, dirs};
-use reqwest::header::HeaderMap;
-use serde::{Deserialize, Serialize};
-use serde_yaml::{Mapping, Value};
-use std::collections::HashMap;
-use std::env::temp_dir;
-use std::fs::File;
-use std::io::Write;
-use std::path::PathBuf;
-use std::time::{SystemTime, UNIX_EPOCH};
-
-/// Define the `profiles.yaml` schema
-#[derive(Default, Debug, Clone, Deserialize, Serialize)]
-pub struct Profiles {
-  /// current profile's name
-  pub current: Option<usize>,
-
-  /// profile list
-  pub items: Option<Vec<ProfileItem>>,
-}
-
-#[derive(Default, Debug, Clone, Deserialize, Serialize)]
-pub struct ProfileItem {
-  /// profile name
-  pub name: Option<String>,
-  /// profile description
-  pub desc: Option<String>,
-  /// profile file
-  pub file: Option<String>,
-  /// current mode
-  pub mode: Option<String>,
-  /// source url
-  pub url: Option<String>,
-  /// selected infomation
-  pub selected: Option<Vec<ProfileSelected>>,
-  /// user info
-  pub extra: Option<ProfileExtra>,
-  /// updated time
-  pub updated: Option<usize>,
-}
-
-#[derive(Default, Debug, Clone, Deserialize, Serialize)]
-pub struct ProfileSelected {
-  pub name: Option<String>,
-  pub now: Option<String>,
-}
-
-#[derive(Default, Debug, Clone, Copy, Deserialize, Serialize)]
-pub struct ProfileExtra {
-  pub upload: usize,
-  pub download: usize,
-  pub total: usize,
-  pub expire: usize,
-}
-
-#[derive(Default, Debug, Clone, Deserialize, Serialize)]
-/// the result from url
-pub struct ProfileResponse {
-  pub name: String,
-  pub file: String,
-  pub data: String,
-  pub extra: ProfileExtra,
-}
-
-static PROFILE_YAML: &str = "profiles.yaml";
-static PROFILE_TEMP: &str = "clash-verge-runtime.yaml";
-
-impl Profiles {
-  /// read the config from the file
-  pub fn read_file() -> Self {
-    config::read_yaml::<Profiles>(dirs::app_home_dir().join(PROFILE_YAML))
-  }
-
-  /// save the config to the file
-  pub fn save_file(&self) -> Result<(), String> {
-    config::save_yaml(
-      dirs::app_home_dir().join(PROFILE_YAML),
-      self,
-      Some("# Profiles Config for Clash Verge\n\n"),
-    )
-  }
-
-  /// sync the config between file and memory
-  pub fn sync_file(&mut self) -> Result<(), String> {
-    let data = config::read_yaml::<Self>(dirs::app_home_dir().join(PROFILE_YAML));
-    if data.current.is_none() {
-      Err("failed to read profiles.yaml".into())
-    } else {
-      self.current = data.current;
-      self.items = data.items;
-      Ok(())
-    }
-  }
-
-  /// import the new profile from the url
-  /// and update the config file
-  pub fn import_from_url(&mut self, url: String, result: ProfileResponse) -> Result<(), String> {
-    // save the profile file
-    let path = dirs::app_home_dir().join("profiles").join(&result.file);
-    let file_data = result.data.as_bytes();
-    File::create(path).unwrap().write(file_data).unwrap();
-
-    // update `profiles.yaml`
-    let data = Profiles::read_file();
-    let mut items = data.items.unwrap_or(vec![]);
-
-    let now = SystemTime::now()
-      .duration_since(UNIX_EPOCH)
-      .unwrap()
-      .as_secs();
-
-    items.push(ProfileItem {
-      name: Some(result.name),
-      desc: Some("imported url".into()),
-      file: Some(result.file),
-      mode: Some(format!("rule")),
-      url: Some(url),
-      selected: Some(vec![]),
-      extra: Some(result.extra),
-      updated: Some(now as usize),
-    });
-
-    self.items = Some(items);
-    if data.current.is_none() {
-      self.current = Some(0);
-    }
-
-    self.save_file()
-  }
-
-  /// set the current and save to file
-  pub fn put_current(&mut self, index: usize) -> Result<(), String> {
-    let items = self.items.take().unwrap_or(vec![]);
-
-    if index >= items.len() {
-      return Err("the index out of bound".into());
-    }
-
-    self.items = Some(items);
-    self.current = Some(index);
-    self.save_file()
-  }
-
-  /// append new item
-  /// return the new item's index
-  pub fn append_item(&mut self, name: String, desc: String) -> Result<(usize, PathBuf), String> {
-    let mut items = self.items.take().unwrap_or(vec![]);
-
-    // create a new profile file
-    let now = SystemTime::now()
-      .duration_since(UNIX_EPOCH)
-      .unwrap()
-      .as_secs();
-    let file = format!("{}.yaml", now);
-    let path = dirs::app_home_dir().join("profiles").join(&file);
-
-    let file_data = b"# Profile Template for clash verge\n
-# proxies defination (optional, the same as clash)
-proxies:\n
-# proxy-groups (optional, the same as clash)
-proxy-groups:\n
-# rules (optional, the same as clash)
-rules:\n\n
-";
-
-    match File::create(&path).unwrap().write(file_data) {
-      Ok(_) => {
-        items.push(ProfileItem {
-          name: Some(name),
-          desc: Some(desc),
-          file: Some(file),
-          mode: None,
-          url: None,
-          selected: Some(vec![]),
-          extra: None,
-          updated: Some(now as usize),
-        });
-
-        let index = items.len();
-        self.items = Some(items);
-        Ok((index, path))
-      }
-      Err(_) => Err("failed to create file".into()),
-    }
-  }
-
-  /// update the target profile
-  /// and save to config file
-  /// only support the url item
-  pub fn update_item(&mut self, index: usize, result: ProfileResponse) -> Result<(), String> {
-    let mut items = self.items.take().unwrap_or(vec![]);
-
-    let now = SystemTime::now()
-      .duration_since(UNIX_EPOCH)
-      .unwrap()
-      .as_secs() as usize;
-
-    // update file
-    let file_path = &items[index].file.as_ref().unwrap();
-    let file_path = dirs::app_home_dir().join("profiles").join(file_path);
-    let file_data = result.data.as_bytes();
-    File::create(file_path).unwrap().write(file_data).unwrap();
-
-    items[index].name = Some(result.name);
-    items[index].extra = Some(result.extra);
-    items[index].updated = Some(now);
-
-    self.items = Some(items);
-    self.save_file()
-  }
-
-  /// patch item
-  pub fn patch_item(&mut self, index: usize, profile: ProfileItem) -> Result<(), String> {
-    let mut items = self.items.take().unwrap_or(vec![]);
-    if index >= items.len() {
-      return Err("index out of bound".into());
-    }
-
-    if profile.name.is_some() {
-      items[index].name = profile.name;
-    }
-    if profile.file.is_some() {
-      items[index].file = profile.file;
-    }
-    if profile.mode.is_some() {
-      items[index].mode = profile.mode;
-    }
-    if profile.url.is_some() {
-      items[index].url = profile.url;
-    }
-    if profile.selected.is_some() {
-      items[index].selected = profile.selected;
-    }
-    if profile.extra.is_some() {
-      items[index].extra = profile.extra;
-    }
-
-    self.items = Some(items);
-    self.save_file()
-  }
-
-  /// delete the item
-  pub fn delete_item(&mut self, index: usize) -> Result<bool, String> {
-    let mut current = self.current.clone().unwrap_or(0);
-    let mut items = self.items.clone().unwrap_or(vec![]);
-
-    if index >= items.len() {
-      return Err("index out of bound".into());
-    }
-
-    items.remove(index);
-
-    let mut should_change = false;
-
-    if current == index {
-      current = 0;
-      should_change = true;
-    } else if current > index {
-      current = current - 1;
-    }
-
-    self.current = Some(current);
-    self.items = Some(items);
-
-    match self.save_file() {
-      Ok(_) => Ok(should_change),
-      Err(err) => Err(err),
-    }
-  }
-
-  /// activate current profile
-  pub fn activate(&self, clash: &Clash) -> Result<(), String> {
-    let current = self.current.unwrap_or(0);
-    match self.items.clone() {
-      Some(items) => {
-        if current >= items.len() {
-          return Err("the index out of bound".into());
-        }
-
-        let profile = items[current].clone();
-        let clash_config = clash.config.clone();
-        let clash_info = clash.info.clone();
-        tauri::async_runtime::spawn(async move {
-          let mut count = 5; // retry times
-          let mut err = String::from("");
-          while count > 0 {
-            match activate_profile(&profile, &clash_config, &clash_info).await {
-              Ok(_) => return,
-              Err(e) => err = e,
-            }
-            count -= 1;
-          }
-          log::error!("failed to activate for `{}`", err);
-        });
-
-        Ok(())
-      }
-      None => Err("empty profiles".into()),
-    }
-  }
-}
-
-/// put the profile to clash
-pub async fn activate_profile(
-  profile_item: &ProfileItem,
-  clash_config: &Mapping,
-  clash_info: &ClashInfo,
-) -> Result<(), String> {
-  // temp profile's path
-  let temp_path = temp_dir().join(PROFILE_TEMP);
-
-  // generate temp profile
-  {
-    let file_name = match profile_item.file.clone() {
-      Some(file_name) => file_name,
-      None => return Err("profile item should have `file` field".into()),
-    };
-
-    let file_path = dirs::app_home_dir().join("profiles").join(file_name);
-    if !file_path.exists() {
-      return Err(format!(
-        "profile `{}` not exists",
-        file_path.as_os_str().to_str().unwrap()
-      ));
-    }
-
-    // begin to generate the new profile config
-    let def_config = config::read_yaml::<Mapping>(file_path.clone());
-    let mut new_config = Mapping::new();
-
-    // Only the following fields are allowed:
-    // proxies/proxy-providers/proxy-groups/rule-providers/rules
-    let valid_keys = vec![
-      "proxies",
-      "proxy-providers",
-      "proxy-groups",
-      "rule-providers",
-      "rules",
-    ];
-    valid_keys.iter().for_each(|key| {
-      let key = Value::String(key.to_string());
-      if def_config.contains_key(&key) {
-        let value = def_config[&key].clone();
-        new_config.insert(key, value);
-      }
-    });
-
-    // add some of the clash `config.yaml` config to it
-    let valid_keys = vec![
-      "mixed-port",
-      "log-level",
-      "allow-lan",
-      "external-controller",
-      "secret",
-      "mode",
-      "ipv6",
-    ];
-    valid_keys.iter().for_each(|key| {
-      let key = Value::String(key.to_string());
-      if clash_config.contains_key(&key) {
-        let value = clash_config[&key].clone();
-        new_config.insert(key, value);
-      }
-    });
-
-    config::save_yaml(
-      temp_path.clone(),
-      &new_config,
-      Some("# Clash Verge Temp File"),
-    )?
-  };
-
-  let server = format!("http://{}/configs", clash_info.server.clone().unwrap());
-
-  let mut headers = HeaderMap::new();
-  headers.insert("Content-Type", "application/json".parse().unwrap());
-
-  if let Some(secret) = clash_info.secret.clone() {
-    headers.insert(
-      "Authorization",
-      format!("Bearer {}", secret).parse().unwrap(),
-    );
-  }
-
-  let mut data = HashMap::new();
-  data.insert("path", temp_path.as_os_str().to_str().unwrap());
-
-  let client = match reqwest::ClientBuilder::new().no_proxy().build() {
-    Ok(c) => c,
-    Err(_) => return Err("failed to create http::put".into()),
-  };
-  match client.put(server).headers(headers).json(&data).send().await {
-    Ok(_) => Ok(()),
-    Err(err) => Err(format!("request failed `{}`", err.to_string())),
-  }
-}

src-tauri/src/core/service.rs

@@ -0,0 +1,533 @@
+use crate::data::{ClashInfo, Data};
+use crate::log_if_err;
+use crate::utils::{config, dirs};
+use anyhow::{bail, Result};
+use parking_lot::RwLock;
+use reqwest::header::HeaderMap;
+use serde_yaml::Mapping;
+use std::fs;
+use std::io::Write;
+use std::sync::Arc;
+use std::{
+  collections::{HashMap, VecDeque},
+  time::Duration,
+};
+use tauri::api::process::{Command, CommandChild, CommandEvent};
+use tokio::time::sleep;
+
+const LOGS_QUEUE_LEN: usize = 100;
+
+#[derive(Debug)]
+pub struct Service {
+  sidecar: Option<CommandChild>,
+
+  logs: Arc<RwLock<VecDeque<String>>>,
+}
+
+impl Service {
+  pub fn new() -> Service {
+    let queue = VecDeque::with_capacity(LOGS_QUEUE_LEN + 10);
+
+    Service {
+      sidecar: None,
+      logs: Arc::new(RwLock::new(queue)),
+    }
+  }
+
+  pub fn start(&mut self) -> Result<()> {
+    #[cfg(not(target_os = "windows"))]
+    self.start_clash_by_sidecar()?;
+
+    #[cfg(target_os = "windows")]
+    {
+      let enable = {
+        let data = Data::global();
+        let verge = data.verge.lock();
+        verge.enable_service_mode.clone().unwrap_or(false)
+      };
+
+      if !enable {
+        return self.start_clash_by_sidecar();
+      }
+
+      tauri::async_runtime::spawn(async move {
+        match Self::check_service().await {
+          Ok(status) => {
+            // 未启动clash
+            if status.code != 0 {
+              log_if_err!(Self::start_clash_by_service().await);
+            }
+          }
+          Err(err) => log::error!(target: "app", "{err}"),
+        }
+      });
+    }
+
+    Ok(())
+  }
+
+  pub fn stop(&mut self) -> Result<()> {
+    #[cfg(not(target_os = "windows"))]
+    self.stop_clash_by_sidecar()?;
+
+    #[cfg(target_os = "windows")]
+    {
+      let _ = self.stop_clash_by_sidecar();
+
+      let enable = {
+        let data = Data::global();
+        let verge = data.verge.lock();
+        verge.enable_service_mode.clone().unwrap_or(false)
+      };
+
+      if enable {
+        tauri::async_runtime::spawn(async move {
+          log_if_err!(Self::stop_clash_by_service().await);
+        });
+      }
+    }
+
+    Ok(())
+  }
+
+  pub fn restart(&mut self) -> Result<()> {
+    self.stop()?;
+    self.start()
+  }
+
+  pub fn get_logs(&self) -> VecDeque<String> {
+    self.logs.read().clone()
+  }
+
+  #[allow(unused)]
+  pub fn set_logs(&self, text: String) {
+    let mut logs = self.logs.write();
+    if logs.len() > LOGS_QUEUE_LEN {
+      (*logs).pop_front();
+    }
+    (*logs).push_back(text);
+  }
+
+  pub fn clear_logs(&self) {
+    let mut logs = self.logs.write();
+    (*logs).clear();
+  }
+
+  /// start the clash sidecar
+  fn start_clash_by_sidecar(&mut self) -> Result<()> {
+    if self.sidecar.is_some() {
+      let sidecar = self.sidecar.take().unwrap();
+      let _ = sidecar.kill();
+    }
+
+    let clash_core: String = {
+      let global = Data::global();
+      let verge = global.verge.lock();
+      verge.clash_core.clone().unwrap_or("clash".into())
+    };
+
+    let app_dir = dirs::app_home_dir();
+    let app_dir = app_dir.as_os_str().to_str().unwrap();
+
+    // fix #212
+    let args = match clash_core.as_str() {
+      "clash-meta" => vec!["-m", "-d", app_dir],
+      _ => vec!["-d", app_dir],
+    };
+
+    let cmd = Command::new_sidecar(clash_core)?;
+
+    let (mut rx, cmd_child) = cmd.args(args).spawn()?;
+
+    // 将pid写入文件中
+    let pid = cmd_child.pid();
+    log_if_err!(|| -> Result<()> {
+      let path = dirs::clash_pid_path();
+      fs::File::create(path)?.write(format!("{pid}").as_bytes())?;
+      Ok(())
+    }());
+
+    self.sidecar = Some(cmd_child);
+
+    // clash log
+    let logs = self.logs.clone();
+    tauri::async_runtime::spawn(async move {
+      let write_log = |text: String| {
+        let mut logs = logs.write();
+        if logs.len() >= LOGS_QUEUE_LEN {
+          (*logs).pop_front();
+        }
+        (*logs).push_back(text);
+      };
+
+      while let Some(event) = rx.recv().await {
+        match event {
+          CommandEvent::Stdout(line) => {
+            let can_short = line.starts_with("time=") && line.len() > 33;
+            let stdout = if can_short { &line[33..] } else { &line };
+            log::info!(target: "app" ,"[clash]: {}", stdout);
+            write_log(line);
+          }
+          CommandEvent::Stderr(err) => {
+            log::error!(target: "app" ,"[clash error]: {}", err);
+            write_log(err);
+          }
+          _ => {}
+        }
+      }
+    });
+
+    Ok(())
+  }
+
+  /// stop the clash sidecar
+  fn stop_clash_by_sidecar(&mut self) -> Result<()> {
+    if let Some(sidecar) = self.sidecar.take() {
+      sidecar.kill()?;
+    }
+    Ok(())
+  }
+
+  pub fn check_start(&mut self) -> Result<()> {
+    #[cfg(target_os = "windows")]
+    {
+      let global = Data::global();
+      let verge = global.verge.lock();
+      let service_mode = verge.enable_service_mode.unwrap_or(false);
+
+      if !service_mode && self.sidecar.is_none() {
+        self.start()?;
+      }
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    if self.sidecar.is_none() {
+      self.start()?;
+    }
+
+    Ok(())
+  }
+
+  /// update clash config
+  /// using PUT methods
+  pub async fn set_config(info: ClashInfo, config: Mapping) -> Result<()> {
+    let temp_path = dirs::profiles_temp_path();
+    config::save_yaml(temp_path.clone(), &config, Some("# Clash Verge Temp File"))?;
+
+    let (server, headers) = Self::clash_client_info(info)?;
+
+    let mut data = HashMap::new();
+    data.insert("path", temp_path.as_os_str().to_str().unwrap());
+
+    macro_rules! report_err {
+      ($i: expr, $e: expr) => {
+        match $i {
+          4 => bail!($e),
+          _ => log::error!(target: "app", $e),
+        }
+      };
+    }
+
+    // retry 5 times
+    for i in 0..5 {
+      let headers = headers.clone();
+      match reqwest::ClientBuilder::new().no_proxy().build() {
+        Ok(client) => {
+          let builder = client.put(&server).headers(headers).json(&data);
+          match builder.send().await {
+            Ok(resp) => match resp.status().as_u16() {
+              204 => break,
+              // 配置有问题不重试
+              400 => bail!("failed to update clash config with status 400"),
+              status @ _ => report_err!(i, "failed to activate clash with status \"{status}\""),
+            },
+            Err(err) => report_err!(i, "{err}"),
+          }
+        }
+        Err(err) => report_err!(i, "{err}"),
+      }
+      sleep(Duration::from_millis(500)).await;
+    }
+
+    Ok(())
+  }
+
+  /// patch clash config
+  pub async fn patch_config(info: ClashInfo, config: Mapping) -> Result<()> {
+    let (server, headers) = Self::clash_client_info(info)?;
+
+    let client = reqwest::ClientBuilder::new().no_proxy().build()?;
+    let builder = client.patch(&server).headers(headers.clone()).json(&config);
+    builder.send().await?;
+    Ok(())
+  }
+
+  /// get clash client url and headers from clash info
+  fn clash_client_info(info: ClashInfo) -> Result<(String, HeaderMap)> {
+    if info.server.is_none() {
+      let status = &info.status;
+      if info.port.is_none() {
+        bail!("failed to parse config.yaml file with status {status}");
+      } else {
+        bail!("failed to parse the server with status {status}");
+      }
+    }
+
+    let server = info.server.unwrap();
+    let server = format!("http://{server}/configs");
+
+    let mut headers = HeaderMap::new();
+    headers.insert("Content-Type", "application/json".parse().unwrap());
+
+    if let Some(secret) = info.secret.as_ref() {
+      let secret = format!("Bearer {}", secret.clone()).parse().unwrap();
+      headers.insert("Authorization", secret);
+    }
+
+    Ok((server, headers))
+  }
+
+  /// kill old clash process
+  pub fn kill_old_clash() {
+    use sysinfo::{Pid, PidExt, ProcessExt, System, SystemExt};
+
+    if let Ok(pid) = fs::read(dirs::clash_pid_path()) {
+      if let Ok(pid) = String::from_utf8_lossy(&pid).parse() {
+        let mut system = System::new();
+        system.refresh_all();
+
+        let proc = system.process(Pid::from_u32(pid));
+        if let Some(proc) = proc {
+          proc.kill();
+        }
+      }
+    }
+  }
+}
+
+impl Drop for Service {
+  fn drop(&mut self) {
+    log_if_err!(self.stop());
+  }
+}
+
+/// ### Service Mode
+///
+#[cfg(target_os = "windows")]
+pub mod win_service {
+  use super::*;
+  use anyhow::Context;
+  use deelevate::{PrivilegeLevel, Token};
+  use runas::Command as RunasCommand;
+  use serde::{Deserialize, Serialize};
+  use std::os::windows::process::CommandExt;
+  use std::{env::current_exe, process::Command as StdCommand};
+
+  const SERVICE_NAME: &str = "clash_verge_service";
+
+  const SERVICE_URL: &str = "http://127.0.0.1:33211";
+
+  #[derive(Debug, Deserialize, Serialize, Clone)]
+  pub struct ResponseBody {
+    pub bin_path: String,
+    pub config_dir: String,
+    pub log_file: String,
+  }
+
+  #[derive(Debug, Deserialize, Serialize, Clone)]
+  pub struct JsonResponse {
+    pub code: u64,
+    pub msg: String,
+    pub data: Option<ResponseBody>,
+  }
+
+  impl Service {
+    /// Install the Clash Verge Service
+    /// 该函数应该在协程或者线程中执行，避免UAC弹窗阻塞主线程
+    pub async fn install_service() -> Result<()> {
+      let binary_path = dirs::service_path();
+      let install_path = binary_path.with_file_name("install-service.exe");
+
+      if !install_path.exists() {
+        bail!("installer exe not found");
+      }
+
+      let token = Token::with_current_process()?;
+      let level = token.privilege_level()?;
+
+      let status = match level {
+        PrivilegeLevel::NotPrivileged => RunasCommand::new(install_path).status()?,
+        _ => StdCommand::new(install_path)
+          .creation_flags(0x08000000)
+          .status()?,
+      };
+
+      if !status.success() {
+        bail!(
+          "failed to install service with status {}",
+          status.code().unwrap()
+        );
+      }
+
+      Ok(())
+    }
+
+    /// Uninstall the Clash Verge Service
+    /// 该函数应该在协程或者线程中执行，避免UAC弹窗阻塞主线程
+    pub async fn uninstall_service() -> Result<()> {
+      let binary_path = dirs::service_path();
+      let uninstall_path = binary_path.with_file_name("uninstall-service.exe");
+
+      if !uninstall_path.exists() {
+        bail!("uninstaller exe not found");
+      }
+
+      let token = Token::with_current_process()?;
+      let level = token.privilege_level()?;
+
+      let status = match level {
+        PrivilegeLevel::NotPrivileged => RunasCommand::new(uninstall_path).status()?,
+        _ => StdCommand::new(uninstall_path)
+          .creation_flags(0x08000000)
+          .status()?,
+      };
+
+      if !status.success() {
+        bail!(
+          "failed to uninstall service with status {}",
+          status.code().unwrap()
+        );
+      }
+
+      Ok(())
+    }
+
+    /// [deprecated]
+    /// start service
+    /// 该函数应该在协程或者线程中执行，避免UAC弹窗阻塞主线程
+    pub async fn start_service() -> Result<()> {
+      let token = Token::with_current_process()?;
+      let level = token.privilege_level()?;
+
+      let args = ["start", SERVICE_NAME];
+
+      let status = match level {
+        PrivilegeLevel::NotPrivileged => RunasCommand::new("sc").args(&args).status()?,
+        _ => StdCommand::new("sc").args(&args).status()?,
+      };
+
+      match status.success() {
+        true => Ok(()),
+        false => bail!(
+          "failed to start service with status {}",
+          status.code().unwrap()
+        ),
+      }
+    }
+
+    /// stop service
+    pub async fn stop_service() -> Result<()> {
+      let url = format!("{SERVICE_URL}/stop_service");
+      let res = reqwest::ClientBuilder::new()
+        .no_proxy()
+        .build()?
+        .post(url)
+        .send()
+        .await?
+        .json::<JsonResponse>()
+        .await
+        .context("failed to connect to the Clash Verge Service")?;
+
+      if res.code != 0 {
+        bail!(res.msg);
+      }
+
+      Ok(())
+    }
+
+    /// check the windows service status
+    pub async fn check_service() -> Result<JsonResponse> {
+      let url = format!("{SERVICE_URL}/get_clash");
+      let response = reqwest::ClientBuilder::new()
+        .no_proxy()
+        .build()?
+        .get(url)
+        .send()
+        .await?
+        .json::<JsonResponse>()
+        .await
+        .context("failed to connect to the Clash Verge Service")?;
+
+      Ok(response)
+    }
+
+    /// start the clash by service
+    pub(super) async fn start_clash_by_service() -> Result<()> {
+      let status = Self::check_service().await?;
+
+      if status.code == 0 {
+        Self::stop_clash_by_service().await?;
+        sleep(Duration::from_secs(1)).await;
+      }
+
+      let clash_core = {
+        let global = Data::global();
+        let verge = global.verge.lock();
+        verge.clash_core.clone().unwrap_or("clash".into())
+      };
+
+      let clash_bin = format!("{clash_core}.exe");
+      let bin_path = current_exe().unwrap().with_file_name(clash_bin);
+      let bin_path = bin_path.as_os_str().to_str().unwrap();
+
+      let config_dir = dirs::app_home_dir();
+      let config_dir = config_dir.as_os_str().to_str().unwrap();
+
+      let log_path = dirs::service_log_file();
+      let log_path = log_path.as_os_str().to_str().unwrap();
+
+      let mut map = HashMap::new();
+      map.insert("bin_path", bin_path);
+      map.insert("config_dir", config_dir);
+      map.insert("log_file", log_path);
+
+      let url = format!("{SERVICE_URL}/start_clash");
+      let res = reqwest::ClientBuilder::new()
+        .no_proxy()
+        .build()?
+        .post(url)
+        .json(&map)
+        .send()
+        .await?
+        .json::<JsonResponse>()
+        .await
+        .context("failed to connect to the Clash Verge Service")?;
+
+      if res.code != 0 {
+        bail!(res.msg);
+      }
+
+      Ok(())
+    }
+
+    /// stop the clash by service
+    pub(super) async fn stop_clash_by_service() -> Result<()> {
+      let url = format!("{SERVICE_URL}/stop_clash");
+      let res = reqwest::ClientBuilder::new()
+        .no_proxy()
+        .build()?
+        .post(url)
+        .send()
+        .await?
+        .json::<JsonResponse>()
+        .await
+        .context("failed to connect to the Clash Verge Service")?;
+
+      if res.code != 0 {
+        bail!(res.msg);
+      }
+
+      Ok(())
+    }
+  }
+}

src-tauri/src/core/sysopt.rs

@@ -0,0 +1,286 @@
+use crate::{data::*, log_if_err};
+use anyhow::{anyhow, bail, Result};
+use auto_launch::{AutoLaunch, AutoLaunchBuilder};
+use std::sync::Arc;
+use sysproxy::Sysproxy;
+use tauri::{async_runtime::Mutex, utils::platform::current_exe};
+
+pub struct Sysopt {
+  /// current system proxy setting
+  cur_sysproxy: Option<Sysproxy>,
+
+  /// record the original system proxy
+  /// recover it when exit
+  old_sysproxy: Option<Sysproxy>,
+
+  /// helps to auto launch the app
+  auto_launch: Option<AutoLaunch>,
+
+  /// record whether the guard async is running or not
+  guard_state: Arc<Mutex<bool>>,
+}
+
+#[cfg(target_os = "windows")]
+static DEFAULT_BYPASS: &str = "localhost;127.*;192.168.*;<local>";
+#[cfg(target_os = "linux")]
+static DEFAULT_BYPASS: &str = "localhost,127.0.0.1/8,::1";
+#[cfg(target_os = "macos")]
+static DEFAULT_BYPASS: &str = "127.0.0.1,localhost,<local>";
+
+impl Sysopt {
+  pub fn new() -> Sysopt {
+    Sysopt {
+      cur_sysproxy: None,
+      old_sysproxy: None,
+      auto_launch: None,
+      guard_state: Arc::new(Mutex::new(false)),
+    }
+  }
+
+  /// init the sysproxy
+  pub fn init_sysproxy(&mut self) -> Result<()> {
+    let data = Data::global();
+    let clash = data.clash.lock();
+    let port = clash.info.port.clone();
+
+    if port.is_none() {
+      bail!("clash port is none");
+    }
+
+    let verge = data.verge.lock();
+
+    let enable = verge.enable_system_proxy.clone().unwrap_or(false);
+    let bypass = verge.system_proxy_bypass.clone();
+    let bypass = bypass.unwrap_or(DEFAULT_BYPASS.into());
+
+    let port = port.unwrap().parse::<u16>()?;
+    let host = String::from("127.0.0.1");
+
+    self.cur_sysproxy = Some(Sysproxy {
+      enable,
+      host,
+      port,
+      bypass,
+    });
+
+    if enable {
+      self.old_sysproxy = Sysproxy::get_system_proxy().map_or(None, |p| Some(p));
+      self.cur_sysproxy.as_ref().unwrap().set_system_proxy()?;
+    }
+
+    // launchs the system proxy guard
+    self.guard_proxy();
+    Ok(())
+  }
+
+  /// update the system proxy
+  pub fn update_sysproxy(&mut self) -> Result<()> {
+    if self.cur_sysproxy.is_none() {
+      return self.init_sysproxy();
+    }
+
+    let data = Data::global();
+    let verge = data.verge.lock();
+
+    let enable = verge.enable_system_proxy.clone().unwrap_or(false);
+    let bypass = verge.system_proxy_bypass.clone();
+    let bypass = bypass.unwrap_or(DEFAULT_BYPASS.into());
+
+    let mut sysproxy = self.cur_sysproxy.take().unwrap();
+
+    sysproxy.enable = enable;
+    sysproxy.bypass = bypass;
+
+    self.cur_sysproxy = Some(sysproxy);
+    self.cur_sysproxy.as_ref().unwrap().set_system_proxy()?;
+
+    Ok(())
+  }
+
+  /// reset the sysproxy
+  pub fn reset_sysproxy(&mut self) -> Result<()> {
+    if self.cur_sysproxy.is_none() {
+      return Ok(());
+    }
+
+    let mut cur = self.cur_sysproxy.take().unwrap();
+
+    match self.old_sysproxy.take() {
+      Some(old) => {
+        // 如果原代理设置和当前的设置是一样的，需要关闭
+        // 否则就恢复原代理设置
+        if old.enable && old.host == cur.host && old.port == cur.port {
+          cur.enable = false;
+          cur.set_system_proxy()?;
+        } else {
+          old.set_system_proxy()?;
+        }
+      }
+      None => {
+        if cur.enable {
+          cur.enable = false;
+          cur.set_system_proxy()?;
+        }
+      }
+    }
+
+    Ok(())
+  }
+
+  /// init the auto launch
+  pub fn init_launch(&mut self) -> Result<()> {
+    let data = Data::global();
+    let verge = data.verge.lock();
+    let enable = verge.enable_auto_launch.clone().unwrap_or(false);
+
+    let app_exe = current_exe()?;
+    let app_exe = dunce::canonicalize(app_exe)?;
+    let app_name = app_exe
+      .file_stem()
+      .and_then(|f| f.to_str())
+      .ok_or(anyhow!("failed to get file stem"))?;
+
+    let app_path = app_exe
+      .as_os_str()
+      .to_str()
+      .ok_or(anyhow!("failed to get app_path"))?
+      .to_string();
+
+    // fix issue #26
+    #[cfg(target_os = "windows")]
+    let app_path = format!("\"{app_path}\"");
+
+    // use the /Applications/Clash Verge.app path
+    #[cfg(target_os = "macos")]
+    let app_path = (|| -> Option<String> {
+      let path = std::path::PathBuf::from(&app_path);
+      let path = path.parent()?.parent()?.parent()?;
+      let extension = path.extension()?.to_str()?;
+      match extension == "app" {
+        true => Some(path.as_os_str().to_str()?.to_string()),
+        false => None,
+      }
+    })()
+    .unwrap_or(app_path);
+
+    let auto = AutoLaunchBuilder::new()
+      .set_app_name(app_name)
+      .set_app_path(&app_path)
+      .build()?;
+
+    self.auto_launch = Some(auto);
+
+    // 避免在开发时将自启动关了
+    #[cfg(feature = "verge-dev")]
+    if !enable {
+      return Ok(());
+    }
+
+    let auto = self.auto_launch.as_ref().unwrap();
+
+    // macos每次启动都更新登录项，避免重复设置登录项
+    #[cfg(target_os = "macos")]
+    {
+      let _ = auto.disable();
+      if enable {
+        auto.enable()?;
+      }
+    }
+
+    #[cfg(not(target_os = "macos"))]
+    {
+      match enable {
+        true => auto.enable()?,
+        false => auto.disable()?,
+      };
+    }
+
+    Ok(())
+  }
+
+  /// update the startup
+  pub fn update_launch(&mut self) -> Result<()> {
+    if self.auto_launch.is_none() {
+      return self.init_launch();
+    }
+
+    let data = Data::global();
+    let verge = data.verge.lock();
+    let enable = verge.enable_auto_launch.clone().unwrap_or(false);
+
+    let auto_launch = self.auto_launch.as_ref().unwrap();
+
+    match enable {
+      true => auto_launch.enable()?,
+      false => crate::log_if_err!(auto_launch.disable()), // 忽略关闭的错误
+    };
+
+    Ok(())
+  }
+
+  /// launch a system proxy guard
+  /// read config from file directly
+  pub fn guard_proxy(&self) {
+    use tokio::time::{sleep, Duration};
+
+    let guard_state = self.guard_state.clone();
+
+    tauri::async_runtime::spawn(async move {
+      // if it is running, exit
+      let mut state = guard_state.lock().await;
+      if *state {
+        return;
+      }
+      *state = true;
+      drop(state);
+
+      // default duration is 10s
+      let mut wait_secs = 10u64;
+
+      loop {
+        sleep(Duration::from_secs(wait_secs)).await;
+
+        let global = Data::global();
+        let verge = global.verge.lock();
+
+        let enable = verge.enable_system_proxy.clone().unwrap_or(false);
+        let guard = verge.enable_proxy_guard.clone().unwrap_or(false);
+        let guard_duration = verge.proxy_guard_duration.clone().unwrap_or(10);
+        let bypass = verge.system_proxy_bypass.clone();
+        drop(verge);
+
+        // stop loop
+        if !enable || !guard {
+          break;
+        }
+
+        // update duration
+        wait_secs = guard_duration;
+
+        let clash = global.clash.lock();
+        let port = clash.info.port.clone();
+        let port = port.unwrap_or("".into()).parse::<u16>();
+        drop(clash);
+
+        log::debug!(target: "app", "try to guard the system proxy");
+
+        match port {
+          Ok(port) => {
+            let sysproxy = Sysproxy {
+              enable: true,
+              host: "127.0.0.1".into(),
+              port,
+              bypass: bypass.unwrap_or(DEFAULT_BYPASS.into()),
+            };
+
+            log_if_err!(sysproxy.set_system_proxy());
+          }
+          Err(_) => log::error!(target: "app", "failed to parse clash port"),
+        }
+      }
+
+      let mut state = guard_state.lock().await;
+      *state = false;
+    });
+  }
+}

src-tauri/src/core/timer.rs

@@ -0,0 +1,172 @@
+use super::Core;
+use crate::utils::help::get_now;
+use crate::{data::Data, log_if_err};
+use anyhow::{Context, Result};
+use delay_timer::prelude::{DelayTimer, DelayTimerBuilder, TaskBuilder};
+use std::collections::HashMap;
+
+type TaskID = u64;
+
+pub struct Timer {
+  /// cron manager
+  delay_timer: DelayTimer,
+
+  /// save the current state
+  timer_map: HashMap<String, (TaskID, u64)>,
+
+  /// increment id
+  timer_count: TaskID,
+}
+
+impl Timer {
+  pub fn new() -> Self {
+    Timer {
+      delay_timer: DelayTimerBuilder::default().build(),
+      timer_map: HashMap::new(),
+      timer_count: 1,
+    }
+  }
+
+  /// Correctly update all cron tasks
+  pub fn refresh(&mut self) -> Result<()> {
+    let diff_map = self.gen_diff();
+
+    for (uid, diff) in diff_map.into_iter() {
+      match diff {
+        DiffFlag::Del(tid) => {
+          let _ = self.timer_map.remove(&uid);
+          log_if_err!(self.delay_timer.remove_task(tid));
+        }
+        DiffFlag::Add(tid, val) => {
+          let _ = self.timer_map.insert(uid.clone(), (tid, val));
+          log_if_err!(self.add_task(uid, tid, val));
+        }
+        DiffFlag::Mod(tid, val) => {
+          let _ = self.timer_map.insert(uid.clone(), (tid, val));
+          log_if_err!(self.delay_timer.remove_task(tid));
+          log_if_err!(self.add_task(uid, tid, val));
+        }
+      }
+    }
+
+    Ok(())
+  }
+
+  /// restore timer
+  pub fn restore(&mut self) -> Result<()> {
+    self.refresh()?;
+
+    let cur_timestamp = get_now(); // seconds
+
+    let global = Data::global();
+    let profiles = global.profiles.lock();
+
+    profiles
+      .get_items()
+      .unwrap_or(&vec![])
+      .iter()
+      .filter(|item| item.uid.is_some() && item.updated.is_some() && item.option.is_some())
+      .filter(|item| {
+        // mins to seconds
+        let interval = item.option.as_ref().unwrap().update_interval.unwrap_or(0) as usize * 60;
+        let updated = item.updated.unwrap();
+        return interval > 0 && cur_timestamp - updated >= interval;
+      })
+      .for_each(|item| {
+        let uid = item.uid.as_ref().unwrap();
+        if let Some((task_id, _)) = self.timer_map.get(uid) {
+          log_if_err!(self.delay_timer.advance_task(*task_id));
+        }
+      });
+
+    Ok(())
+  }
+
+  /// generate a uid -> update_interval map
+  fn gen_map(&self) -> HashMap<String, u64> {
+    let global = Data::global();
+    let profiles = global.profiles.lock();
+
+    let mut new_map = HashMap::new();
+
+    if let Some(items) = profiles.get_items() {
+      for item in items.iter() {
+        if item.option.is_some() {
+          let option = item.option.as_ref().unwrap();
+          let interval = option.update_interval.unwrap_or(0);
+
+          if interval > 0 {
+            new_map.insert(item.uid.clone().unwrap(), interval);
+          }
+        }
+      }
+    }
+
+    new_map
+  }
+
+  /// generate the diff map for refresh
+  fn gen_diff(&mut self) -> HashMap<String, DiffFlag> {
+    let mut diff_map = HashMap::new();
+
+    let new_map = self.gen_map();
+    let cur_map = &self.timer_map;
+
+    cur_map.iter().for_each(|(uid, (tid, val))| {
+      let new_val = new_map.get(uid).unwrap_or(&0);
+
+      if *new_val == 0 {
+        diff_map.insert(uid.clone(), DiffFlag::Del(*tid));
+      } else if new_val != val {
+        diff_map.insert(uid.clone(), DiffFlag::Mod(*tid, *new_val));
+      }
+    });
+
+    let mut count = self.timer_count;
+
+    new_map.iter().for_each(|(uid, val)| {
+      if cur_map.get(uid).is_none() {
+        diff_map.insert(uid.clone(), DiffFlag::Add(count, *val));
+
+        count += 1;
+      }
+    });
+
+    self.timer_count = count;
+
+    diff_map
+  }
+
+  /// add a cron task
+  fn add_task(&self, uid: String, tid: TaskID, minutes: u64) -> Result<()> {
+    let core = Core::global();
+
+    let task = TaskBuilder::default()
+      .set_task_id(tid)
+      .set_maximum_parallel_runnable_num(1)
+      .set_frequency_repeated_by_minutes(minutes)
+      // .set_frequency_repeated_by_seconds(minutes) // for test
+      .spawn_async_routine(move || Self::async_task(core.to_owned(), uid.to_owned()))
+      .context("failed to create timer task")?;
+
+    self
+      .delay_timer
+      .add_task(task)
+      .context("failed to add timer task")?;
+
+    Ok(())
+  }
+
+  /// the task runner
+  async fn async_task(core: Core, uid: String) {
+    log::info!(target: "app", "running timer task `{uid}`");
+    log_if_err!(core.update_profile_item(uid, None).await);
+  }
+}
+
+#[derive(Debug)]
+enum DiffFlag {
+  Del(TaskID),
+  Add(TaskID, u64),
+  Mod(TaskID, u64),
+}

src-tauri/src/core/verge.rs

@@ -1,237 +0,0 @@
-use crate::utils::{config, dirs, sysopt::SysProxyConfig};
-use auto_launch::{AutoLaunch, AutoLaunchBuilder};
-use serde::{Deserialize, Serialize};
-use tauri::api::path::resource_dir;
-
-/// ### `verge.yaml` schema
-#[derive(Default, Debug, Clone, Deserialize, Serialize)]
-pub struct VergeConfig {
-  /// `light` or `dark`
-  pub theme_mode: Option<String>,
-
-  /// enable blur mode
-  /// maybe be able to set the alpha
-  pub theme_blur: Option<bool>,
-
-  /// can the app auto startup
-  pub enable_auto_launch: Option<bool>,
-
-  /// set system proxy
-  pub enable_system_proxy: Option<bool>,
-
-  /// set system proxy bypass
-  pub system_proxy_bypass: Option<String>,
-}
-
-static VERGE_CONFIG: &str = "verge.yaml";
-
-impl VergeConfig {
-  pub fn new() -> Self {
-    config::read_yaml::<VergeConfig>(dirs::app_home_dir().join(VERGE_CONFIG))
-  }
-
-  /// Save Verge App Config
-  pub fn save_file(&self) -> Result<(), String> {
-    config::save_yaml(
-      dirs::app_home_dir().join(VERGE_CONFIG),
-      self,
-      Some("# The Config for Clash Verge App\n\n"),
-    )
-  }
-}
-
-/// Verge App abilities
-#[derive(Debug)]
-pub struct Verge {
-  pub config: VergeConfig,
-
-  pub old_sysproxy: Option<SysProxyConfig>,
-
-  pub cur_sysproxy: Option<SysProxyConfig>,
-
-  pub auto_launch: Option<AutoLaunch>,
-}
-
-impl Default for Verge {
-  fn default() -> Self {
-    Verge::new()
-  }
-}
-
-impl Verge {
-  pub fn new() -> Self {
-    Verge {
-      config: VergeConfig::new(),
-      old_sysproxy: None,
-      cur_sysproxy: None,
-      auto_launch: None,
-    }
-  }
-
-  /// init the sysproxy
-  pub fn init_sysproxy(&mut self, port: Option<String>) {
-    if let Some(port) = port {
-      let enable = self.config.enable_system_proxy.clone().unwrap_or(false);
-
-      self.old_sysproxy = match SysProxyConfig::get_sys() {
-        Ok(proxy) => Some(proxy),
-        Err(_) => None,
-      };
-
-      let bypass = self.config.system_proxy_bypass.clone();
-      let sysproxy = SysProxyConfig::new(enable, port, bypass);
-
-      if enable {
-        if sysproxy.set_sys().is_err() {
-          log::error!("failed to set system proxy");
-        }
-      }
-
-      self.cur_sysproxy = Some(sysproxy);
-    }
-  }
-
-  /// reset the sysproxy
-  pub fn reset_sysproxy(&mut self) {
-    if let Some(sysproxy) = self.old_sysproxy.take() {
-      match sysproxy.set_sys() {
-        Ok(_) => self.cur_sysproxy = None,
-        Err(_) => log::error!("failed to reset proxy for"),
-      }
-    }
-  }
-
-  /// init the auto launch
-  pub fn init_launch(&mut self, package_info: &tauri::PackageInfo) {
-    let app_name = "clash-verge";
-    let app_path = get_app_path(app_name);
-    let app_path = resource_dir(package_info).unwrap().join(app_path);
-    let app_path = app_path.as_os_str().to_str().unwrap();
-
-    let auto = AutoLaunchBuilder::new()
-      .set_app_name(app_name)
-      .set_app_path(app_path)
-      .build();
-
-    self.auto_launch = Some(auto);
-  }
-
-  /// sync the startup when run the app
-  pub fn sync_launch(&self) -> Result<(), String> {
-    let enable = self.config.enable_auto_launch.clone().unwrap_or(false);
-    if !enable {
-      return Ok(());
-    }
-
-    if self.auto_launch.is_none() {
-      return Err("should init the auto launch first".into());
-    }
-
-    let auto_launch = self.auto_launch.clone().unwrap();
-
-    let is_enabled = auto_launch.is_enabled().unwrap_or(false);
-    if !is_enabled {
-      if let Err(_) = auto_launch.enable() {
-        return Err("failed to enable auto-launch".into());
-      }
-    }
-
-    Ok(())
-  }
-
-  /// update the startup
-  fn update_launch(&mut self, enable: bool) -> Result<(), String> {
-    let conf_enable = self.config.enable_auto_launch.clone().unwrap_or(false);
-
-    if enable == conf_enable {
-      return Ok(());
-    }
-
-    let auto_launch = self.auto_launch.clone().unwrap();
-
-    let result = if enable {
-      auto_launch.enable()
-    } else {
-      auto_launch.disable()
-    };
-
-    match result {
-      Ok(_) => Ok(()),
-      Err(err) => {
-        log::error!("{err}");
-        Err("failed to set system startup info".into())
-      }
-    }
-  }
-
-  // fn guard_thread(&mut self) -> Result<(), String> {
-  //   let sysproxy = self.cur_sysproxy.clone();
-
-  //   use std::{thread, time};
-  //   tauri::async_runtime::spawn(async move {
-  //     if let Some(sysproxy) = sysproxy {
-  //       sysproxy.set_sys();
-  //     }
-
-  //     let ten_millis = time::Duration::from_millis(10);
-  //     let now = time::Instant::now();
-
-  //     thread::sleep(ten_millis);
-  //   });
-
-  //   Ok(())
-  // }
-
-  /// patch verge config
-  /// There should be only one update at a time here
-  /// so call the save_file at the end is savely
-  pub fn patch_config(&mut self, patch: VergeConfig) -> Result<(), String> {
-    // only change it
-    if patch.theme_mode.is_some() {
-      self.config.theme_mode = patch.theme_mode;
-    }
-    if patch.theme_blur.is_some() {
-      self.config.theme_blur = patch.theme_blur;
-    }
-
-    // should update system startup
-    if patch.enable_auto_launch.is_some() {
-      let enable = patch.enable_auto_launch.unwrap();
-      self.update_launch(enable)?;
-      self.config.enable_auto_launch = Some(enable);
-    }
-
-    // should update system proxy
-    if patch.enable_system_proxy.is_some() {
-      let enable = patch.enable_system_proxy.unwrap();
-      if let Some(mut sysproxy) = self.cur_sysproxy.take() {
-        sysproxy.enable = enable;
-        if sysproxy.set_sys().is_err() {
-          log::error!("failed to set system proxy");
-          return Err("failed to set system proxy".into());
-        }
-        self.cur_sysproxy = Some(sysproxy);
-      }
-      self.config.enable_system_proxy = Some(enable);
-    }
-
-    // todo
-    // should update system proxy too
-    if patch.system_proxy_bypass.is_some() {
-      self.config.system_proxy_bypass = patch.system_proxy_bypass;
-    }
-
-    self.config.save_file()
-  }
-}
-
-// Get the target app_path
-fn get_app_path(app_name: &str) -> String {
-  #[cfg(target_os = "linux")]
-  let ext = "";
-  #[cfg(target_os = "macos")]
-  let ext = "";
-  #[cfg(target_os = "windows")]
-  let ext = ".exe";
-  String::from(app_name) + ext
-}

src-tauri/src/data/clash.rs

@@ -0,0 +1,167 @@
+use crate::utils::{config, dirs};
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+use serde_yaml::{Mapping, Value};
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct ClashInfo {
+  /// clash sidecar status
+  pub status: String,
+
+  /// clash core port
+  pub port: Option<String>,
+
+  /// same as `external-controller`
+  pub server: Option<String>,
+
+  /// clash secret
+  pub secret: Option<String>,
+}
+
+impl ClashInfo {
+  /// parse the clash's config.yaml
+  /// get some information
+  pub fn from(config: &Mapping) -> ClashInfo {
+    let key_port_1 = Value::from("mixed-port");
+    let key_port_2 = Value::from("port");
+    let key_server = Value::from("external-controller");
+    let key_secret = Value::from("secret");
+
+    let mut status: u32 = 0;
+
+    let port = match config.get(&key_port_1) {
+      Some(value) => match value {
+        Value::String(val_str) => Some(val_str.clone()),
+        Value::Number(val_num) => Some(val_num.to_string()),
+        _ => {
+          status |= 0b1;
+          None
+        }
+      },
+      _ => {
+        status |= 0b10;
+        None
+      }
+    };
+    let port = match port {
+      Some(_) => port,
+      None => match config.get(&key_port_2) {
+        Some(value) => match value {
+          Value::String(val_str) => Some(val_str.clone()),
+          Value::Number(val_num) => Some(val_num.to_string()),
+          _ => {
+            status |= 0b100;
+            None
+          }
+        },
+        _ => {
+          status |= 0b1000;
+          None
+        }
+      },
+    };
+
+    // `external-controller` could be
+    // "127.0.0.1:9090" or ":9090"
+    let server = match config.get(&key_server) {
+      Some(value) => match value.as_str() {
+        Some(val_str) => {
+          if val_str.starts_with(":") {
+            Some(format!("127.0.0.1{val_str}"))
+          } else if val_str.starts_with("0.0.0.0:") {
+            Some(format!("127.0.0.1:{}", &val_str[8..]))
+          } else if val_str.starts_with("[::]:") {
+            Some(format!("127.0.0.1:{}", &val_str[5..]))
+          } else {
+            Some(val_str.into())
+          }
+        }
+        None => {
+          status |= 0b10000;
+          None
+        }
+      },
+      None => {
+        status |= 0b100000;
+        None
+      }
+    };
+
+    let secret = match config.get(&key_secret) {
+      Some(value) => match value {
+        Value::String(val_str) => Some(val_str.clone()),
+        Value::Bool(val_bool) => Some(val_bool.to_string()),
+        Value::Number(val_num) => Some(val_num.to_string()),
+        _ => None,
+      },
+      _ => None,
+    };
+
+    ClashInfo {
+      status: format!("{status}"),
+      port,
+      server,
+      secret,
+    }
+  }
+}
+
+#[derive(Debug)]
+pub struct Clash {
+  /// maintain the clash config
+  pub config: Mapping,
+
+  /// some info
+  pub info: ClashInfo,
+}
+
+impl Clash {
+  pub fn new() -> Clash {
+    let config = Clash::read_config();
+    let info = ClashInfo::from(&config);
+
+    Clash { config, info }
+  }
+
+  /// get clash config
+  pub fn read_config() -> Mapping {
+    config::read_merge_mapping(dirs::clash_path())
+  }
+
+  /// save the clash config
+  pub fn save_config(&self) -> Result<()> {
+    config::save_yaml(
+      dirs::clash_path(),
+      &self.config,
+      Some("# Default Config For Clash Core\n\n"),
+    )
+  }
+
+  /// patch update the clash config
+  /// if the port is changed then return true
+  pub fn patch_config(&mut self, patch: Mapping) -> Result<()> {
+    let port_key = Value::from("mixed-port");
+    let server_key = Value::from("external-controller");
+    let secret_key = Value::from("secret");
+
+    let change_info = patch.contains_key(&port_key)
+      || patch.contains_key(&server_key)
+      || patch.contains_key(&secret_key);
+
+    for (key, value) in patch.into_iter() {
+      self.config.insert(key, value);
+    }
+
+    if change_info {
+      self.info = ClashInfo::from(&self.config);
+    }
+
+    self.save_config()
+  }
+}
+
+impl Default for Clash {
+  fn default() -> Self {
+    Clash::new()
+  }
+}

src-tauri/src/data/mod.rs

@@ -0,0 +1,32 @@
+mod clash;
+mod prfitem;
+mod profiles;
+mod verge;
+
+pub use self::clash::*;
+pub use self::prfitem::*;
+pub use self::profiles::*;
+pub use self::verge::*;
+
+use once_cell::sync::Lazy;
+use parking_lot::Mutex;
+use std::sync::Arc;
+
+static DATA: Lazy<Data> = Lazy::new(|| Data {
+  clash: Arc::new(Mutex::new(Clash::new())),
+  verge: Arc::new(Mutex::new(Verge::new())),
+  profiles: Arc::new(Mutex::new(Profiles::new())),
+});
+
+#[derive(Debug, Clone)]
+pub struct Data {
+  pub clash: Arc<Mutex<Clash>>,
+  pub verge: Arc<Mutex<Verge>>,
+  pub profiles: Arc<Mutex<Profiles>>,
+}
+
+impl Data {
+  pub fn global() -> Data {
+    DATA.clone()
+  }
+}

src-tauri/src/data/prfitem.rs

@@ -0,0 +1,372 @@
+use crate::utils::{config, dirs, help, tmpl};
+use anyhow::{bail, Context, Result};
+use serde::{Deserialize, Serialize};
+use serde_yaml::Mapping;
+use std::fs;
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct PrfItem {
+  pub uid: Option<String>,
+
+  /// profile item type
+  /// enum value: remote | local | script | merge
+  #[serde(rename = "type")]
+  pub itype: Option<String>,
+
+  /// profile name
+  pub name: Option<String>,
+
+  /// profile file
+  pub file: Option<String>,
+
+  /// profile description
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub desc: Option<String>,
+
+  /// source url
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub url: Option<String>,
+
+  /// selected infomation
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub selected: Option<Vec<PrfSelected>>,
+
+  /// subscription user info
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub extra: Option<PrfExtra>,
+
+  /// updated time
+  pub updated: Option<usize>,
+
+  /// some options of the item
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub option: Option<PrfOption>,
+
+  /// the file data
+  #[serde(skip)]
+  pub file_data: Option<String>,
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct PrfSelected {
+  pub name: Option<String>,
+  pub now: Option<String>,
+}
+
+#[derive(Default, Debug, Clone, Copy, Deserialize, Serialize)]
+pub struct PrfExtra {
+  pub upload: usize,
+  pub download: usize,
+  pub total: usize,
+  pub expire: usize,
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
+pub struct PrfOption {
+  /// for `remote` profile's http request
+  /// see issue #13
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub user_agent: Option<String>,
+
+  /// for `remote` profile
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub with_proxy: Option<bool>,
+
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub update_interval: Option<u64>,
+}
+
+impl PrfOption {
+  pub fn merge(one: Option<Self>, other: Option<Self>) -> Option<Self> {
+    if one.is_none() {
+      return other;
+    }
+
+    if one.is_some() && other.is_some() {
+      let mut one = one.unwrap();
+      let other = other.unwrap();
+
+      if let Some(val) = other.user_agent {
+        one.user_agent = Some(val);
+      }
+
+      if let Some(val) = other.with_proxy {
+        one.with_proxy = Some(val);
+      }
+
+      if let Some(val) = other.update_interval {
+        one.update_interval = Some(val);
+      }
+
+      return Some(one);
+    }
+
+    return one;
+  }
+}
+
+impl Default for PrfItem {
+  fn default() -> Self {
+    PrfItem {
+      uid: None,
+      itype: None,
+      name: None,
+      desc: None,
+      file: None,
+      url: None,
+      selected: None,
+      extra: None,
+      updated: None,
+      option: None,
+      file_data: None,
+    }
+  }
+}
+
+impl PrfItem {
+  /// From partial item
+  /// must contain `itype`
+  pub async fn from(item: PrfItem, file_data: Option<String>) -> Result<PrfItem> {
+    if item.itype.is_none() {
+      bail!("type should not be null");
+    }
+
+    match item.itype.unwrap().as_str() {
+      "remote" => {
+        if item.url.is_none() {
+          bail!("url should not be null");
+        }
+        let url = item.url.as_ref().unwrap().as_str();
+        let name = item.name;
+        let desc = item.desc;
+        PrfItem::from_url(url, name, desc, item.option).await
+      }
+      "local" => {
+        let name = item.name.unwrap_or("Local File".into());
+        let desc = item.desc.unwrap_or("".into());
+        PrfItem::from_local(name, desc, file_data)
+      }
+      "merge" => {
+        let name = item.name.unwrap_or("Merge".into());
+        let desc = item.desc.unwrap_or("".into());
+        PrfItem::from_merge(name, desc)
+      }
+      "script" => {
+        let name = item.name.unwrap_or("Script".into());
+        let desc = item.desc.unwrap_or("".into());
+        PrfItem::from_script(name, desc)
+      }
+      typ @ _ => bail!("invalid profile item type \"{typ}\""),
+    }
+  }
+
+  /// ## Local type
+  /// create a new item from name/desc
+  pub fn from_local(name: String, desc: String, file_data: Option<String>) -> Result<PrfItem> {
+    let uid = help::get_uid("l");
+    let file = format!("{uid}.yaml");
+
+    Ok(PrfItem {
+      uid: Some(uid),
+      itype: Some("local".into()),
+      name: Some(name),
+      desc: Some(desc),
+      file: Some(file),
+      url: None,
+      selected: None,
+      extra: None,
+      option: None,
+      updated: Some(help::get_now()),
+      file_data: Some(file_data.unwrap_or(tmpl::ITEM_LOCAL.into())),
+    })
+  }
+
+  /// ## Remote type
+  /// create a new item from url
+  pub async fn from_url(
+    url: &str,
+    name: Option<String>,
+    desc: Option<String>,
+    option: Option<PrfOption>,
+  ) -> Result<PrfItem> {
+    let with_proxy = match option.as_ref() {
+      Some(opt) => opt.with_proxy.unwrap_or(false),
+      None => false,
+    };
+    let user_agent = match option.as_ref() {
+      Some(opt) => opt.user_agent.clone(),
+      None => None,
+    };
+
+    let mut builder = reqwest::ClientBuilder::new();
+
+    if !with_proxy {
+      builder = builder.no_proxy();
+    }
+
+    builder = builder.user_agent(user_agent.unwrap_or("clash-verge/v1.0.0".into()));
+
+    let resp = builder.build()?.get(url).send().await?;
+    let header = resp.headers();
+
+    // parse the Subscription Userinfo
+    let extra = match header.get("Subscription-Userinfo") {
+      Some(value) => {
+        let sub_info = value.to_str().unwrap_or("");
+
+        Some(PrfExtra {
+          upload: help::parse_str(sub_info, "upload=").unwrap_or(0),
+          download: help::parse_str(sub_info, "download=").unwrap_or(0),
+          total: help::parse_str(sub_info, "total=").unwrap_or(0),
+          expire: help::parse_str(sub_info, "expire=").unwrap_or(0),
+        })
+      }
+      None => None,
+    };
+
+    // parse the Content-Disposition
+    let filename = match header.get("Content-Disposition") {
+      Some(value) => {
+        let filename = value.to_str().unwrap_or("");
+        help::parse_str::<String>(filename, "filename=")
+      }
+      None => None,
+    };
+
+    // parse the profile-update-interval
+    let option = match header.get("profile-update-interval") {
+      Some(value) => match value.to_str().unwrap_or("").parse::<u64>() {
+        Ok(val) => Some(PrfOption {
+          update_interval: Some(val * 60), // hour -> min
+          ..PrfOption::default()
+        }),
+        Err(_) => None,
+      },
+      None => None,
+    };
+
+    let uid = help::get_uid("r");
+    let file = format!("{uid}.yaml");
+    let name = name.unwrap_or(filename.unwrap_or("Remote File".into()));
+    let data = resp.text_with_charset("utf-8").await?;
+
+    // check the data whether the valid yaml format
+    if !serde_yaml::from_str::<Mapping>(&data).is_ok() {
+      bail!("the remote profile data is invalid yaml");
+    }
+
+    Ok(PrfItem {
+      uid: Some(uid),
+      itype: Some("remote".into()),
+      name: Some(name),
+      desc,
+      file: Some(file),
+      url: Some(url.into()),
+      selected: None,
+      extra,
+      option,
+      updated: Some(help::get_now()),
+      file_data: Some(data),
+    })
+  }
+
+  /// ## Merge type (enhance)
+  /// create the enhanced item by using `merge` rule
+  pub fn from_merge(name: String, desc: String) -> Result<PrfItem> {
+    let uid = help::get_uid("m");
+    let file = format!("{uid}.yaml");
+
+    Ok(PrfItem {
+      uid: Some(uid),
+      itype: Some("merge".into()),
+      name: Some(name),
+      desc: Some(desc),
+      file: Some(file),
+      url: None,
+      selected: None,
+      extra: None,
+      option: None,
+      updated: Some(help::get_now()),
+      file_data: Some(tmpl::ITEM_MERGE.into()),
+    })
+  }
+
+  /// ## Script type (enhance)
+  /// create the enhanced item by using javascript(browserjs)
+  pub fn from_script(name: String, desc: String) -> Result<PrfItem> {
+    let uid = help::get_uid("s");
+    let file = format!("{uid}.js"); // js ext
+
+    Ok(PrfItem {
+      uid: Some(uid),
+      itype: Some("script".into()),
+      name: Some(name),
+      desc: Some(desc),
+      file: Some(file),
+      url: None,
+      selected: None,
+      extra: None,
+      option: None,
+      updated: Some(help::get_now()),
+      file_data: Some(tmpl::ITEM_SCRIPT.into()),
+    })
+  }
+
+  /// get the file data
+  pub fn read_file(&self) -> Result<String> {
+    if self.file.is_none() {
+      bail!("could not find the file");
+    }
+
+    let file = self.file.clone().unwrap();
+    let path = dirs::app_profiles_dir().join(file);
+    fs::read_to_string(path).context("failed to read the file")
+  }
+
+  /// save the file data
+  pub fn save_file(&self, data: String) -> Result<()> {
+    if self.file.is_none() {
+      bail!("could not find the file");
+    }
+
+    let file = self.file.clone().unwrap();
+    let path = dirs::app_profiles_dir().join(file);
+    fs::write(path, data.as_bytes()).context("failed to save the file")
+  }
+
+  /// get the data for enhanced mode
+  pub fn to_enhance(&self) -> Option<ChainItem> {
+    let itype = self.itype.as_ref()?.as_str();
+    let file = self.file.clone()?;
+    let uid = self.uid.clone().unwrap_or("".into());
+    let path = dirs::app_profiles_dir().join(file);
+
+    if !path.exists() {
+      return None;
+    }
+
+    match itype {
+      "script" => Some(ChainItem {
+        uid,
+        data: ChainType::Script(fs::read_to_string(path).unwrap_or("".into())),
+      }),
+      "merge" => Some(ChainItem {
+        uid,
+        data: ChainType::Merge(config::read_merge_mapping(path)),
+      }),
+      _ => None,
+    }
+  }
+}
+
+#[derive(Debug, Clone)]
+pub struct ChainItem {
+  pub uid: String,
+  pub data: ChainType,
+}
+
+#[derive(Debug, Clone)]
+pub enum ChainType {
+  Merge(Mapping),
+  Script(String),
+}

src-tauri/src/data/profiles.rs

@@ -0,0 +1,328 @@
+use super::prfitem::PrfItem;
+use super::ChainItem;
+use crate::utils::{config, dirs, help};
+use anyhow::{bail, Context, Result};
+use serde::{Deserialize, Serialize};
+use serde_yaml::Mapping;
+use std::collections::HashMap;
+use std::{fs, io::Write};
+
+///
+/// ## Profiles Config
+///
+/// Define the `profiles.yaml` schema
+///
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct Profiles {
+  /// same as PrfConfig.current
+  current: Option<String>,
+
+  /// same as PrfConfig.chain
+  chain: Option<Vec<String>>,
+
+  /// record valid fields for clash
+  valid: Option<Vec<String>>,
+
+  /// profile list
+  items: Option<Vec<PrfItem>>,
+}
+
+macro_rules! patch {
+  ($lv: expr, $rv: expr, $key: tt) => {
+    if ($rv.$key).is_some() {
+      $lv.$key = $rv.$key;
+    }
+  };
+}
+
+impl Profiles {
+  pub fn new() -> Self {
+    Profiles::read_file()
+  }
+
+  /// read the config from the file
+  pub fn read_file() -> Self {
+    let mut profiles = config::read_yaml::<Self>(dirs::profiles_path());
+
+    if profiles.items.is_none() {
+      profiles.items = Some(vec![]);
+    }
+
+    // compatiable with the old old old version
+    profiles.items.as_mut().map(|items| {
+      for mut item in items.iter_mut() {
+        if item.uid.is_none() {
+          item.uid = Some(help::get_uid("d"));
+        }
+      }
+    });
+
+    profiles
+  }
+
+  /// save the config to the file
+  pub fn save_file(&self) -> Result<()> {
+    config::save_yaml(
+      dirs::profiles_path(),
+      self,
+      Some("# Profiles Config for Clash Verge\n\n"),
+    )
+  }
+
+  /// get the current uid
+  pub fn get_current(&self) -> Option<String> {
+    self.current.clone()
+  }
+
+  /// only change the main to the target id
+  pub fn put_current(&mut self, uid: String) -> Result<()> {
+    if self.items.is_none() {
+      self.items = Some(vec![]);
+    }
+
+    let items = self.items.as_ref().unwrap();
+    let some_uid = Some(uid.clone());
+
+    if items.iter().find(|&each| each.uid == some_uid).is_some() {
+      self.current = some_uid;
+      return self.save_file();
+    }
+
+    bail!("invalid uid \"{uid}\"");
+  }
+
+  /// just change the `chain`
+  pub fn put_chain(&mut self, chain: Option<Vec<String>>) -> Result<()> {
+    self.chain = chain;
+    self.save_file()
+  }
+
+  /// just change the `field`
+  pub fn put_valid(&mut self, valid: Option<Vec<String>>) -> Result<()> {
+    self.valid = valid;
+    self.save_file()
+  }
+
+  /// get items ref
+  pub fn get_items(&self) -> Option<&Vec<PrfItem>> {
+    self.items.as_ref()
+  }
+
+  /// find the item by the uid
+  pub fn get_item(&self, uid: &String) -> Result<&PrfItem> {
+    if self.items.is_some() {
+      let items = self.items.as_ref().unwrap();
+      let some_uid = Some(uid.clone());
+
+      for each in items.iter() {
+        if each.uid == some_uid {
+          return Ok(each);
+        }
+      }
+    }
+
+    bail!("failed to get the profile item \"uid:{uid}\"");
+  }
+
+  /// append new item
+  /// if the file_data is some
+  /// then should save the data to file
+  pub fn append_item(&mut self, mut item: PrfItem) -> Result<()> {
+    if item.uid.is_none() {
+      bail!("the uid should not be null");
+    }
+
+    // save the file data
+    // move the field value after save
+    if let Some(file_data) = item.file_data.take() {
+      if item.file.is_none() {
+        bail!("the file should not be null");
+      }
+
+      let file = item.file.clone().unwrap();
+      let path = dirs::app_profiles_dir().join(&file);
+
+      fs::File::create(path)
+        .context(format!("failed to create file \"{}\"", file))?
+        .write(file_data.as_bytes())
+        .context(format!("failed to write to file \"{}\"", file))?;
+    }
+
+    if self.items.is_none() {
+      self.items = Some(vec![]);
+    }
+
+    self.items.as_mut().map(|items| items.push(item));
+    self.save_file()
+  }
+
+  /// update the item value
+  pub fn patch_item(&mut self, uid: String, item: PrfItem) -> Result<()> {
+    let mut items = self.items.take().unwrap_or(vec![]);
+
+    for mut each in items.iter_mut() {
+      if each.uid == Some(uid.clone()) {
+        patch!(each, item, itype);
+        patch!(each, item, name);
+        patch!(each, item, desc);
+        patch!(each, item, file);
+        patch!(each, item, url);
+        patch!(each, item, selected);
+        patch!(each, item, extra);
+        patch!(each, item, updated);
+        patch!(each, item, option);
+
+        self.items = Some(items);
+        return self.save_file();
+      }
+    }
+
+    self.items = Some(items);
+    bail!("failed to find the profile item \"uid:{uid}\"")
+  }
+
+  /// be used to update the remote item
+  /// only patch `updated` `extra` `file_data`
+  pub fn update_item(&mut self, uid: String, mut item: PrfItem) -> Result<()> {
+    if self.items.is_none() {
+      self.items = Some(vec![]);
+    }
+
+    // find the item
+    let _ = self.get_item(&uid)?;
+
+    if let Some(items) = self.items.as_mut() {
+      let some_uid = Some(uid.clone());
+
+      for mut each in items.iter_mut() {
+        if each.uid == some_uid {
+          each.extra = item.extra;
+          each.updated = item.updated;
+
+          // save the file data
+          // move the field value after save
+          if let Some(file_data) = item.file_data.take() {
+            let file = each.file.take();
+            let file = file.unwrap_or(item.file.take().unwrap_or(format!("{}.yaml", &uid)));
+
+            // the file must exists
+            each.file = Some(file.clone());
+
+            let path = dirs::app_profiles_dir().join(&file);
+
+            fs::File::create(path)
+              .context(format!("failed to create file \"{}\"", file))?
+              .write(file_data.as_bytes())
+              .context(format!("failed to write to file \"{}\"", file))?;
+          }
+
+          break;
+        }
+      }
+    }
+
+    self.save_file()
+  }
+
+  /// delete item
+  /// if delete the current then return true
+  pub fn delete_item(&mut self, uid: String) -> Result<bool> {
+    let current = self.current.as_ref().unwrap_or(&uid);
+    let current = current.clone();
+
+    let mut items = self.items.take().unwrap_or(vec![]);
+    let mut index = None;
+
+    // get the index
+    for i in 0..items.len() {
+      if items[i].uid == Some(uid.clone()) {
+        index = Some(i);
+        break;
+      }
+    }
+
+    if let Some(index) = index {
+      items.remove(index).file.map(|file| {
+        let path = dirs::app_profiles_dir().join(file);
+        if path.exists() {
+          let _ = fs::remove_file(path);
+        }
+      });
+    }
+
+    // delete the original uid
+    if current == uid {
+      self.current = match items.len() > 0 {
+        true => items[0].uid.clone(),
+        false => None,
+      };
+    }
+
+    self.items = Some(items);
+    self.save_file()?;
+    Ok(current == uid)
+  }
+
+  /// generate the current Mapping data
+  fn gen_current(&self) -> Result<Mapping> {
+    let config = Mapping::new();
+
+    if self.current.is_none() || self.items.is_none() {
+      return Ok(config);
+    }
+
+    let current = self.current.clone().unwrap();
+    for item in self.items.as_ref().unwrap().iter() {
+      if item.uid == Some(current.clone()) {
+        let file_path = match item.file.clone() {
+          Some(file) => dirs::app_profiles_dir().join(file),
+          None => bail!("failed to get the file field"),
+        };
+
+        if !file_path.exists() {
+          bail!("failed to read the file \"{}\"", file_path.display());
+        }
+
+        return Ok(config::read_merge_mapping(file_path.clone()));
+      }
+    }
+    bail!("failed to find current profile \"uid:{current}\"");
+  }
+
+  /// generate the data for activate clash config
+  pub fn gen_activate(&self) -> Result<PrfActivate> {
+    let current = self.gen_current()?;
+    let chain = match self.chain.as_ref() {
+      Some(chain) => chain
+        .iter()
+        .filter_map(|uid| self.get_item(uid).ok())
+        .filter_map(|item| item.to_enhance())
+        .collect::<Vec<ChainItem>>(),
+      None => vec![],
+    };
+    let valid = self.valid.clone().unwrap_or(vec![]);
+
+    Ok(PrfActivate {
+      current,
+      chain,
+      valid,
+    })
+  }
+}
+
+#[derive(Default, Clone)]
+pub struct PrfActivate {
+  pub current: Mapping,
+  pub chain: Vec<ChainItem>,
+  pub valid: Vec<String>,
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct RuntimeResult {
+  pub config: Option<Mapping>,
+  pub config_yaml: Option<String>,
+  // 记录在配置中（包括merge和script生成的）出现过的keys
+  // 这些keys不一定都生效
+  pub exists_keys: Vec<String>,
+  pub chain_logs: HashMap<String, Vec<(String, String)>>,
+}

src-tauri/src/data/verge.rs

@@ -0,0 +1,127 @@
+use crate::utils::{config, dirs};
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+
+/// ### `verge.yaml` schema
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct Verge {
+  /// app listening port
+  /// for app singleton
+  pub app_singleton_port: Option<u16>,
+
+  // i18n
+  pub language: Option<String>,
+
+  /// `light` or `dark` or `system`
+  pub theme_mode: Option<String>,
+
+  /// enable blur mode
+  /// maybe be able to set the alpha
+  pub theme_blur: Option<bool>,
+
+  /// enable traffic graph default is true
+  pub traffic_graph: Option<bool>,
+
+  /// clash tun mode
+  pub enable_tun_mode: Option<bool>,
+
+  /// windows service mode
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub enable_service_mode: Option<bool>,
+
+  /// can the app auto startup
+  pub enable_auto_launch: Option<bool>,
+
+  /// not show the window on launch
+  pub enable_silent_start: Option<bool>,
+
+  /// set system proxy
+  pub enable_system_proxy: Option<bool>,
+
+  /// enable proxy guard
+  pub enable_proxy_guard: Option<bool>,
+
+  /// set system proxy bypass
+  pub system_proxy_bypass: Option<String>,
+
+  /// proxy guard duration
+  pub proxy_guard_duration: Option<u64>,
+
+  /// theme setting
+  pub theme_setting: Option<VergeTheme>,
+
+  /// web ui list
+  pub web_ui_list: Option<Vec<String>>,
+
+  /// clash core path
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub clash_core: Option<String>,
+
+  /// hotkey map
+  /// format: {func},{key}
+  pub hotkeys: Option<Vec<String>>,
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct VergeTheme {
+  pub primary_color: Option<String>,
+  pub secondary_color: Option<String>,
+  pub primary_text: Option<String>,
+  pub secondary_text: Option<String>,
+
+  pub info_color: Option<String>,
+  pub error_color: Option<String>,
+  pub warning_color: Option<String>,
+  pub success_color: Option<String>,
+
+  pub font_family: Option<String>,
+  pub css_injection: Option<String>,
+}
+
+impl Verge {
+  pub fn new() -> Self {
+    config::read_yaml::<Verge>(dirs::verge_path())
+  }
+
+  /// Save Verge App Config
+  pub fn save_file(&self) -> Result<()> {
+    config::save_yaml(
+      dirs::verge_path(),
+      self,
+      Some("# The Config for Clash Verge App\n\n"),
+    )
+  }
+
+  /// patch verge config
+  /// only save to file
+  pub fn patch_config(&mut self, patch: Verge) -> Result<()> {
+    macro_rules! patch {
+      ($key: tt) => {
+        if patch.$key.is_some() {
+          self.$key = patch.$key;
+        }
+      };
+    }
+
+    patch!(language);
+    patch!(theme_mode);
+    patch!(theme_blur);
+    patch!(traffic_graph);
+
+    patch!(enable_tun_mode);
+    patch!(enable_service_mode);
+    patch!(enable_auto_launch);
+    patch!(enable_silent_start);
+    patch!(enable_system_proxy);
+    patch!(enable_proxy_guard);
+    patch!(system_proxy_bypass);
+    patch!(proxy_guard_duration);
+
+    patch!(theme_setting);
+    patch!(web_ui_list);
+    patch!(clash_core);
+    patch!(hotkeys);
+
+    self.save_file()
+  }
+}

src-tauri/src/feat.rs

@@ -0,0 +1,93 @@
+use crate::core::*;
+use crate::data::*;
+use crate::log_if_err;
+
+// 切换模式
+pub fn change_clash_mode(mode: &str) {
+  let core = Core::global();
+  log_if_err!(core.update_mode(mode));
+}
+
+// 切换系统代理
+pub fn toggle_system_proxy() {
+  let core = Core::global();
+  let data = Data::global();
+
+  let verge = data.verge.lock();
+  let enable = !verge.enable_system_proxy.clone().unwrap_or(false);
+  drop(verge);
+
+  log_if_err!(core.patch_verge(Verge {
+    enable_system_proxy: Some(enable),
+    ..Verge::default()
+  }));
+
+  let handle = core.handle.lock();
+  let _ = handle.refresh_verge();
+}
+
+// 打开系统代理
+pub fn enable_system_proxy() {
+  let core = Core::global();
+  log_if_err!(core.patch_verge(Verge {
+    enable_system_proxy: Some(true),
+    ..Verge::default()
+  }));
+
+  let handle = core.handle.lock();
+  let _ = handle.refresh_verge();
+}
+
+// 关闭系统代理
+pub fn disable_system_proxy() {
+  let core = Core::global();
+  log_if_err!(core.patch_verge(Verge {
+    enable_system_proxy: Some(false),
+    ..Verge::default()
+  }));
+
+  let handle = core.handle.lock();
+  let _ = handle.refresh_verge();
+}
+
+// 切换tun模式
+pub fn toggle_tun_mode() {
+  let core = Core::global();
+  let data = Data::global();
+
+  let verge = data.verge.lock();
+  let enable = !verge.enable_tun_mode.clone().unwrap_or(false);
+  drop(verge);
+
+  log_if_err!(core.patch_verge(Verge {
+    enable_tun_mode: Some(enable),
+    ..Verge::default()
+  }));
+
+  let handle = core.handle.lock();
+  let _ = handle.refresh_verge();
+}
+
+// 打开tun模式
+pub fn enable_tun_mode() {
+  let core = Core::global();
+  log_if_err!(core.patch_verge(Verge {
+    enable_tun_mode: Some(true),
+    ..Verge::default()
+  }));
+
+  let handle = core.handle.lock();
+  let _ = handle.refresh_verge();
+}
+
+// 关闭tun模式
+pub fn disable_tun_mode() {
+  let core = Core::global();
+  log_if_err!(core.patch_verge(Verge {
+    enable_tun_mode: Some(false),
+    ..Verge::default()
+  }));
+
+  let handle = core.handle.lock();
+  let _ = handle.refresh_verge();
+}

src-tauri/src/main.rs

@@ -4,107 +4,181 @@
 )]
 
 mod cmds;
+mod config;
 mod core;
-mod states;
+mod data;
+mod feat;
 mod utils;
 
-use crate::utils::{resolve, server};
+use crate::{
+  data::Verge,
+  utils::{resolve, server},
+};
 use tauri::{
   api, CustomMenuItem, Manager, SystemTray, SystemTrayEvent, SystemTrayMenu, SystemTrayMenuItem,
 };
 
 fn main() -> std::io::Result<()> {
-  if server::check_singleton().is_err() {
-    println!("app exists");
-    return Ok(());
+  {
+    let verge = Verge::new();
+
+    if server::check_singleton(verge.app_singleton_port).is_err() {
+      println!("app exists");
+      return Ok(());
+    }
   }
 
-  let menu = SystemTrayMenu::new()
+  #[cfg(target_os = "windows")]
+  unsafe {
+    use crate::utils::dirs;
+    dirs::init_portable_flag();
+  }
+
+  let tray_menu = SystemTrayMenu::new()
     .add_item(CustomMenuItem::new("open_window", "Show"))
+    .add_native_item(SystemTrayMenuItem::Separator)
+    .add_item(CustomMenuItem::new("rule_mode", "Rule Mode"))
+    .add_item(CustomMenuItem::new("global_mode", "Global Mode"))
+    .add_item(CustomMenuItem::new("direct_mode", "Direct Mode"))
+    .add_item(CustomMenuItem::new("script_mode", "Script Mode"))
+    .add_native_item(SystemTrayMenuItem::Separator)
+    .add_item(CustomMenuItem::new("system_proxy", "System Proxy"))
+    .add_item(CustomMenuItem::new("tun_mode", "Tun Mode"))
     .add_item(CustomMenuItem::new("restart_clash", "Restart Clash"))
+    .add_item(CustomMenuItem::new("restart_app", "Restart App"))
     .add_native_item(SystemTrayMenuItem::Separator)
     .add_item(CustomMenuItem::new("quit", "Quit").accelerator("CmdOrControl+Q"));
 
-  tauri::Builder::default()
-    .manage(states::VergeState::default())
-    .manage(states::ClashState::default())
-    .manage(states::ProfilesState::default())
+  #[allow(unused_mut)]
+  let mut builder = tauri::Builder::default()
     .setup(|app| Ok(resolve::resolve_setup(app)))
-    .system_tray(SystemTray::new().with_menu(menu))
+    .system_tray(SystemTray::new().with_menu(tray_menu))
     .on_system_tray_event(move |app_handle, event| match event {
       SystemTrayEvent::MenuItemClick { id, .. } => match id.as_str() {
         "open_window" => {
-          let window = app_handle.get_window("main").unwrap();
-          window.unminimize().unwrap();
-          window.show().unwrap();
-          window.set_focus().unwrap();
+          resolve::create_window(app_handle);
         }
-        "restart_clash" => {
-          let clash_state = app_handle.state::<states::ClashState>();
-          let profiles_state = app_handle.state::<states::ProfilesState>();
-          let mut clash = clash_state.0.lock().unwrap();
-          let mut profiles = profiles_state.0.lock().unwrap();
-          match clash.restart_sidecar(&mut profiles) {
-            Ok(_) => {
-              let window = app_handle.get_window("main").unwrap();
-              window.emit("restart_clash", "yes").unwrap();
-            }
-            Err(err) => log::error!("{}", err),
-          }
+        mode @ ("rule_mode" | "global_mode" | "direct_mode" | "script_mode") => {
+          let mode = &mode[0..mode.len() - 5];
+          feat::change_clash_mode(mode);
+        }
+        "system_proxy" => feat::toggle_system_proxy(),
+        "tun_mode" => feat::toggle_tun_mode(),
+        "restart_app" => {
+          api::process::restart(&app_handle.env());
         }
         "quit" => {
-          api::process::kill_children();
-          resolve::resolve_reset(app_handle);
+          resolve::resolve_reset();
           app_handle.exit(0);
         }
         _ => {}
       },
+      #[cfg(target_os = "windows")]
       SystemTrayEvent::LeftClick { .. } => {
-        if cfg![target_os = "windows"] {
-          let window = app_handle.get_window("main").unwrap();
-          window.unminimize().unwrap();
-          window.show().unwrap();
-          window.set_focus().unwrap();
-        }
+        resolve::create_window(app_handle);
       }
       _ => {}
     })
     .invoke_handler(tauri::generate_handler![
       // common
-      cmds::restart_sidecar,
       cmds::get_sys_proxy,
-      cmds::get_cur_proxy,
+      cmds::open_app_dir,
+      cmds::open_logs_dir,
+      cmds::open_web_url,
+      cmds::kill_sidecar,
+      cmds::restart_sidecar,
       // clash
       cmds::get_clash_info,
+      cmds::get_clash_logs,
       cmds::patch_clash_config,
+      cmds::change_clash_core,
+      cmds::get_runtime_config,
+      cmds::get_runtime_yaml,
+      cmds::get_runtime_exists,
+      cmds::get_runtime_logs,
       // verge
       cmds::get_verge_config,
       cmds::patch_verge_config,
+      cmds::update_hotkeys,
       // profile
-      cmds::new_profile,
       cmds::view_profile,
       cmds::patch_profile,
+      cmds::create_profile,
       cmds::import_profile,
       cmds::update_profile,
       cmds::delete_profile,
       cmds::select_profile,
       cmds::get_profiles,
-      cmds::sync_profiles,
-    ])
+      cmds::enhance_profiles,
+      cmds::change_profile_chain,
+      cmds::change_profile_valid,
+      cmds::read_profile_file,
+      cmds::save_profile_file,
+      // service mode
+      cmds::service::start_service,
+      cmds::service::stop_service,
+      cmds::service::check_service,
+      cmds::service::install_service,
+      cmds::service::uninstall_service,
+    ]);
+
+  #[cfg(target_os = "macos")]
+  {
+    use tauri::{Menu, MenuItem, Submenu};
+
+    let submenu_file = Submenu::new(
+      "File",
+      Menu::new()
+        .add_native_item(MenuItem::Undo)
+        .add_native_item(MenuItem::Redo)
+        .add_native_item(MenuItem::Copy)
+        .add_native_item(MenuItem::Paste)
+        .add_native_item(MenuItem::Cut)
+        .add_native_item(MenuItem::SelectAll),
+    );
+    builder = builder.menu(Menu::new().add_submenu(submenu_file));
+  }
+
+  #[allow(unused_mut)]
+  let mut app = builder
     .build(tauri::generate_context!())
-    .expect("error while running tauri application")
-    .run(|app_handle, e| match e {
-      tauri::Event::CloseRequested { label, api, .. } => {
-        let app_handle = app_handle.clone();
-        api.prevent_close();
-        app_handle.get_window(&label).unwrap().hide().unwrap();
+    .expect("error while running tauri application");
+
+  #[cfg(target_os = "macos")]
+  app.set_activation_policy(tauri::ActivationPolicy::Accessory);
+
+  let app_handle = app.app_handle();
+  ctrlc::set_handler(move || {
+    resolve::resolve_reset();
+    app_handle.exit(0);
+  })
+  .expect("error while exiting.");
+
+  #[allow(unused)]
+  app.run(|app_handle, e| match e {
+    tauri::RunEvent::ExitRequested { api, .. } => {
+      api.prevent_exit();
+    }
+    tauri::RunEvent::Exit => {
+      resolve::resolve_reset();
+      api::process::kill_children();
+    }
+    #[cfg(target_os = "macos")]
+    tauri::RunEvent::WindowEvent { label, event, .. } => {
+      if label == "main" {
+        match event {
+          tauri::WindowEvent::CloseRequested { api, .. } => {
+            api.prevent_close();
+            app_handle.get_window("main").map(|win| {
+              let _ = win.hide();
+            });
+          }
+          _ => {}
+        }
       }
-      tauri::Event::ExitRequested { .. } => {
-        resolve::resolve_reset(app_handle);
-        api::process::kill_children();
-      }
-      _ => {}
-    });
+    }
+    _ => {}
+  });
 
   Ok(())
 }

src-tauri/src/states.rs

@@ -1,11 +0,0 @@
-use crate::core::{Clash, Profiles, Verge};
-use std::sync::{Arc, Mutex};
-
-#[derive(Default)]
-pub struct ProfilesState(pub Arc<Mutex<Profiles>>);
-
-#[derive(Default)]
-pub struct ClashState(pub Arc<Mutex<Clash>>);
-
-#[derive(Default)]
-pub struct VergeState(pub Arc<Mutex<Verge>>);

src-tauri/src/utils/config.rs

@@ -1,32 +1,59 @@
+use anyhow::{Context, Result};
 use serde::{de::DeserializeOwned, Serialize};
+use serde_yaml::{Mapping, Value};
 use std::{fs, path::PathBuf};
 
 /// read data from yaml as struct T
 pub fn read_yaml<T: DeserializeOwned + Default>(path: PathBuf) -> T {
-  let yaml_str = fs::read_to_string(path).unwrap_or("".into());
-  serde_yaml::from_str::<T>(&yaml_str).unwrap_or(T::default())
-}
+  if !path.exists() {
+    log::error!(target: "app", "file not found \"{}\"", path.display());
+    return T::default();
+  }
 
-/// - save the data to the file
-/// - can set `prefix` string to add some comments
-pub fn save_yaml<T: Serialize>(
-  path: PathBuf,
-  data: &T,
-  prefix: Option<&str>,
-) -> Result<(), String> {
-  match serde_yaml::to_string(data) {
-    Ok(data_str) => {
-      let yaml_str = match prefix {
-        Some(prefix) => format!("{}{}", prefix, data_str),
-        None => data_str,
-      };
+  let yaml_str = fs::read_to_string(&path).unwrap_or("".into());
 
-      let path_str = path.as_os_str().to_string_lossy().to_string();
-      match fs::write(path, yaml_str.as_bytes()) {
-        Ok(_) => Ok(()),
-        Err(_) => Err(format!("can not save file `{}`", path_str)),
-      }
+  match serde_yaml::from_str::<T>(&yaml_str) {
+    Ok(val) => val,
+    Err(_) => {
+      log::error!(target: "app", "failed to read yaml file \"{}\"", path.display());
+      T::default()
     }
-    Err(_) => Err("can not convert the data to yaml".into()),
   }
 }
+
+/// read mapping from yaml fix #165
+pub fn read_merge_mapping(path: PathBuf) -> Mapping {
+  let map = Mapping::new();
+
+  if !path.exists() {
+    log::error!(target: "app", "file not found \"{}\"", path.display());
+    return map;
+  }
+
+  let yaml_str = fs::read_to_string(&path).unwrap_or("".into());
+
+  match serde_yaml::from_str::<Value>(&yaml_str) {
+    Ok(mut val) => {
+      crate::log_if_err!(val.apply_merge());
+      val.as_mapping().unwrap_or(&map).to_owned()
+    }
+    Err(_) => {
+      log::error!(target: "app", "failed to read yaml file \"{}\"", path.display());
+      map
+    }
+  }
+}
+
+/// save the data to the file
+/// can set `prefix` string to add some comments
+pub fn save_yaml<T: Serialize>(path: PathBuf, data: &T, prefix: Option<&str>) -> Result<()> {
+  let data_str = serde_yaml::to_string(data)?;
+
+  let yaml_str = match prefix {
+    Some(prefix) => format!("{prefix}{data_str}"),
+    None => data_str,
+  };
+
+  let path_str = path.as_os_str().to_string_lossy().to_string();
+  fs::write(path, yaml_str.as_bytes()).context(format!("failed to save file \"{path_str}\""))
+}

src-tauri/src/utils/dirs.rs

@@ -1,18 +1,132 @@
-use std::path::{Path, PathBuf};
+use std::env::temp_dir;
+use std::path::PathBuf;
 use tauri::{
   api::path::{home_dir, resource_dir},
-  PackageInfo,
+  Env, PackageInfo,
 };
 
+#[cfg(not(feature = "verge-dev"))]
+static APP_DIR: &str = "clash-verge";
+#[cfg(feature = "verge-dev")]
+static APP_DIR: &str = "clash-verge-dev";
+
+static CLASH_CONFIG: &str = "config.yaml";
+static VERGE_CONFIG: &str = "verge.yaml";
+static PROFILE_YAML: &str = "profiles.yaml";
+static PROFILE_TEMP: &str = "clash-verge-runtime.yaml";
+
+static mut RESOURCE_DIR: Option<PathBuf> = None;
+
+/// portable flag
+#[allow(unused)]
+static mut PORTABLE_FLAG: bool = false;
+
+/// initialize portable flag
+#[allow(unused)]
+pub unsafe fn init_portable_flag() {
+  #[cfg(target_os = "windows")]
+  {
+    use tauri::utils::platform::current_exe;
+
+    let exe = current_exe().unwrap();
+    let dir = exe.parent().unwrap();
+    let dir = PathBuf::from(dir).join(".config/PORTABLE");
+
+    if dir.exists() {
+      PORTABLE_FLAG = true;
+    }
+  }
+}
+
 /// get the verge app home dir
 pub fn app_home_dir() -> PathBuf {
-  home_dir()
-    .unwrap()
-    .join(Path::new(".config"))
-    .join(Path::new("clash-verge"))
+  #[cfg(target_os = "windows")]
+  unsafe {
+    use tauri::utils::platform::current_exe;
+
+    if !PORTABLE_FLAG {
+      home_dir().unwrap().join(".config").join(APP_DIR)
+    } else {
+      let app_exe = current_exe().unwrap();
+      let app_exe = dunce::canonicalize(app_exe).unwrap();
+      let app_dir = app_exe.parent().unwrap();
+      PathBuf::from(app_dir).join(".config").join(APP_DIR)
+    }
+  }
+
+  #[cfg(not(target_os = "windows"))]
+  home_dir().unwrap().join(".config").join(APP_DIR)
 }
 
 /// get the resources dir
 pub fn app_resources_dir(package_info: &PackageInfo) -> PathBuf {
-  resource_dir(package_info).unwrap().join("resources")
+  let res_dir = resource_dir(package_info, &Env::default())
+    .unwrap()
+    .join("resources");
+
+  unsafe {
+    RESOURCE_DIR = Some(res_dir.clone());
+  }
+
+  res_dir
+}
+
+/// profiles dir
+pub fn app_profiles_dir() -> PathBuf {
+  app_home_dir().join("profiles")
+}
+
+/// logs dir
+pub fn app_logs_dir() -> PathBuf {
+  app_home_dir().join("logs")
+}
+
+pub fn clash_path() -> PathBuf {
+  app_home_dir().join(CLASH_CONFIG)
+}
+
+pub fn verge_path() -> PathBuf {
+  app_home_dir().join(VERGE_CONFIG)
+}
+
+pub fn profiles_path() -> PathBuf {
+  app_home_dir().join(PROFILE_YAML)
+}
+
+pub fn profiles_temp_path() -> PathBuf {
+  #[cfg(not(feature = "debug-yml"))]
+  return temp_dir().join(PROFILE_TEMP);
+
+  #[cfg(feature = "debug-yml")]
+  return app_home_dir().join(PROFILE_TEMP);
+}
+
+pub fn clash_pid_path() -> PathBuf {
+  unsafe { RESOURCE_DIR.clone().unwrap().join("clash.pid") }
+}
+
+#[cfg(windows)]
+static SERVICE_PATH: &str = "clash-verge-service.exe";
+
+#[cfg(windows)]
+pub fn service_path() -> PathBuf {
+  unsafe {
+    let res_dir = RESOURCE_DIR.clone().unwrap();
+    res_dir.join(SERVICE_PATH)
+  }
+}
+
+#[cfg(windows)]
+pub fn service_log_file() -> PathBuf {
+  use chrono::Local;
+
+  let log_dir = app_logs_dir().join("service");
+
+  let local_time = Local::now().format("%Y-%m-%d-%H%M%S").to_string();
+  let log_file = format!("{}.log", local_time);
+  let log_file = log_dir.join(log_file);
+
+  std::fs::create_dir_all(&log_dir).unwrap();
+
+  log_file
 }

src-tauri/src/utils/fetch.rs

@@ -1,105 +0,0 @@
-use crate::core::{ProfileExtra, ProfileResponse};
-use std::{
-  str::FromStr,
-  time::{SystemTime, UNIX_EPOCH},
-};
-
-/// parse the string
-fn parse_string<T: FromStr>(target: &str, key: &str) -> Option<T> {
-  match target.find(key) {
-    Some(idx) => {
-      let idx = idx + key.len();
-      let value = &target[idx..];
-      match match value.split(';').nth(0) {
-        Some(value) => value.trim().parse(),
-        None => value.trim().parse(),
-      } {
-        Ok(r) => Some(r),
-        Err(_) => None,
-      }
-    }
-    None => None,
-  }
-}
-
-/// fetch and parse the profile
-pub async fn fetch_profile(url: &str, with_proxy: bool) -> Option<ProfileResponse> {
-  let builder = reqwest::ClientBuilder::new();
-  let client = match with_proxy {
-    true => builder.build(),
-    false => builder.no_proxy().build(),
-  };
-  let resp = match client {
-    Ok(client) => match client.get(url).send().await {
-      Ok(res) => res,
-      Err(_) => return None,
-    },
-    Err(_) => return None,
-  };
-
-  let header = resp.headers();
-
-  // parse the Subscription Userinfo
-  let extra = {
-    let sub_info = match header.get("Subscription-Userinfo") {
-      Some(value) => value.to_str().unwrap_or(""),
-      None => "",
-    };
-
-    ProfileExtra {
-      upload: parse_string(sub_info, "upload=").unwrap_or(0),
-      download: parse_string(sub_info, "download=").unwrap_or(0),
-      total: parse_string(sub_info, "total=").unwrap_or(0),
-      expire: parse_string(sub_info, "expire=").unwrap_or(0),
-    }
-  };
-
-  // parse the `name` and `file`
-  let (name, file) = {
-    let now = SystemTime::now()
-      .duration_since(UNIX_EPOCH)
-      .unwrap()
-      .as_secs();
-    let file = format!("{}.yaml", now);
-    let name = header.get("Content-Disposition").unwrap().to_str().unwrap();
-    let name = parse_string::<String>(name, "filename=");
-
-    match name {
-      Some(f) => (f, file),
-      None => (file.clone(), file),
-    }
-  };
-
-  // get the data
-  let data = match resp.text_with_charset("utf-8").await {
-    Ok(d) => d,
-    Err(_) => return None,
-  };
-
-  Some(ProfileResponse {
-    file,
-    name,
-    data,
-    extra,
-  })
-}
-
-#[test]
-fn test_parse_value() {
-  let test_1 = "upload=111; download=2222; total=3333; expire=444";
-  let test_2 = "attachment; filename=Clash.yaml";
-
-  assert_eq!(parse_string::<usize>(test_1, "upload=").unwrap(), 111);
-  assert_eq!(parse_string::<usize>(test_1, "download=").unwrap(), 2222);
-  assert_eq!(parse_string::<usize>(test_1, "total=").unwrap(), 3333);
-  assert_eq!(parse_string::<usize>(test_1, "expire=").unwrap(), 444);
-  assert_eq!(
-    parse_string::<String>(test_2, "filename=").unwrap(),
-    format!("Clash.yaml")
-  );
-
-  assert_eq!(parse_string::<usize>(test_1, "aaa="), None);
-  assert_eq!(parse_string::<usize>(test_1, "upload1="), None);
-  assert_eq!(parse_string::<usize>(test_1, "expire1="), None);
-  assert_eq!(parse_string::<usize>(test_2, "attachment="), None);
-}

src-tauri/src/utils/help.rs

@@ -0,0 +1,127 @@
+use anyhow::{bail, Result};
+use nanoid::nanoid;
+use std::path::PathBuf;
+use std::process::Command;
+use std::str::FromStr;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+pub fn get_now() -> usize {
+  SystemTime::now()
+    .duration_since(UNIX_EPOCH)
+    .unwrap()
+    .as_secs() as _
+}
+
+const ALPHABET: [char; 62] = [
+  '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
+  'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B',
+  'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U',
+  'V', 'W', 'X', 'Y', 'Z',
+];
+
+/// generate the uid
+pub fn get_uid(prefix: &str) -> String {
+  let id = nanoid!(11, &ALPHABET);
+  format!("{prefix}{id}")
+}
+
+/// parse the string
+/// xxx=123123; => 123123
+pub fn parse_str<T: FromStr>(target: &str, key: &str) -> Option<T> {
+  match target.find(key) {
+    Some(idx) => {
+      let idx = idx + key.len();
+      let value = &target[idx..];
+      match match value.split(';').nth(0) {
+        Some(value) => value.trim().parse(),
+        None => value.trim().parse(),
+      } {
+        Ok(r) => Some(r),
+        Err(_) => None,
+      }
+    }
+    None => None,
+  }
+}
+
+/// open file
+/// use vscode by default
+pub fn open_file(path: PathBuf) -> Result<()> {
+  // use vscode first
+  if let Ok(code) = which::which("code") {
+    #[cfg(target_os = "windows")]
+    {
+      use std::os::windows::process::CommandExt;
+
+      if let Err(err) = Command::new(code)
+        .creation_flags(0x08000000)
+        .arg(path)
+        .spawn()
+      {
+        bail!("failed to open file by VScode for `{err}`");
+      }
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    if let Err(err) = Command::new(code).arg(path).spawn() {
+      bail!("failed to open file by VScode for `{err}`");
+    }
+
+    return Ok(());
+  }
+
+  open::that(path)?;
+  Ok(())
+}
+
+#[macro_export]
+macro_rules! log_if_err {
+  ($result: expr) => {
+    if let Err(err) = $result {
+      log::error!(target: "app", "{err}");
+    }
+  };
+}
+
+/// wrap the anyhow error
+/// transform the error to String
+#[macro_export]
+macro_rules! wrap_err {
+  ($stat: expr) => {
+    match $stat {
+      Ok(a) => Ok(a),
+      Err(err) => {
+        log::error!(target: "app", "{}", err.to_string());
+        Err(format!("{}", err.to_string()))
+      }
+    }
+  };
+}
+
+/// return the string literal error
+#[macro_export]
+macro_rules! ret_err {
+  ($str: expr) => {
+    return Err($str.into())
+  };
+}
+
+#[test]
+fn test_parse_value() {
+  let test_1 = "upload=111; download=2222; total=3333; expire=444";
+  let test_2 = "attachment; filename=Clash.yaml";
+
+  assert_eq!(parse_str::<usize>(test_1, "upload=").unwrap(), 111);
+  assert_eq!(parse_str::<usize>(test_1, "download=").unwrap(), 2222);
+  assert_eq!(parse_str::<usize>(test_1, "total=").unwrap(), 3333);
+  assert_eq!(parse_str::<usize>(test_1, "expire=").unwrap(), 444);
+  assert_eq!(
+    parse_str::<String>(test_2, "filename=").unwrap(),
+    format!("Clash.yaml")
+  );
+
+  assert_eq!(parse_str::<usize>(test_1, "aaa="), None);
+  assert_eq!(parse_str::<usize>(test_1, "upload1="), None);
+  assert_eq!(parse_str::<usize>(test_1, "expire1="), None);
+  assert_eq!(parse_str::<usize>(test_2, "attachment="), None);
+}

src-tauri/src/utils/init.rs

@@ -1,19 +1,18 @@
-extern crate serde_yaml;
-
-use crate::utils::dirs;
+use crate::utils::{dirs, tmpl};
+use anyhow::Result;
 use chrono::Local;
 use log::LevelFilter;
 use log4rs::append::console::ConsoleAppender;
 use log4rs::append::file::FileAppender;
-use log4rs::config::{Appender, Config, Root};
+use log4rs::config::{Appender, Config, Logger, Root};
 use log4rs::encode::pattern::PatternEncoder;
-use std::fs::{self, File};
+use std::fs;
 use std::io::Write;
 use std::path::PathBuf;
 use tauri::PackageInfo;
 
 /// initialize this instance's log file
-fn init_log(log_dir: &PathBuf) {
+fn init_log(log_dir: &PathBuf) -> Result<()> {
   let local_time = Local::now().format("%Y-%m-%d-%H%M%S").to_string();
   let log_file = format!("{}.log", local_time);
   let log_file = log_dir.join(log_file);
@@ -24,82 +23,80 @@ fn init_log(log_dir: &PathBuf) {
     .build();
   let tofile = FileAppender::builder()
     .encoder(Box::new(PatternEncoder::new(time_format)))
-    .build(log_file)
-    .unwrap();
+    .build(log_file)?;
 
   let config = Config::builder()
     .appender(Appender::builder().build("stdout", Box::new(stdout)))
     .appender(Appender::builder().build("file", Box::new(tofile)))
-    .build(
-      Root::builder()
-        .appenders(["stdout", "file"])
-        .build(LevelFilter::Debug),
+    .logger(
+      Logger::builder()
+        .appenders(["file", "stdout"])
+        .additive(false)
+        .build("app", LevelFilter::Info),
     )
-    .unwrap();
+    .build(Root::builder().appender("stdout").build(LevelFilter::Info))?;
 
-  log4rs::init_config(config).unwrap();
+  log4rs::init_config(config)?;
+
+  Ok(())
 }
 
 /// Initialize all the files from resources
-fn init_config_file(app_dir: &PathBuf, res_dir: &PathBuf) {
+fn init_config(app_dir: &PathBuf) -> Result<()> {
   // target path
   let clash_path = app_dir.join("config.yaml");
   let verge_path = app_dir.join("verge.yaml");
   let profile_path = app_dir.join("profiles.yaml");
-  let mmdb_path = app_dir.join("Country.mmdb");
-
-  // template path
-  let clash_tmpl = res_dir.join("config_tmp.yaml");
-  let verge_tmpl = res_dir.join("verge_tmp.yaml");
-  let profiles_tmpl = res_dir.join("profiles_tmp.yaml");
-  let mmdb_tmpl = res_dir.join("Country.mmdb");
 
   if !clash_path.exists() {
-    if clash_tmpl.exists() {
-      fs::copy(clash_tmpl, clash_path).unwrap();
-    } else {
-      // make sure that the config.yaml not null
-      let content = b"\
-        mixed-port: 7890\n\
-        log-level: info\n\
-        allow-lan: false\n\
-        external-controller: 127.0.0.1:9090\n\
-        secret: \"\"\n";
-      File::create(clash_path).unwrap().write(content).unwrap();
-    }
+    fs::File::create(clash_path)?.write(tmpl::CLASH_CONFIG)?;
   }
-
-  // only copy it
-  if !verge_path.exists() && verge_tmpl.exists() {
-    fs::copy(verge_tmpl, verge_path).unwrap();
+  if !verge_path.exists() {
+    fs::File::create(verge_path)?.write(tmpl::VERGE_CONFIG)?;
   }
-  if !profile_path.exists() && profiles_tmpl.exists() {
-    fs::copy(profiles_tmpl, profile_path).unwrap();
-  }
-  if !mmdb_path.exists() && mmdb_tmpl.exists() {
-    fs::copy(mmdb_tmpl, mmdb_path).unwrap();
+  if !profile_path.exists() {
+    fs::File::create(profile_path)?.write(tmpl::PROFILES_CONFIG)?;
   }
+  Ok(())
 }
 
 /// initialize app
 pub fn init_app(package_info: &PackageInfo) {
   // create app dir
   let app_dir = dirs::app_home_dir();
-  let log_dir = app_dir.join("logs");
-  let profiles_dir = app_dir.join("profiles");
+  let log_dir = dirs::app_logs_dir();
+  let profiles_dir = dirs::app_profiles_dir();
 
   let res_dir = dirs::app_resources_dir(package_info);
 
   if !app_dir.exists() {
-    fs::create_dir(&app_dir).unwrap();
+    let _ = fs::create_dir_all(&app_dir);
   }
   if !log_dir.exists() {
-    fs::create_dir(&log_dir).unwrap();
+    let _ = fs::create_dir_all(&log_dir);
   }
   if !profiles_dir.exists() {
-    fs::create_dir(&profiles_dir).unwrap();
+    let _ = fs::create_dir_all(&profiles_dir);
   }
 
-  init_log(&log_dir);
-  init_config_file(&app_dir, &res_dir);
+  crate::log_if_err!(init_log(&log_dir));
+
+  crate::log_if_err!(init_config(&app_dir));
+
+  // copy the resource file
+  let mmdb_path = app_dir.join("Country.mmdb");
+  let mmdb_tmpl = res_dir.join("Country.mmdb");
+  if !mmdb_path.exists() && mmdb_tmpl.exists() {
+    let _ = fs::copy(mmdb_tmpl, mmdb_path);
+  }
+
+  // copy the wintun.dll
+  #[cfg(target_os = "windows")]
+  {
+    let wintun_path = app_dir.join("wintun.dll");
+    let wintun_tmpl = res_dir.join("wintun.dll");
+    if !wintun_path.exists() && wintun_tmpl.exists() {
+      let _ = fs::copy(wintun_tmpl, wintun_path);
+    }
+  }
 }

src-tauri/src/utils/mod.rs

@@ -1,7 +1,8 @@
 pub mod config;
 pub mod dirs;
-pub mod fetch;
+pub mod help;
 pub mod init;
 pub mod resolve;
 pub mod server;
-pub mod sysopt;
+pub mod tmpl;
+mod winhelp;

src-tauri/src/utils/resolve.rs

@@ -1,60 +1,102 @@
-use super::{init, server};
-use crate::{core::Profiles, states};
+use crate::{core::Core, data::Data, utils::init, utils::server};
 use tauri::{App, AppHandle, Manager};
-use tauri_plugin_shadows::Shadows;
 
 /// handle something when start app
 pub fn resolve_setup(app: &App) {
-  // set shadow when window decorations
-  let window = app.get_window("main").unwrap();
-  window.set_shadow(true);
-
-  // enable system blur
-  use tauri_plugin_vibrancy::Vibrancy;
-  #[cfg(target_os = "windows")]
-  window.apply_blur();
-  #[cfg(target_os = "macos")]
-  {
-    use tauri_plugin_vibrancy::MacOSVibrancy;
-    #[allow(deprecated)]
-    window.apply_vibrancy(MacOSVibrancy::AppearanceBased);
-  }
-
-  // setup a simple http server for singleton
-  server::embed_server(&app.handle());
-
   // init app config
   init::init_app(app.package_info());
 
-  // init states
-  let clash_state = app.state::<states::ClashState>();
-  let verge_state = app.state::<states::VergeState>();
-  let profiles_state = app.state::<states::ProfilesState>();
+  let silent_start = {
+    let global = Data::global();
+    let verge = global.verge.lock();
+    let singleton = verge.app_singleton_port.clone();
 
-  let mut clash = clash_state.0.lock().unwrap();
-  let mut verge = verge_state.0.lock().unwrap();
-  let mut profiles = profiles_state.0.lock().unwrap();
+    // setup a simple http server for singleton
+    server::embed_server(&app.handle(), singleton);
 
-  if let Err(err) = clash.run_sidecar() {
-    log::error!("{}", err);
-  }
+    verge.enable_silent_start.clone().unwrap_or(false)
+  };
 
-  *profiles = Profiles::read_file();
-  if let Err(err) = profiles.activate(&clash) {
-    log::error!("{}", err);
-  }
+  // core should be initialized after init_app fix #122
+  let core = Core::global();
+  core.init(app.app_handle());
 
-  verge.init_sysproxy(clash.info.port.clone());
-  verge.init_launch(app.package_info());
-  if let Err(err) = verge.sync_launch() {
-    log::error!("{}", err);
+  if !silent_start {
+    create_window(&app.app_handle());
   }
 }
 
 /// reset system proxy
-pub fn resolve_reset(app_handle: &AppHandle) {
-  let verge_state = app_handle.state::<states::VergeState>();
-  let mut verge = verge_state.0.lock().unwrap();
+pub fn resolve_reset() {
+  let core = Core::global();
+  let mut sysopt = core.sysopt.lock();
+  crate::log_if_err!(sysopt.reset_sysproxy());
+  drop(sysopt);
 
-  verge.reset_sysproxy();
+  let mut service = core.service.lock();
+  crate::log_if_err!(service.stop());
+}
+
+/// create main window
+pub fn create_window(app_handle: &AppHandle) {
+  if let Some(window) = app_handle.get_window("main") {
+    let _ = window.unminimize();
+    let _ = window.show();
+    let _ = window.set_focus();
+    return;
+  }
+
+  let builder = tauri::window::WindowBuilder::new(
+    app_handle,
+    "main".to_string(),
+    tauri::WindowUrl::App("index.html".into()),
+  )
+  .title("Clash Verge")
+  .center()
+  .fullscreen(false)
+  .min_inner_size(600.0, 520.0);
+
+  #[cfg(target_os = "windows")]
+  {
+    use crate::utils::winhelp;
+    use std::time::Duration;
+    use tokio::time::sleep;
+    use window_shadows::set_shadow;
+    use window_vibrancy::apply_blur;
+
+    match builder
+      .decorations(false)
+      .transparent(true)
+      .inner_size(800.0, 636.0)
+      .build()
+    {
+      Ok(_) => {
+        let app_handle = app_handle.clone();
+
+        tauri::async_runtime::spawn(async move {
+          sleep(Duration::from_secs(1)).await;
+
+          if let Some(window) = app_handle.get_window("main") {
+            let _ = window.show();
+            let _ = set_shadow(&window, true);
+
+            if !winhelp::is_win11() {
+              let _ = apply_blur(&window, None);
+            }
+          }
+        });
+      }
+      Err(err) => log::error!(target: "app", "{err}"),
+    }
+  }
+
+  #[cfg(target_os = "macos")]
+  crate::log_if_err!(builder.decorations(true).inner_size(800.0, 642.0).build());
+
+  #[cfg(target_os = "linux")]
+  crate::log_if_err!(builder
+    .decorations(false)
+    .transparent(true)
+    .inner_size(800.0, 636.0)
+    .build());
 }

src-tauri/src/utils/server.rs

@@ -1,16 +1,22 @@
 extern crate warp;
 
+use super::resolve;
 use port_scanner::local_port_available;
-use tauri::{AppHandle, Manager};
+use tauri::AppHandle;
 use warp::Filter;
 
-const SERVER_PORT: u16 = 33333;
+#[cfg(not(feature = "verge-dev"))]
+const SERVER_PORT: u16 = 33331;
+#[cfg(feature = "verge-dev")]
+const SERVER_PORT: u16 = 11233;
 
 /// check whether there is already exists
-pub fn check_singleton() -> Result<(), ()> {
-  if !local_port_available(SERVER_PORT) {
+pub fn check_singleton(port: Option<u16>) -> Result<(), ()> {
+  let port = port.unwrap_or(SERVER_PORT);
+
+  if !local_port_available(port) {
     tauri::async_runtime::block_on(async {
-      let url = format!("http://127.0.0.1:{}/commands/visible", SERVER_PORT);
+      let url = format!("http://127.0.0.1:{}/commands/visible", port);
       reqwest::get(url).await.unwrap();
       Err(())
     })
@@ -21,18 +27,16 @@ pub fn check_singleton() -> Result<(), ()> {
 
 /// The embed server only be used to implement singleton process
 /// maybe it can be used as pac server later
-pub fn embed_server(app: &AppHandle) {
-  let window = app.get_window("main").unwrap();
+pub fn embed_server(app_handle: &AppHandle, port: Option<u16>) {
+  let app_handle = app_handle.clone();
+  let port = port.unwrap_or(SERVER_PORT);
 
   tauri::async_runtime::spawn(async move {
     let commands = warp::path!("commands" / "visible").map(move || {
-      window.show().unwrap();
-      window.set_focus().unwrap();
+      resolve::create_window(&app_handle);
       return format!("ok");
     });
 
-    warp::serve(commands)
-      .bind(([127, 0, 0, 1], SERVER_PORT))
-      .await;
+    warp::serve(commands).bind(([127, 0, 0, 1], port)).await;
   });
 }

src-tauri/src/utils/sysopt.rs

@@ -1,211 +0,0 @@
-use serde::{Deserialize, Serialize};
-use std::io;
-
-#[cfg(target_os = "windows")]
-static DEFAULT_BYPASS: &str = "localhost;127.*;10.*;172.16.*;172.17.*;172.18.*;172.19.*;172.20.*;172.21.*;172.22.*;172.23.*;172.24.*;172.25.*;172.26.*;172.27.*;172.28.*;172.29.*;172.30.*;172.31.*;192.168.*;<local>";
-#[cfg(target_os = "macos")]
-static DEFAULT_BYPASS: &str =
-  "192.168.0.0/16\n10.0.0.0/8\n172.16.0.0/12\n127.0.0.1\nlocalhost\n*.local\ntimestamp.apple.com\n";
-#[cfg(target_os = "macos")]
-static MACOS_SERVICE: &str = "Wi-Fi";
-
-#[derive(Debug, Deserialize, Serialize, Clone)]
-pub struct SysProxyConfig {
-  pub enable: bool,
-  pub server: String,
-  pub bypass: String,
-}
-
-impl Default for SysProxyConfig {
-  fn default() -> Self {
-    SysProxyConfig {
-      enable: false,
-      server: String::from(""),
-      bypass: String::from(""),
-    }
-  }
-}
-
-impl SysProxyConfig {
-  pub fn new(enable: bool, port: String, bypass: Option<String>) -> Self {
-    SysProxyConfig {
-      enable,
-      server: format!("127.0.0.1:{}", port),
-      bypass: bypass.unwrap_or(DEFAULT_BYPASS.into()),
-    }
-  }
-
-  #[cfg(target_os = "windows")]
-  /// Get the windows system proxy config
-  pub fn get_sys() -> io::Result<Self> {
-    use winreg::enums::*;
-    use winreg::RegKey;
-
-    let hkcu = RegKey::predef(HKEY_CURRENT_USER);
-    let cur_var = hkcu.open_subkey_with_flags(
-      "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Internet Settings",
-      KEY_READ,
-    )?;
-
-    Ok(SysProxyConfig {
-      enable: cur_var.get_value::<u32, _>("ProxyEnable")? == 1u32,
-      server: cur_var.get_value("ProxyServer")?,
-      bypass: cur_var.get_value("ProxyOverride")?,
-    })
-  }
-
-  #[cfg(target_os = "macos")]
-  /// Get the macos system proxy config
-  pub fn get_sys() -> io::Result<Self> {
-    use std::process::Command;
-
-    let http = macproxy::get_proxy(&["-getwebproxy", MACOS_SERVICE])?;
-    let https = macproxy::get_proxy(&["-getsecurewebproxy", MACOS_SERVICE])?;
-    let sock = macproxy::get_proxy(&["-getsocksfirewallproxy", MACOS_SERVICE])?;
-
-    let mut enable = false;
-    let mut server = "".into();
-
-    if sock.0 == "Yes" {
-      enable = true;
-      server = sock.1;
-    }
-    if https.0 == "Yes" {
-      enable = true;
-      server = https.1;
-    }
-    if http.0 == "Yes" || !enable {
-      enable = http.0 == "Yes";
-      server = http.1;
-    }
-
-    let bypass_output = Command::new("networksetup")
-      .args(["-getproxybypassdomains", MACOS_SERVICE])
-      .output()?;
-    let bypass = std::str::from_utf8(&bypass_output.stdout).unwrap_or(DEFAULT_BYPASS);
-
-    Ok(SysProxyConfig {
-      enable,
-      server,
-      bypass: bypass.into(),
-    })
-  }
-
-  #[cfg(target_os = "windows")]
-  /// Set the windows system proxy config
-  pub fn set_sys(&self) -> io::Result<()> {
-    use winreg::enums::*;
-    use winreg::RegKey;
-    let hkcu = RegKey::predef(HKEY_CURRENT_USER);
-    let cur_var = hkcu.open_subkey_with_flags(
-      "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Internet Settings",
-      KEY_SET_VALUE,
-    )?;
-
-    let enable: u32 = if self.enable { 1u32 } else { 0u32 };
-
-    cur_var.set_value("ProxyEnable", &enable)?;
-    cur_var.set_value("ProxyServer", &self.server)?;
-    cur_var.set_value("ProxyOverride", &self.bypass)
-  }
-
-  #[cfg(target_os = "macos")]
-  /// Set the macos system proxy config
-  pub fn set_sys(&self) -> io::Result<()> {
-    let enable = self.enable;
-    let server = self.server.as_str();
-    macproxy::set_proxy("-setwebproxy", MACOS_SERVICE, enable, server)?;
-    macproxy::set_proxy("-setsecurewebproxy", MACOS_SERVICE, enable, server)?;
-    macproxy::set_proxy("-setsocksfirewallproxy", MACOS_SERVICE, enable, server)
-  }
-}
-
-#[cfg(target_os = "macos")]
-mod macproxy {
-  use super::*;
-  use std::process::Command;
-
-  /// use networksetup
-  /// get the target proxy config
-  pub(super) fn get_proxy(args: &[&str; 2]) -> io::Result<(String, String)> {
-    let output = Command::new("networksetup").args(args).output()?;
-    match std::str::from_utf8(&output.stdout) {
-      Ok(stdout) => {
-        let enable = parse(stdout, "Enabled:");
-        let server = parse(stdout, "Server:");
-        let port = parse(stdout, "Port:");
-        let server = format!("{}:{}", server, port);
-        Ok((enable.into(), server))
-      }
-      Err(_) => Err(io::Error::from_raw_os_error(1)),
-    }
-  }
-
-  /// use networksetup
-  /// set the target proxy config
-  pub(super) fn set_proxy(
-    target: &str, // like: -setwebproxy
-    device: &str,
-    enable: bool,
-    server: &str,
-  ) -> io::Result<()> {
-    let mut split = server.split(":");
-    let domain = split.next();
-    let port = split.next();
-
-    // can not parse the field
-    if domain.is_none() || port.is_none() {
-      return Err(io::Error::from_raw_os_error(1));
-    }
-
-    let args = vec![target, device, domain.unwrap(), port.unwrap()];
-    Command::new("networksetup").args(&args).status()?;
-
-    let target_state = String::from(target) + "state";
-    let enable = if enable { "on" } else { "off" };
-    let args = vec![target_state.as_str(), device, enable];
-    Command::new("networksetup").args(&args).status()?;
-    Ok(())
-  }
-
-  /// parse the networksetup output
-  pub(super) fn parse<'a>(target: &'a str, key: &'a str) -> &'a str {
-    match target.find(key) {
-      Some(idx) => {
-        let idx = idx + key.len();
-        let value = &target[idx..];
-        let value = match value.find("\n") {
-          Some(end) => &value[..end],
-          None => value,
-        };
-        value.trim()
-      }
-      None => "",
-    }
-  }
-
-  #[test]
-  fn test_get() {
-    use std::process::Command;
-
-    let output = Command::new("networksetup")
-      .args(["-getwebproxy", "Wi-Fi"])
-      .output();
-
-    let output = output.unwrap();
-    let stdout = std::str::from_utf8(&output.stdout).unwrap();
-    let enable = parse(stdout, "Enabled:");
-    let server = parse(stdout, "Server:");
-    let port = parse(stdout, "Port:");
-
-    println!("enable: {}, server: {}, port: {}", enable, server, port);
-
-    dbg!(SysProxyConfig::get_sys().unwrap());
-  }
-
-  #[test]
-  fn test_set() {
-    let sysproxy = SysProxyConfig::new(true, "7890".into(), None);
-    dbg!(sysproxy.set_sys().unwrap());
-  }
-}

src-tauri/src/utils/tmpl.rs

@@ -0,0 +1,69 @@
+///! Some config file template
+
+/// template for clash core `config.yaml`
+pub const CLASH_CONFIG: &[u8] = br#"# Default Config For Clash Core
+
+mixed-port: 7890
+log-level: info
+allow-lan: false
+external-controller: 127.0.0.1:9090
+mode: rule
+secret: ""
+"#;
+
+/// template for `profiles.yaml`
+pub const PROFILES_CONFIG: &[u8] = b"# Profiles Config for Clash Verge
+
+current: ~
+items: ~
+";
+
+/// template for `verge.yaml`
+pub const VERGE_CONFIG: &[u8] = b"# Defaulf Config For Clash Verge
+
+language: en
+theme_mode: light
+theme_blur: false
+traffic_graph: true
+enable_self_startup: false
+enable_system_proxy: false
+enable_proxy_guard: false
+proxy_guard_duration: 10
+";
+
+/// template for new a profile item
+pub const ITEM_LOCAL: &str = "# Profile Template for clash verge
+
+proxies:
+
+proxy-groups:
+
+rules:
+";
+
+/// enhanced profile
+pub const ITEM_MERGE: &str = "# Merge Template for clash verge
+# The `Merge` format used to enhance profile
+
+prepend-rules:
+
+prepend-proxies:
+
+prepend-proxy-groups:
+
+append-rules:
+
+append-proxies:
+
+append-proxy-groups:
+";
+
+/// enhanced profile
+pub const ITEM_SCRIPT: &str = "// Define the `main` function
+// The argument to this function is the clash config 
+// or the result of the previous handler
+// so you should return the config after processing
+function main(params) {
+  return params;
+}
+";

src-tauri/src/utils/winhelp.rs

@@ -0,0 +1,69 @@
+#![cfg(target_os = "windows")]
+#![allow(non_snake_case)]
+#![allow(non_camel_case_types)]
+
+//!
+//! From https://github.com/tauri-apps/window-vibrancy/blob/dev/src/windows.rs
+//!
+
+use windows_sys::Win32::{
+  Foundation::*,
+  System::{LibraryLoader::*, SystemInformation::*},
+};
+
+fn get_function_impl(library: &str, function: &str) -> Option<FARPROC> {
+  assert_eq!(library.chars().last(), Some('\0'));
+  assert_eq!(function.chars().last(), Some('\0'));
+
+  let module = unsafe { LoadLibraryA(library.as_ptr()) };
+  if module == 0 {
+    return None;
+  }
+  Some(unsafe { GetProcAddress(module, function.as_ptr()) })
+}
+
+macro_rules! get_function {
+  ($lib:expr, $func:ident) => {
+    get_function_impl(concat!($lib, '\0'), concat!(stringify!($func), '\0')).map(|f| unsafe {
+      std::mem::transmute::<::windows_sys::Win32::Foundation::FARPROC, $func>(f)
+    })
+  };
+}
+
+/// Returns a tuple of (major, minor, buildnumber)
+fn get_windows_ver() -> Option<(u32, u32, u32)> {
+  type RtlGetVersion = unsafe extern "system" fn(*mut OSVERSIONINFOW) -> i32;
+  let handle = get_function!("ntdll.dll", RtlGetVersion);
+  if let Some(rtl_get_version) = handle {
+    unsafe {
+      let mut vi = OSVERSIONINFOW {
+        dwOSVersionInfoSize: 0,
+        dwMajorVersion: 0,
+        dwMinorVersion: 0,
+        dwBuildNumber: 0,
+        dwPlatformId: 0,
+        szCSDVersion: [0; 128],
+      };
+
+      let status = (rtl_get_version)(&mut vi as _);
+
+      if status >= 0 {
+        Some((vi.dwMajorVersion, vi.dwMinorVersion, vi.dwBuildNumber))
+      } else {
+        None
+      }
+    }
+  } else {
+    None
+  }
+}
+
+pub fn is_win11() -> bool {
+  let v = get_windows_ver().unwrap_or_default();
+  v.2 >= 22000
+}
+
+#[test]
+fn test_version() {
+  dbg!(get_windows_ver().unwrap_or_default());
+}

src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "package": {
-    "productName": "clash-verge",
-    "version": "0.0.14"
+    "productName": "Clash Verge",
+    "version": "1.1.1"
   },
   "build": {
     "distDir": "../dist",
@@ -11,7 +11,7 @@
   },
   "tauri": {
     "systemTray": {
-      "iconPath": "icons/icon.png",
+      "iconPath": "icons/tray-icon.ico",
       "iconAsTemplate": true
     },
     "bundle": {
@@ -22,23 +22,26 @@
         "icons/32x32.png",
         "icons/128x128.png",
         "icons/128x128@2x.png",
-        "icons/icon.icns",
+        "icons/icon-new.icns",
         "icons/icon.ico"
       ],
-      "resources": ["resources"],
-      "externalBin": ["sidecar/clash"],
-      "copyright": "© 2021 zzzgydi All Rights Reserved",
+      "resources": [
+        "resources"
+      ],
+      "externalBin": [
+        "sidecar/clash",
+        "sidecar/clash-meta"
+      ],
+      "copyright": "© 2022 zzzgydi All Rights Reserved",
       "category": "DeveloperTool",
       "shortDescription": "A Clash GUI based on tauri.",
       "longDescription": "A Clash GUI based on tauri.",
       "deb": {
-        "depends": [],
-        "useBootstrapper": false
+        "depends": []
       },
       "macOS": {
         "frameworks": [],
         "minimumSystemVersion": "",
-        "useBootstrapper": false,
         "exceptionDomain": "",
         "signingIdentity": null,
         "entitlements": null
@@ -46,34 +49,41 @@
       "windows": {
         "certificateThumbprint": null,
         "digestAlgorithm": "sha256",
-        "timestampUrl": ""
+        "timestampUrl": "",
+        "wix": {
+          "language": [
+            "zh-CN",
+            "en-US"
+          ]
+        }
       }
     },
     "updater": {
       "active": true,
       "endpoints": [
-        "https://github.com/zzzgydi/clash-verge/releases/download/updater/update.json"
+        "https://github.com/zzzgydi/clash-verge/releases/download/updater/update.json",
+        "https://hub.fastgit.xyz/zzzgydi/clash-verge/releases/download/updater/update-proxy.json"
       ],
-      "dialog": false
+      "dialog": false,
+      "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IDExNUFBNTBBN0FDNEFBRTUKUldUbHFzUjZDcVZhRVRJM25NS3NkSFlFVElxUkNZMzZ6bHUwRVJjb2F3alJXVzRaeDdSaTA2YWYK"
     },
     "allowlist": {
-      "all": true
-    },
-    "windows": [
-      {
-        "title": "Clash Verge",
-        "width": 800,
-        "height": 600,
-        "resizable": true,
-        "fullscreen": false,
-        "decorations": false,
-        "transparent": true,
-        "minWidth": 600,
-        "minHeight": 520
+      "shell": {
+        "all": true
+      },
+      "window": {
+        "all": true
+      },
+      "process": {
+        "all": true
+      },
+      "globalShortcut": {
+        "all": true
       }
-    ],
+    },
+    "windows": [],
     "security": {
-      "csp": "default-src blob: data: filesystem: ws: wss: http: https: tauri: 'unsafe-eval' 'unsafe-inline' 'self' img-src: 'self'"
+      "csp": "script-src 'unsafe-eval' 'self'; default-src blob: data: filesystem: ws: wss: http: https: tauri: 'unsafe-eval' 'unsafe-inline' 'self'; img-src data: 'self';"
     }
   }
-}
+}

src/assets/styles/index.scss

@@ -4,12 +4,14 @@ body {
     "Ubuntu", "Cantarell", "Fira Sans", "Droid Sans", "Helvetica Neue",
     sans-serif;
   -webkit-font-smoothing: antialiased;
+  user-select: none;
 }
 
 :root {
   --primary-main: #5b5c9d;
   --text-primary: #637381;
   --selection-color: #f5f5f5;
+  --scroller-color: #90939980;
 }
 
 ::selection {
@@ -24,8 +26,14 @@ body {
 }
 *::-webkit-scrollbar-thumb {
   border-radius: 6px;
-  background-color: rgba(#909399, 0.5);
+  background-color: var(--scroller-color);
 }
 
 @import "./layout.scss";
 @import "./page.scss";
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    background-color: rgba(18, 18, 18, 1);
+  }
+}

src/assets/styles/layout.scss

@@ -10,37 +10,42 @@
     height: 100%;
     max-width: 225px;
     min-width: 125px;
-    padding: 8px 0;
+    padding: 16px 0 8px;
     flex-direction: column;
     box-sizing: border-box;
     user-select: none;
     overflow: hidden;
 
+    $maxLogo: 100px;
+
     .the-logo {
       position: relative;
-      flex: 0 1 180px;
+      flex: 0 1 $maxLogo;
       width: 100%;
-      max-width: 180px;
-      max-height: 180px;
+      max-width: $maxLogo + 32px;
+      max-height: $maxLogo;
       margin: 0 auto;
-      padding: 0 8px;
+      padding: 0 16px;
       text-align: center;
       box-sizing: border-box;
 
-      img {
+      img,
+      svg {
         width: 100%;
+        height: 100%;
+        pointer-events: none;
       }
 
       .the-newbtn {
         position: absolute;
-        right: 20px;
-        bottom: 12px;
+        right: 10px;
+        bottom: 0px;
         transform: scale(0.8);
       }
     }
 
     .the-menu {
-      flex: 1 1 75%;
+      flex: 1 1 80%;
       overflow-y: auto;
       margin-bottom: 8px;
     }
@@ -72,10 +77,27 @@
 
     .the-content {
       position: absolute;
-      top: 30px;
+      top: 0;
       left: 0;
       right: 2px;
       bottom: 10px;
     }
   }
 }
+
+.linux,
+.windows,
+.unknown {
+  &.layout {
+    $maxLogo: 115px;
+    .layout__left .the-logo {
+      flex: 0 1 $maxLogo;
+      max-width: $maxLogo + 32px;
+      max-height: $maxLogo;
+    }
+
+    .layout__right .the-content {
+      top: 30px;
+    }
+  }
+}

src/components/base/base-empty.tsx

@@ -0,0 +1,31 @@
+import { alpha, Box, Typography } from "@mui/material";
+import { BlurOnRounded } from "@mui/icons-material";
+
+interface Props {
+  text?: React.ReactNode;
+  extra?: React.ReactNode;
+}
+
+const BaseEmpty = (props: Props) => {
+  const { text = "Empty", extra } = props;
+
+  return (
+    <Box
+      sx={({ palette }) => ({
+        width: "100%",
+        height: "100%",
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "center",
+        justifyContent: "center",
+        color: alpha(palette.text.secondary, 0.75),
+      })}
+    >
+      <BlurOnRounded sx={{ fontSize: "4em" }} />
+      <Typography sx={{ fontSize: "1.25em" }}>{text}</Typography>
+      {extra}
+    </Box>
+  );
+};
+
+export default BaseEmpty;

src/components/base/base-loading.tsx

@@ -0,0 +1,50 @@
+import { styled } from "@mui/material";
+
+const Loading = styled("div")`
+  position: relative;
+  display: flex;
+  height: 100%;
+  min-height: 18px;
+  box-sizing: border-box;
+  align-items: center;
+
+  & > div {
+    box-sizing: border-box;
+    width: 6px;
+    height: 6px;
+    margin: 2px;
+    border-radius: 100%;
+    animation: loading 0.7s -0.15s infinite linear;
+  }
+
+  & > div:nth-child(2n-1) {
+    animation-delay: -0.5s;
+  }
+
+  @keyframes loading {
+    50% {
+      opacity: 0.2;
+      transform: scale(0.75);
+    }
+    100% {
+      opacity: 1;
+      transform: scale(1);
+    }
+  }
+`;
+
+const LoadingItem = styled("div")(({ theme }) => ({
+  background: theme.palette.text.secondary,
+}));
+
+const BaseLoading = () => {
+  return (
+    <Loading>
+      <LoadingItem />
+      <LoadingItem />
+      <LoadingItem />
+    </Loading>
+  );
+};
+
+export default BaseLoading;

src/components/base/base-notice.tsx

@@ -11,7 +11,7 @@ interface InnerProps {
 }
 
 const NoticeInner = (props: InnerProps) => {
-  const { type, message, duration = 2000, onClose } = props;
+  const { type, message, duration = 1500, onClose } = props;
   const [visible, setVisible] = useState(true);
 
   const onBtnClose = () => {
@@ -26,12 +26,13 @@ const NoticeInner = (props: InnerProps) => {
     type === "info" ? (
       message
     ) : (
-      <Box sx={{ display: "flex", alignItems: "center" }}>
+      <Box sx={{ width: 328, display: "flex", alignItems: "center" }}>
         {type === "error" && <ErrorRounded color="error" />}
         {type === "success" && <CheckCircleRounded color="success" />}
 
         <Typography
-          sx={{ ml: 1, wordWrap: "break-word", wordBreak: "break-all" }}
+          component="span"
+          sx={{ ml: 1, wordWrap: "break-word", width: "calc(100% - 35px)" }}
         >
           {message}
         </Typography>
@@ -79,14 +80,16 @@ const Notice: NoticeInstance = (props) => {
 
   const onUnmount = () => {
     const result = ReactDOM.unmountComponentAtNode(container);
-    if (result && parent) parent.removeChild(container);
+    if (result && parent) setTimeout(() => parent.removeChild(container), 500);
   };
 
   ReactDOM.render(<NoticeInner {...props} onClose={onUnmount} />, container);
 };
 
 (["info", "error", "success"] as const).forEach((type) => {
-  Notice[type] = (message, duration) => Notice({ type, message, duration });
+  Notice[type] = (message, duration) => {
+    setTimeout(() => Notice({ type, message, duration }), 0);
+  };
 });
 
 export default Notice;

src/components/base/base-page.tsx

@@ -12,8 +12,8 @@ const BasePage: React.FC<Props> = (props) => {
 
   return (
     <div className="base-page" data-windrag>
-      <header data-windrag>
-        <Typography variant="h4" component="h1">
+      <header data-windrag style={{ userSelect: "none" }}>
+        <Typography variant="h4" component="h1" data-windrag>
           {title}
         </Typography>
 

src/components/connection-item.tsx

@@ -1,13 +0,0 @@
-import { ApiType } from "../services/types";
-
-interface Props {
-  value: ApiType.ConnectionsItem;
-}
-
-const ConnectionItem = (props: Props) => {
-  const { value } = props;
-
-  return <div>{value.metadata.host || value.metadata.destinationIP}</div>;
-};
-
-export default ConnectionItem;

src/components/connection/connection-item.tsx

@@ -0,0 +1,75 @@
+import dayjs from "dayjs";
+import { useLockFn } from "ahooks";
+import {
+  styled,
+  ListItem,
+  IconButton,
+  ListItemText,
+  Box,
+  alpha,
+} from "@mui/material";
+import { CloseRounded } from "@mui/icons-material";
+import { deleteConnection } from "@/services/api";
+import parseTraffic from "@/utils/parse-traffic";
+
+const Tag = styled("span")(({ theme }) => ({
+  fontSize: "10px",
+  padding: "0 4px",
+  lineHeight: 1.375,
+  border: "1px solid",
+  borderRadius: 4,
+  borderColor: alpha(theme.palette.text.secondary, 0.35),
+  marginRight: "4px",
+}));
+
+interface Props {
+  value: ApiType.ConnectionsItem;
+}
+
+const ConnectionItem = (props: Props) => {
+  const { value } = props;
+
+  const { id, metadata, chains, start, curUpload, curDownload } = value;
+
+  const onDelete = useLockFn(async () => deleteConnection(id));
+  const showTraffic = curUpload! >= 100 || curDownload! >= 100;
+
+  return (
+    <ListItem
+      dense
+      secondaryAction={
+        <IconButton edge="end" color="inherit" onClick={onDelete}>
+          <CloseRounded />
+        </IconButton>
+      }
+    >
+      <ListItemText
+        sx={{ userSelect: "text" }}
+        primary={metadata.host || metadata.destinationIP}
+        secondary={
+          <Box sx={{ display: "flex", flexWrap: "wrap" }}>
+            <Tag sx={{ textTransform: "uppercase", color: "success" }}>
+              {metadata.network}
+            </Tag>
+
+            <Tag>{metadata.type}</Tag>
+
+            {!!metadata.process && <Tag>{metadata.process}</Tag>}
+
+            {chains.length > 0 && <Tag>{chains[value.chains.length - 1]}</Tag>}
+
+            <Tag>{dayjs(start).fromNow()}</Tag>
+
+            {showTraffic && (
+              <Tag>
+                {parseTraffic(curUpload!)} / {parseTraffic(curDownload!)}
+              </Tag>
+            )}
+          </Box>
+        }
+      />
+    </ListItem>
+  );
+};
+
+export default ConnectionItem;

src/components/connection/connection-table.tsx

@@ -0,0 +1,144 @@
+import dayjs from "dayjs";
+import { useMemo } from "react";
+import { DataGrid, GridColDef } from "@mui/x-data-grid";
+import parseTraffic from "@/utils/parse-traffic";
+
+interface Props {
+  connections: ApiType.ConnectionsItem[];
+}
+
+const ConnectionTable = (props: Props) => {
+  const { connections } = props;
+
+  const columns: GridColDef[] = [
+    {
+      field: "host",
+      headerName: "Host",
+      flex: 200,
+      minWidth: 200,
+      resizable: false,
+      disableColumnMenu: true,
+    },
+    {
+      field: "download",
+      headerName: "Download",
+      width: 88,
+      align: "right",
+      headerAlign: "right",
+      disableColumnMenu: true,
+      valueFormatter: (params: any) => parseTraffic(params.value).join(" "),
+    },
+    {
+      field: "upload",
+      headerName: "Upload",
+      width: 88,
+      align: "right",
+      headerAlign: "right",
+      disableColumnMenu: true,
+      valueFormatter: (params: any) => parseTraffic(params.value).join(" "),
+    },
+    {
+      field: "dlSpeed",
+      headerName: "DL Speed",
+      align: "right",
+      width: 88,
+      headerAlign: "right",
+      disableColumnMenu: true,
+      valueFormatter: (params: any) =>
+        parseTraffic(params.value).join(" ") + "/s",
+    },
+    {
+      field: "ulSpeed",
+      headerName: "UL Speed",
+      width: 88,
+      align: "right",
+      headerAlign: "right",
+      disableColumnMenu: true,
+      valueFormatter: (params: any) =>
+        parseTraffic(params.value).join(" ") + "/s",
+    },
+    {
+      field: "chains",
+      headerName: "Chains",
+      width: 360,
+      disableColumnMenu: true,
+    },
+    {
+      field: "rule",
+      headerName: "Rule",
+      width: 225,
+      disableColumnMenu: true,
+    },
+    {
+      field: "process",
+      headerName: "Process",
+      width: 120,
+      disableColumnMenu: true,
+    },
+    {
+      field: "time",
+      headerName: "Time",
+      width: 120,
+      align: "right",
+      headerAlign: "right",
+      disableColumnMenu: true,
+      valueFormatter: (params) => dayjs(params.value).fromNow(),
+    },
+    {
+      field: "source",
+      headerName: "Source",
+      width: 150,
+      disableColumnMenu: true,
+    },
+    {
+      field: "destinationIP",
+      headerName: "Destination IP",
+      width: 125,
+      disableColumnMenu: true,
+    },
+    {
+      field: "type",
+      headerName: "Type",
+      width: 160,
+      disableColumnMenu: true,
+    },
+  ];
+
+  const connRows = useMemo(() => {
+    return connections.map((each) => {
+      const { metadata, rulePayload } = each;
+      const chains = [...each.chains].reverse().join(" / ");
+      const rule = rulePayload ? `${each.rule}(${rulePayload})` : each.rule;
+
+      return {
+        id: each.id,
+        host: metadata.host
+          ? `${metadata.host}:${metadata.destinationPort}`
+          : `${metadata.destinationIP}:${metadata.destinationPort}`,
+        download: each.download,
+        upload: each.upload,
+        dlSpeed: each.curDownload,
+        ulSpeed: each.curUpload,
+        chains,
+        rule,
+        process: metadata.process || metadata.processPath,
+        time: each.start,
+        source: `${metadata.sourceIP}:${metadata.sourcePort}`,
+        destinationIP: metadata.destinationIP,
+        type: `${metadata.type}(${metadata.network})`,
+      };
+    });
+  }, [connections]);
+
+  return (
+    <DataGrid
+      rows={connRows}
+      columns={columns}
+      density="compact"
+      sx={{ border: "none", "div:focus": { outline: "none !important" } }}
+      hideFooter
+    />
+  );
+};
+
+export default ConnectionTable;

src/components/layout/layout-control.tsx

@@ -30,7 +30,7 @@ const LayoutControl = () => {
       <Button
         size="small"
         sx={{ minWidth, svg: { transform: "scale(1.05)" } }}
-        onClick={() => appWindow.hide()}
+        onClick={() => appWindow.close()}
       >
         <CloseRounded fontSize="small" />
       </Button>

src/components/layout/layout-traffic.tsx

@@ -1,30 +1,58 @@
-import { useEffect, useState } from "react";
+import useSWR from "swr";
+import { useEffect, useRef, useState } from "react";
 import { useRecoilValue } from "recoil";
 import { Box, Typography } from "@mui/material";
 import { ArrowDownward, ArrowUpward } from "@mui/icons-material";
-import { getInfomation } from "../services/api";
-import { ApiType } from "../services/types";
-import { atomClashPort } from "../states/setting";
-import parseTraffic from "../utils/parse-traffic";
+import { listen } from "@tauri-apps/api/event";
+import { getInformation } from "@/services/api";
+import { getVergeConfig } from "@/services/cmds";
+import { atomClashPort } from "@/services/states";
+import TrafficGraph from "./traffic-graph";
+import useLogSetup from "./use-log-setup";
+import parseTraffic from "@/utils/parse-traffic";
 
-const Traffic = () => {
+// setup the traffic
+const LayoutTraffic = () => {
   const portValue = useRecoilValue(atomClashPort);
   const [traffic, setTraffic] = useState({ up: 0, down: 0 });
+  const [refresh, setRefresh] = useState({});
+
+  const trafficRef = useRef<any>();
+
+  // whether hide traffic graph
+  const { data } = useSWR("getVergeConfig", getVergeConfig);
+  const trafficGraph = data?.traffic_graph ?? true;
+
+  // setup log ws during layout
+  useLogSetup();
+
+  useEffect(() => {
+    // should reconnect the traffic ws
+    const unlisten = listen("verge://refresh-clash-config", () =>
+      setRefresh({})
+    );
+
+    return () => {
+      unlisten.then((fn) => fn());
+    };
+  }, []);
 
   useEffect(() => {
     let ws: WebSocket | null = null;
 
-    getInfomation().then((result) => {
+    getInformation().then((result) => {
       const { server = "", secret = "" } = result;
       ws = new WebSocket(`ws://${server}/traffic?token=${secret}`);
 
       ws.addEventListener("message", (event) => {
-        setTraffic(JSON.parse(event.data) as ApiType.TrafficItem);
+        const data = JSON.parse(event.data) as ApiType.TrafficItem;
+        trafficRef.current?.appendData(data);
+        setTraffic(data);
       });
     });
 
     return () => ws?.close();
-  }, [portValue]);
+  }, [portValue, refresh]);
 
   const [up, upUnit] = parseTraffic(traffic.up);
   const [down, downUnit] = parseTraffic(traffic.down);
@@ -44,7 +72,17 @@ const Traffic = () => {
   };
 
   return (
-    <Box width="110px">
+    <Box
+      width="110px"
+      position="relative"
+      onClick={trafficRef.current?.toggleStyle}
+    >
+      {trafficGraph && (
+        <div style={{ width: "100%", height: 60, marginBottom: 6 }}>
+          <TrafficGraph instance={trafficRef} />
+        </div>
+      )}
+
       <Box mb={1.5} display="flex" alignItems="center" whiteSpace="nowrap">
         <ArrowUpward
           fontSize="small"
@@ -66,4 +104,4 @@ const Traffic = () => {
   );
 };
 
-export default Traffic;
+export default LayoutTraffic;

src/components/layout/traffic-graph.tsx

@@ -0,0 +1,201 @@
+import { useEffect, useRef } from "react";
+import { useTheme } from "@mui/material";
+
+const maxPoint = 30;
+
+const refLineAlpha = 1;
+const refLineWidth = 2;
+
+const upLineAlpha = 0.6;
+const upLineWidth = 4;
+
+const downLineAlpha = 1;
+const downLineWidth = 4;
+
+const defaultList = Array(maxPoint + 2).fill({ up: 0, down: 0 });
+
+type TrafficData = { up: number; down: number };
+
+interface Props {
+  instance: React.MutableRefObject<{
+    appendData: (data: TrafficData) => void;
+    toggleStyle: () => void;
+  }>;
+}
+
+/**
+ * draw the traffic graph
+ */
+const TrafficGraph = (props: Props) => {
+  const { instance } = props;
+
+  const countRef = useRef(0);
+  const styleRef = useRef(true);
+  const listRef = useRef<TrafficData[]>(defaultList);
+  const canvasRef = useRef<HTMLCanvasElement>(null!);
+
+  const { palette } = useTheme();
+
+  useEffect(() => {
+    let timer: any;
+    let cache: TrafficData | null = null;
+    const zero = { up: 0, down: 0 };
+
+    const handleData = () => {
+      const data = cache ? cache : zero;
+      cache = null;
+
+      const list = listRef.current;
+      if (list.length > maxPoint + 2) list.shift();
+      list.push(data);
+      countRef.current = 0;
+
+      timer = setTimeout(handleData, 1000);
+    };
+
+    instance.current = {
+      appendData: (data: TrafficData) => {
+        cache = data;
+      },
+      toggleStyle: () => {
+        styleRef.current = !styleRef.current;
+      },
+    };
+
+    handleData();
+
+    return () => {
+      instance.current = null!;
+      if (timer) clearTimeout(timer);
+    };
+  }, []);
+
+  useEffect(() => {
+    let raf = 0;
+    const canvas = canvasRef.current!;
+
+    if (!canvas) return;
+
+    const context = canvas.getContext("2d")!;
+
+    if (!context) return;
+
+    const { primary, secondary, divider } = palette;
+    const refLineColor = divider || "rgba(0, 0, 0, 0.12)";
+    const upLineColor = secondary.main || "#9c27b0";
+    const downLineColor = primary.main || "#5b5c9d";
+
+    const width = canvas.width;
+    const height = canvas.height;
+    const dx = width / maxPoint;
+    const dy = height / 7;
+    const l1 = dy;
+    const l2 = dy * 4;
+
+    const countY = (v: number) => {
+      const h = height;
+
+      if (v == 0) return h - 1;
+      if (v <= 10) return h - (v / 10) * dy;
+      if (v <= 100) return h - (v / 100 + 1) * dy;
+      if (v <= 1024) return h - (v / 1024 + 2) * dy;
+      if (v <= 10240) return h - (v / 10240 + 3) * dy;
+      if (v <= 102400) return h - (v / 102400 + 4) * dy;
+      if (v <= 1048576) return h - (v / 1048576 + 5) * dy;
+      if (v <= 10485760) return h - (v / 10485760 + 6) * dy;
+      return 1;
+    };
+
+    const drawBezier = (list: number[], offset: number) => {
+      const points = list.map((y, i) => [
+        (dx * (i - 1) - offset + 3) | 0,
+        countY(y),
+      ]);
+
+      let x = points[0][0];
+      let y = points[0][1];
+
+      context.moveTo(x, y);
+
+      for (let i = 1; i < points.length; i++) {
+        const p1 = points[i];
+        const p2 = points[i + 1] || p1;
+
+        const x1 = (p1[0] + p2[0]) / 2;
+        const y1 = (p1[1] + p2[1]) / 2;
+
+        context.quadraticCurveTo(p1[0], p1[1], x1, y1);
+        x = x1;
+        y = y1;
+      }
+    };
+
+    const drawLine = (list: number[], offset: number) => {
+      const points = list.map((y, i) => [
+        (dx * (i - 1) - offset) | 0,
+        countY(y),
+      ]);
+
+      context.moveTo(points[0][0], points[0][1]);
+
+      for (let i = 1; i < points.length; i++) {
+        const p = points[i];
+        context.lineTo(p[0], p[1]);
+      }
+    };
+
+    const drawGraph = (lastTime: number) => {
+      const listUp = listRef.current.map((v) => v.up);
+      const listDown = listRef.current.map((v) => v.down);
+      const lineStyle = styleRef.current;
+
+      const now = Date.now();
+      const diff = now - lastTime;
+      const temp = Math.min((diff / 1000) * dx + countRef.current, dx);
+      const offset = countRef.current === 0 ? 0 : temp;
+      countRef.current = temp;
+
+      context.clearRect(0, 0, width, height);
+
+      // Reference lines
+      context.beginPath();
+      context.globalAlpha = refLineAlpha;
+      context.lineWidth = refLineWidth;
+      context.strokeStyle = refLineColor;
+      context.moveTo(0, l1);
+      context.lineTo(width, l1);
+      context.moveTo(0, l2);
+      context.lineTo(width, l2);
+      context.stroke();
+      context.closePath();
+
+      context.beginPath();
+      context.globalAlpha = upLineAlpha;
+      context.lineWidth = upLineWidth;
+      context.strokeStyle = upLineColor;
+      lineStyle ? drawBezier(listUp, offset) : drawLine(listUp, offset);
+      context.stroke();
+      context.closePath();
+
+      context.beginPath();
+      context.globalAlpha = downLineAlpha;
+      context.lineWidth = downLineWidth;
+      context.strokeStyle = downLineColor;
+      lineStyle ? drawBezier(listDown, offset) : drawLine(listDown, offset);
+      context.stroke();
+      context.closePath();
+
+      raf = requestAnimationFrame(() => drawGraph(now));
+    };
+
+    drawGraph(Date.now());
+
+    return () => {
+      cancelAnimationFrame(raf);
+    };
+  }, [palette]);
+
+  return <canvas ref={canvasRef} style={{ width: "100%", height: "100%" }} />;
+};
+
+export default TrafficGraph;

src/components/layout/update-button.tsx

@@ -32,7 +32,9 @@ const UpdateButton = (props: Props) => {
         New
       </Button>
 
-      <UpdateDialog open={dialogOpen} onClose={() => setDialogOpen(false)} />
+      {dialogOpen && (
+        <UpdateDialog open={dialogOpen} onClose={() => setDialogOpen(false)} />
+      )}
     </>
   );
 };

src/components/layout/update-dialog.tsx

@@ -1,62 +1,83 @@
 import useSWR from "swr";
-import { useState } from "react";
-import { checkUpdate, installUpdate } from "@tauri-apps/api/updater";
-import { relaunch } from "@tauri-apps/api/process";
+import snarkdown from "snarkdown";
+import { useMemo } from "react";
+import { useRecoilState } from "recoil";
+import { useTranslation } from "react-i18next";
 import {
+  Box,
   Button,
   Dialog,
   DialogActions,
   DialogContent,
-  DialogContentText,
   DialogTitle,
+  styled,
 } from "@mui/material";
+import { relaunch } from "@tauri-apps/api/process";
+import { checkUpdate, installUpdate } from "@tauri-apps/api/updater";
+import { atomUpdateState } from "@/services/states";
+import Notice from "../base/base-notice";
 
 interface Props {
   open: boolean;
   onClose: () => void;
 }
 
-let uploadingState = false;
+const UpdateLog = styled(Box)(() => ({
+  "h1,h2,h3,ul,ol,p": { margin: "0.5em 0", color: "inherit" },
+}));
 
 const UpdateDialog = (props: Props) => {
   const { open, onClose } = props;
+  const { t } = useTranslation();
   const { data: updateInfo } = useSWR("checkUpdate", checkUpdate, {
     errorRetryCount: 2,
     revalidateIfStale: false,
     focusThrottleInterval: 36e5, // 1 hour
   });
-  const [uploading, setUploading] = useState(uploadingState);
+
+  const [updateState, setUpdateState] = useRecoilState(atomUpdateState);
 
   const onUpdate = async () => {
+    if (updateState) return;
+    setUpdateState(true);
+
     try {
-      setUploading(true);
-      uploadingState = true;
       await installUpdate();
       await relaunch();
-    } catch (error) {
-      console.log(error);
-      window.alert("Failed to upload, please try again.");
+    } catch (err: any) {
+      Notice.error(err?.message || err.toString());
     } finally {
-      setUploading(true);
-      uploadingState = true;
+      setUpdateState(false);
     }
   };
 
+  // markdown parser
+  const parseContent = useMemo(() => {
+    if (!updateInfo?.manifest?.body) {
+      return "New Version is available";
+    }
+    return snarkdown(updateInfo?.manifest?.body);
+  }, [updateInfo]);
+
   return (
     <Dialog open={open} onClose={onClose}>
       <DialogTitle>New Version v{updateInfo?.manifest?.version}</DialogTitle>
+
       <DialogContent sx={{ minWidth: 360, maxWidth: 400, maxHeight: "50vh" }}>
-        <DialogContentText>{updateInfo?.manifest?.body}</DialogContentText>
+        <UpdateLog dangerouslySetInnerHTML={{ __html: parseContent }} />
       </DialogContent>
+
       <DialogActions>
-        <Button onClick={onClose}>Cancel</Button>
+        <Button variant="outlined" onClick={onClose}>
+          {t("Cancel")}
+        </Button>
         <Button
-          variant="contained"
           autoFocus
+          variant="contained"
+          disabled={updateState}
           onClick={onUpdate}
-          disabled={uploading}
         >
-          Update
+          {t("Update")}
         </Button>
       </DialogActions>
     </Dialog>

src/components/layout/use-custom-theme.ts

@@ -0,0 +1,103 @@
+import useSWR from "swr";
+import { useEffect, useMemo } from "react";
+import { useRecoilState } from "recoil";
+import { createTheme } from "@mui/material";
+import { appWindow } from "@tauri-apps/api/window";
+import { getVergeConfig } from "@/services/cmds";
+import { atomThemeMode } from "@/services/states";
+import { defaultTheme, defaultDarkTheme } from "@/pages/_theme";
+
+/**
+ * custome theme
+ */
+export default function useCustomTheme() {
+  const { data } = useSWR("getVergeConfig", getVergeConfig);
+  const { theme_mode, theme_setting } = data ?? {};
+  const [mode, setMode] = useRecoilState(atomThemeMode);
+
+  useEffect(() => {
+    const themeMode = ["light", "dark", "system"].includes(theme_mode!)
+      ? theme_mode!
+      : "light";
+
+    if (themeMode !== "system") {
+      setMode(themeMode);
+      return;
+    }
+
+    appWindow.theme().then((m) => m && setMode(m));
+    const unlisten = appWindow.onThemeChanged((e) => setMode(e.payload));
+
+    return () => {
+      unlisten.then((fn) => fn());
+    };
+  }, [theme_mode]);
+
+  const theme = useMemo(() => {
+    const setting = theme_setting || {};
+    const dt = mode === "light" ? defaultTheme : defaultDarkTheme;
+
+    const theme = createTheme({
+      breakpoints: {
+        values: { xs: 0, sm: 650, md: 900, lg: 1200, xl: 1536 },
+      },
+      palette: {
+        mode,
+        primary: { main: setting.primary_color || dt.primary_color },
+        secondary: { main: setting.secondary_color || dt.secondary_color },
+        info: { main: setting.info_color || dt.info_color },
+        error: { main: setting.error_color || dt.error_color },
+        warning: { main: setting.warning_color || dt.warning_color },
+        success: { main: setting.success_color || dt.success_color },
+        text: {
+          primary: setting.primary_text || dt.primary_text,
+          secondary: setting.secondary_text || dt.secondary_text,
+        },
+      },
+      typography: {
+        // todo
+        fontFamily: setting.font_family
+          ? `${setting.font_family}, ${dt.font_family}`
+          : dt.font_family,
+      },
+    });
+
+    // css
+    const selectColor = mode === "light" ? "#f5f5f5" : "#d5d5d5";
+    const scrollColor = mode === "light" ? "#90939980" : "#54545480";
+
+    const rootEle = document.documentElement;
+    rootEle.style.setProperty("--selection-color", selectColor);
+    rootEle.style.setProperty("--scroller-color", scrollColor);
+    rootEle.style.setProperty("--primary-main", theme.palette.primary.main);
+
+    // inject css
+    let style = document.querySelector("style#verge-theme");
+    if (!style) {
+      style = document.createElement("style");
+      style.id = "verge-theme";
+      document.head.appendChild(style!);
+    }
+    if (style) {
+      style.innerHTML = setting.css_injection || "";
+    }
+
+    // update svg icon
+    const { palette } = theme;
+
+    setTimeout(() => {
+      const dom = document.querySelector("#Gradient2");
+      if (dom) {
+        dom.innerHTML = `
+        <stop offset="0%" stop-color="${palette.primary.main}" />
+        <stop offset="80%" stop-color="${palette.primary.dark}" />
+        <stop offset="100%" stop-color="${palette.primary.dark}" />
+        `;
+      }
+    }, 0);
+
+    return theme;
+  }, [mode, theme_setting]);
+
+  return { theme };
+}

src/components/layout/use-log-setup.ts

@@ -0,0 +1,48 @@
+import dayjs from "dayjs";
+import { useEffect, useState } from "react";
+import { useRecoilValue, useSetRecoilState } from "recoil";
+import { listen } from "@tauri-apps/api/event";
+import { getInformation } from "@/services/api";
+import { getClashLogs } from "@/services/cmds";
+import { atomEnableLog, atomLogData } from "@/services/states";
+
+const MAX_LOG_NUM = 1000;
+
+// setup the log websocket
+export default function useLogSetup() {
+  const [refresh, setRefresh] = useState({});
+
+  const enableLog = useRecoilValue(atomEnableLog);
+  const setLogData = useSetRecoilState(atomLogData);
+
+  useEffect(() => {
+    if (!enableLog) return;
+
+    getClashLogs().then(setLogData);
+
+    const handler = (event: MessageEvent<any>) => {
+      const data = JSON.parse(event.data) as ApiType.LogItem;
+      const time = dayjs().format("MM-DD HH:mm:ss");
+      setLogData((l) => {
+        if (l.length >= MAX_LOG_NUM) l.shift();
+        return [...l, { ...data, time }];
+      });
+    };
+
+    const ws = getInformation().then((info) => {
+      const { server = "", secret = "" } = info;
+      const ws = new WebSocket(`ws://${server}/logs?token=${secret}`);
+      ws.addEventListener("message", handler);
+      return ws;
+    });
+
+    const unlisten = listen("verge://refresh-clash-config", () =>
+      setRefresh({})
+    );
+
+    return () => {
+      ws.then((ws) => ws?.close());
+      unlisten.then((fn) => fn());
+    };
+  }, [refresh, enableLog]);
+}

src/components/log/log-item.tsx

@@ -1,11 +1,12 @@
 import { styled, Box } from "@mui/material";
-import { ApiType } from "../services/types";
 
 const Item = styled(Box)(({ theme }) => ({
   padding: "8px 0",
   margin: "0 12px",
   lineHeight: 1.35,
   borderBottom: `1px solid ${theme.palette.divider}`,
+  fontSize: "0.875rem",
+  userSelect: "text",
   "& .time": {},
   "& .type": {
     display: "inline-block",

src/components/profile-item.tsx

@@ -1,262 +0,0 @@
-import React, { useRef, useState } from "react";
-import dayjs from "dayjs";
-import {
-  alpha,
-  Box,
-  styled,
-  Typography,
-  LinearProgress,
-  IconButton,
-  keyframes,
-  MenuItem,
-  Menu,
-} from "@mui/material";
-import { useSWRConfig } from "swr";
-import { RefreshRounded } from "@mui/icons-material";
-import { CmdType } from "../services/types";
-import { updateProfile, deleteProfile, viewProfile } from "../services/cmds";
-import Notice from "./notice";
-import parseTraffic from "../utils/parse-traffic";
-import relativeTime from "dayjs/plugin/relativeTime";
-
-dayjs.extend(relativeTime);
-
-const Wrapper = styled(Box)(({ theme }) => ({
-  width: "100%",
-  display: "block",
-  cursor: "pointer",
-  textAlign: "left",
-  borderRadius: theme.shape.borderRadius,
-  boxShadow: theme.shadows[2],
-  padding: "8px 16px",
-  boxSizing: "border-box",
-}));
-
-const round = keyframes`
-  from { transform: rotate(0deg); }
-  to { transform: rotate(360deg); }
-`;
-
-interface Props {
-  index: number;
-  selected: boolean;
-  itemData: CmdType.ProfileItem;
-  onSelect: (force: boolean) => void;
-}
-
-const ProfileItem: React.FC<Props> = (props) => {
-  const { index, selected, itemData, onSelect } = props;
-
-  const { mutate } = useSWRConfig();
-  const [loading, setLoading] = useState(false);
-  const [anchorEl, setAnchorEl] = useState<any>(null);
-  const [position, setPosition] = useState({ left: 0, top: 0 });
-
-  const { name = "Profile", extra, updated = 0 } = itemData;
-  const { upload = 0, download = 0, total = 0 } = extra ?? {};
-  const from = parseUrl(itemData.url);
-  const expire = parseExpire(extra?.expire);
-  const progress = Math.round(((download + upload) * 100) / (total + 0.1));
-  const fromnow = updated > 0 ? dayjs(updated * 1000).fromNow() : "";
-
-  // url or file mode
-  const isUrlMode = itemData.url && extra;
-
-  const onView = async () => {
-    setAnchorEl(null);
-    try {
-      await viewProfile(index);
-    } catch (err: any) {
-      Notice.error(err.toString());
-    }
-  };
-
-  const onForceSelect = () => {
-    setAnchorEl(null);
-    onSelect(true);
-  };
-
-  const onUpdateWrapper = (withProxy: boolean) => async () => {
-    setAnchorEl(null);
-    if (loading) return;
-    setLoading(true);
-    try {
-      await updateProfile(index, withProxy);
-      mutate("getProfiles");
-    } catch (err: any) {
-      Notice.error(err.toString());
-    } finally {
-      setLoading(false);
-    }
-  };
-
-  const deleteRef = useRef(false);
-  const onDelete = async () => {
-    setAnchorEl(null);
-    if (deleteRef.current) return;
-    deleteRef.current = true;
-    try {
-      await deleteProfile(index);
-      mutate("getProfiles");
-    } catch (err: any) {
-      Notice.error(err.toString());
-    } finally {
-      deleteRef.current = false;
-    }
-  };
-
-  const handleContextMenu = (
-    event: React.MouseEvent<HTMLDivElement, MouseEvent>
-  ) => {
-    const { clientX, clientY } = event;
-    setPosition({ top: clientY, left: clientX });
-    setAnchorEl(event.currentTarget);
-    event.preventDefault();
-  };
-
-  const boxStyle = {
-    height: 26,
-    display: "flex",
-    alignItems: "center",
-    justifyContent: "space-between",
-  };
-
-  return (
-    <>
-      <Wrapper
-        sx={({ palette }) => {
-          const { mode, primary, text, grey } = palette;
-          const key = `${mode}-${selected}`;
-
-          const bgcolor = {
-            "light-true": alpha(primary.main, 0.15),
-            "light-false": palette.background.paper,
-            "dark-true": alpha(primary.main, 0.35),
-            "dark-false": alpha(grey[700], 0.35),
-          }[key]!;
-
-          const color = {
-            "light-true": text.secondary,
-            "light-false": text.secondary,
-            "dark-true": alpha(text.secondary, 0.6),
-            "dark-false": alpha(text.secondary, 0.6),
-          }[key]!;
-
-          const h2color = {
-            "light-true": primary.main,
-            "light-false": text.primary,
-            "dark-true": primary.light,
-            "dark-false": text.primary,
-          }[key]!;
-
-          return { bgcolor, color, "& h2": { color: h2color } };
-        }}
-        onClick={() => onSelect(false)}
-        onContextMenu={handleContextMenu}
-      >
-        <Box display="flex" justifyContent="space-between">
-          <Typography
-            width="calc(100% - 40px)"
-            variant="h6"
-            component="h2"
-            noWrap
-            title={name}
-          >
-            {name}
-          </Typography>
-
-          {isUrlMode && (
-            <IconButton
-              sx={{
-                width: 26,
-                height: 26,
-                animation: loading ? `1s linear infinite ${round}` : "none",
-              }}
-              color="inherit"
-              disabled={loading}
-              onClick={(e) => {
-                e.stopPropagation();
-                onUpdateWrapper(false)();
-              }}
-            >
-              <RefreshRounded />
-            </IconButton>
-          )}
-        </Box>
-
-        {isUrlMode ? (
-          <>
-            <Box sx={boxStyle}>
-              <Typography noWrap title={`From: ${from}`}>
-                {from}
-              </Typography>
-
-              <Typography
-                noWrap
-                flex="1 0 auto"
-                fontSize={14}
-                textAlign="right"
-                title="updated time"
-              >
-                {fromnow}
-              </Typography>
-            </Box>
-
-            <Box sx={{ ...boxStyle, fontSize: 14 }}>
-              <span title="used / total">
-                {parseTraffic(upload + download)} / {parseTraffic(total)}
-              </span>
-              <span title="expire time">{expire}</span>
-            </Box>
-          </>
-        ) : (
-          <>
-            <Box sx={boxStyle}>
-              <Typography noWrap title={itemData.desc}>
-                {itemData.desc}
-              </Typography>
-            </Box>
-
-            <Box sx={{ ...boxStyle, fontSize: 14, justifyContent: "flex-end" }}>
-              <span title="updated time">{parseExpire(updated)}</span>
-            </Box>
-          </>
-        )}
-
-        <LinearProgress
-          variant="determinate"
-          value={progress}
-          color="inherit"
-        />
-      </Wrapper>
-
-      <Menu
-        open={!!anchorEl}
-        anchorEl={anchorEl}
-        onClose={() => setAnchorEl(null)}
-        anchorPosition={position}
-        anchorReference="anchorPosition"
-      >
-        <MenuItem onClick={onForceSelect}>Select</MenuItem>
-        <MenuItem onClick={onView}>View</MenuItem>
-        <MenuItem onClick={onUpdateWrapper(false)}>Update</MenuItem>
-        <MenuItem onClick={onUpdateWrapper(true)}>Update(Proxy)</MenuItem>
-        <MenuItem onClick={onDelete}>Delete</MenuItem>
-      </Menu>
-    </>
-  );
-};
-
-function parseUrl(url?: string) {
-  if (!url) return "";
-  const regex = /https?:\/\/(.+?)\//;
-  const result = url.match(regex);
-  return result ? result[1] : "local file";
-}
-
-function parseExpire(expire?: number) {
-  if (!expire) return "-";
-  return dayjs(expire * 1000).format("YYYY-MM-DD");
-}
-
-export default ProfileItem;

src/components/profile/enhanced.tsx

@@ -0,0 +1,129 @@
+import useSWR from "swr";
+import { useLockFn } from "ahooks";
+import { useTranslation } from "react-i18next";
+import { Box, Grid, IconButton, Stack } from "@mui/material";
+import { RestartAltRounded } from "@mui/icons-material";
+import {
+  getProfiles,
+  deleteProfile,
+  enhanceProfiles,
+  changeProfileChain,
+  getRuntimeLogs,
+} from "@/services/cmds";
+import ProfileMore from "./profile-more";
+import Notice from "../base/base-notice";
+
+interface Props {
+  items: CmdType.ProfileItem[];
+  chain: string[];
+}
+
+const EnhancedMode = (props: Props) => {
+  const { items, chain } = props;
+
+  const { t } = useTranslation();
+  const { mutate: mutateProfiles } = useSWR("getProfiles", getProfiles);
+  const { data: chainLogs = {}, mutate: mutateLogs } = useSWR(
+    "getRuntimeLogs",
+    getRuntimeLogs
+  );
+
+  // handler
+  const onEnhance = useLockFn(async () => {
+    try {
+      await enhanceProfiles();
+      mutateLogs();
+      // Notice.success("Refresh clash config", 1000);
+    } catch (err: any) {
+      Notice.error(err.message || err.toString());
+    }
+  });
+
+  const onEnhanceEnable = useLockFn(async (uid: string) => {
+    if (chain.includes(uid)) return;
+
+    const newChain = [...chain, uid];
+    await changeProfileChain(newChain);
+    mutateProfiles((conf = {}) => ({ ...conf, chain: newChain }), true);
+    mutateLogs();
+  });
+
+  const onEnhanceDisable = useLockFn(async (uid: string) => {
+    if (!chain.includes(uid)) return;
+
+    const newChain = chain.filter((i) => i !== uid);
+    await changeProfileChain(newChain);
+    mutateProfiles((conf = {}) => ({ ...conf, chain: newChain }), true);
+    mutateLogs();
+  });
+
+  const onEnhanceDelete = useLockFn(async (uid: string) => {
+    try {
+      await onEnhanceDisable(uid);
+      await deleteProfile(uid);
+      mutateProfiles();
+      mutateLogs();
+    } catch (err: any) {
+      Notice.error(err?.message || err.toString());
+    }
+  });
+
+  const onMoveTop = useLockFn(async (uid: string) => {
+    if (!chain.includes(uid)) return;
+
+    const newChain = [uid].concat(chain.filter((i) => i !== uid));
+    await changeProfileChain(newChain);
+    mutateProfiles((conf = {}) => ({ ...conf, chain: newChain }), true);
+    mutateLogs();
+  });
+
+  const onMoveEnd = useLockFn(async (uid: string) => {
+    if (!chain.includes(uid)) return;
+
+    const newChain = chain.filter((i) => i !== uid).concat([uid]);
+    await changeProfileChain(newChain);
+    mutateProfiles((conf = {}) => ({ ...conf, chain: newChain }), true);
+    mutateLogs();
+  });
+
+  return (
+    <Box sx={{ mt: 2 }}>
+      <Stack
+        spacing={1}
+        direction="row"
+        alignItems="center"
+        justifyContent="flex-end"
+        sx={{ mb: 0.5 }}
+      >
+        <IconButton
+          size="small"
+          color="inherit"
+          title={t("Refresh profiles")}
+          onClick={onEnhance}
+        >
+          <RestartAltRounded />
+        </IconButton>
+      </Stack>
+
+      <Grid container spacing={2}>
+        {items.map((item) => (
+          <Grid item xs={12} sm={6} key={item.file}>
+            <ProfileMore
+              selected={!!chain.includes(item.uid)}
+              itemData={item}
+              enableNum={chain.length}
+              logInfo={chainLogs[item.uid]}
+              onEnable={() => onEnhanceEnable(item.uid)}
+              onDisable={() => onEnhanceDisable(item.uid)}
+              onDelete={() => onEnhanceDelete(item.uid)}
+              onMoveTop={() => onMoveTop(item.uid)}
+              onMoveEnd={() => onMoveEnd(item.uid)}
+            />
+          </Grid>
+        ))}
+      </Grid>
+    </Box>
+  );
+};
+
+export default EnhancedMode;

src/components/profile/file-editor.tsx

@@ -0,0 +1,96 @@
+import { useEffect, useRef } from "react";
+import { useLockFn } from "ahooks";
+import { useRecoilValue } from "recoil";
+import { useTranslation } from "react-i18next";
+import {
+  Button,
+  Dialog,
+  DialogActions,
+  DialogContent,
+  DialogTitle,
+} from "@mui/material";
+import { atomThemeMode } from "@/services/states";
+import { readProfileFile, saveProfileFile } from "@/services/cmds";
+import Notice from "../base/base-notice";
+
+import "monaco-editor/esm/vs/basic-languages/javascript/javascript.contribution.js";
+import "monaco-editor/esm/vs/basic-languages/yaml/yaml.contribution.js";
+import "monaco-editor/esm/vs/editor/contrib/folding/browser/folding.js";
+import { editor } from "monaco-editor/esm/vs/editor/editor.api";
+
+interface Props {
+  uid: string;
+  open: boolean;
+  mode: "yaml" | "javascript";
+  onClose: () => void;
+  onChange?: () => void;
+}
+
+const FileEditor = (props: Props) => {
+  const { uid, open, mode, onClose, onChange } = props;
+
+  const { t } = useTranslation();
+  const editorRef = useRef<any>();
+  const instanceRef = useRef<editor.IStandaloneCodeEditor | null>(null);
+  const themeMode = useRecoilValue(atomThemeMode);
+
+  useEffect(() => {
+    if (!open) return;
+
+    readProfileFile(uid).then((data) => {
+      const dom = editorRef.current;
+
+      if (!dom) return;
+      if (instanceRef.current) instanceRef.current.dispose();
+
+      instanceRef.current = editor.create(editorRef.current, {
+        value: data,
+        language: mode,
+        theme: themeMode === "light" ? "vs" : "vs-dark",
+        minimap: { enabled: false },
+      });
+    });
+
+    return () => {
+      if (instanceRef.current) {
+        instanceRef.current.dispose();
+        instanceRef.current = null;
+      }
+    };
+  }, [open]);
+
+  const onSave = useLockFn(async () => {
+    const value = instanceRef.current?.getValue();
+
+    if (value == null) return;
+
+    try {
+      await saveProfileFile(uid, value);
+      onChange?.();
+      onClose();
+    } catch (err: any) {
+      Notice.error(err.message || err.toString());
+    }
+  });
+
+  return (
+    <Dialog open={open} onClose={onClose}>
+      <DialogTitle>{t("Edit File")}</DialogTitle>
+
+      <DialogContent sx={{ width: 520, pb: 1 }}>
+        <div style={{ width: "100%", height: "420px" }} ref={editorRef} />
+      </DialogContent>
+
+      <DialogActions>
+        <Button onClick={onClose} variant="outlined">
+          {t("Cancel")}
+        </Button>
+        <Button onClick={onSave} variant="contained">
+          {t("Save")}
+        </Button>
+      </DialogActions>
+    </Dialog>
+  );
+};
+
+export default FileEditor;

src/components/profile/file-input.tsx

@@ -0,0 +1,63 @@
+import { useRef, useState } from "react";
+import { useLockFn } from "ahooks";
+import { useTranslation } from "react-i18next";
+import { Box, Button, Typography } from "@mui/material";
+
+interface Props {
+  onChange: (value: string) => void;
+}
+
+const FileInput = (props: Props) => {
+  const { onChange } = props;
+
+  const { t } = useTranslation();
+  // file input
+  const inputRef = useRef<any>();
+  const [loading, setLoading] = useState(false);
+  const [fileName, setFileName] = useState("");
+
+  const onFileInput = useLockFn(async (e: any) => {
+    const file = e.target.files?.[0] as File;
+
+    if (!file) return;
+
+    setFileName(file.name);
+    setLoading(true);
+
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = (event) => {
+        resolve(null);
+        onChange(event.target?.result as string);
+      };
+      reader.onerror = reject;
+      reader.readAsText(file);
+    }).finally(() => setLoading(false));
+  });
+
+  return (
+    <Box sx={{ mt: 2, mb: 1, display: "flex", alignItems: "center" }}>
+      <Button
+        variant="outlined"
+        sx={{ flex: "none" }}
+        onClick={() => inputRef.current?.click()}
+      >
+        {t("Choose File")}
+      </Button>
+
+      <input
+        type="file"
+        accept=".yaml,.yml"
+        ref={inputRef}
+        style={{ display: "none" }}
+        onChange={onFileInput}
+      />
+
+      <Typography noWrap sx={{ ml: 1 }}>
+        {loading ? "Loading..." : fileName}
+      </Typography>
+    </Box>
+  );
+};
+
+export default FileInput;

src/components/profile/info-editor.tsx

@@ -0,0 +1,165 @@
+import { mutate } from "swr";
+import { useEffect, useState } from "react";
+import { useLockFn, useSetState } from "ahooks";
+import { useTranslation } from "react-i18next";
+import {
+  Button,
+  Dialog,
+  DialogActions,
+  DialogContent,
+  DialogTitle,
+  IconButton,
+  TextField,
+} from "@mui/material";
+import { Settings } from "@mui/icons-material";
+import { patchProfile } from "@/services/cmds";
+import Notice from "../base/base-notice";
+
+interface Props {
+  open: boolean;
+  itemData: CmdType.ProfileItem;
+  onClose: () => void;
+}
+
+// edit the profile item
+// remote / local file / merge / script
+const InfoEditor = (props: Props) => {
+  const { open, itemData, onClose } = props;
+
+  const { t } = useTranslation();
+  const [form, setForm] = useSetState({ ...itemData });
+  const [option, setOption] = useSetState(itemData.option ?? {});
+  const [showOpt, setShowOpt] = useState(!!itemData.option);
+
+  useEffect(() => {
+    if (itemData) {
+      setForm({ ...itemData });
+      setOption(itemData.option ?? {});
+      setShowOpt(
+        itemData.type === "remote" &&
+          (!!itemData.option?.user_agent || !!itemData.option?.update_interval)
+      );
+    }
+  }, [itemData]);
+
+  const onUpdate = useLockFn(async () => {
+    try {
+      const { uid } = itemData;
+      const { name, desc, url } = form;
+      const option_ =
+        itemData.type === "remote" || itemData.type === "local"
+          ? option
+          : undefined;
+
+      if (itemData.type === "remote" && !url) {
+        throw new Error("Remote URL should not be null");
+      }
+
+      await patchProfile(uid, { uid, name, desc, url, option: option_ });
+      mutate("getProfiles");
+      onClose();
+    } catch (err: any) {
+      Notice.error(err?.message || err.toString());
+    }
+  });
+
+  const textFieldProps = {
+    fullWidth: true,
+    size: "small",
+    margin: "normal",
+    variant: "outlined",
+  } as const;
+
+  const type =
+    form.type ||
+    (form.url ? "remote" : form.file?.endsWith(".js") ? "script" : "local");
+
+  return (
+    <Dialog open={open} onClose={onClose}>
+      <DialogTitle sx={{ pb: 0.5 }}>{t("Edit Info")}</DialogTitle>
+
+      <DialogContent sx={{ width: 336, pb: 1 }}>
+        <TextField
+          {...textFieldProps}
+          disabled
+          label={t("Type")}
+          value={type}
+          sx={{ input: { textTransform: "capitalize" } }}
+        />
+
+        <TextField
+          {...textFieldProps}
+          autoFocus
+          label={t("Name")}
+          value={form.name}
+          onChange={(e) => setForm({ name: e.target.value })}
+          onKeyDown={(e) => e.key === "Enter" && onUpdate()}
+        />
+
+        <TextField
+          {...textFieldProps}
+          label={t("Descriptions")}
+          value={form.desc}
+          onChange={(e) => setForm({ desc: e.target.value })}
+          onKeyDown={(e) => e.key === "Enter" && onUpdate()}
+        />
+
+        {type === "remote" && (
+          <TextField
+            {...textFieldProps}
+            label={t("Subscription URL")}
+            value={form.url}
+            onChange={(e) => setForm({ url: e.target.value })}
+            onKeyDown={(e) => e.key === "Enter" && onUpdate()}
+          />
+        )}
+
+        {showOpt && (
+          <TextField
+            {...textFieldProps}
+            label="User Agent"
+            value={option.user_agent}
+            placeholder="clash-verge/v1.0.0"
+            onChange={(e) => setOption({ user_agent: e.target.value })}
+            onKeyDown={(e) => e.key === "Enter" && onUpdate()}
+          />
+        )}
+
+        {((type === "remote" && showOpt) || type === "local") && (
+          <TextField
+            {...textFieldProps}
+            label={t("Update Interval(mins)")}
+            value={option.update_interval}
+            onChange={(e) => {
+              const str = e.target.value?.replace(/\D/, "");
+              setOption({ update_interval: !!str ? +str : undefined });
+            }}
+            onKeyDown={(e) => e.key === "Enter" && onUpdate()}
+          />
+        )}
+      </DialogContent>
+
+      <DialogActions sx={{ px: 2, pb: 2, position: "relative" }}>
+        {form.type === "remote" && (
+          <IconButton
+            size="small"
+            color="inherit"
+            sx={{ position: "absolute", left: 18 }}
+            onClick={() => setShowOpt((o) => !o)}
+          >
+            <Settings />
+          </IconButton>
+        )}
+
+        <Button onClick={onClose} variant="outlined">
+          {t("Cancel")}
+        </Button>
+        <Button onClick={onUpdate} variant="contained">
+          {t("Save")}
+        </Button>
+      </DialogActions>
+    </Dialog>
+  );
+};
+
+export default InfoEditor;