chore: fix check

https://github.com/actions/checkout/releases/tag/v4.0.0
https://github.com/actions/setup-node/releases/tag/v4.0.0

.editorconfig

@@ -5,3 +5,9 @@ charset = utf-8
 end_of_line = lf
 indent_size = 2
 insert_final_newline = true
+
+[*.rs]
+charset = utf-8
+end_of_line = lf
+indent_size = 4
+insert_final_newline = true

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,32 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: "[BUG]"
+labels: bug
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Information**
+ - OS: [e.g. macOS]
+ - Clash Verge Version: [e.g. 1.3.4]
+ - Clash Core: [e.g. Clash or Clash Meta]
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: "[Feature]"
+labels: enhancement
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/workflows/alpha.yml

@@ -1,8 +1,11 @@
 name: Alpha CI
 
 on:
-  push:
-    branches: [alpha]
+  workflow_dispatch:
+    inputs:
+      debug:
+        type: boolean
+        default: false
 
 env:
   CARGO_INCREMENTAL: 0
@@ -11,74 +14,80 @@ env:
 jobs:
   release:
     strategy:
+      fail-fast: false
       matrix:
-        os: [windows-latest, ubuntu-latest, macos-latest]
+        os: [windows-latest, ubuntu-20.04, macos-latest]
     runs-on: ${{ matrix.os }}
     if: startsWith(github.repository, 'zzzgydi')
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
-      - name: Install Rust
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          profile: minimal
-          override: true
+      - name: install Rust stable
+        uses: dtolnay/rust-toolchain@stable
 
       - name: Rust Cache
-        uses: Swatinem/rust-cache@ce325b60658c1b38465c06cc965b79baf32c1e72
+        uses: Swatinem/rust-cache@v2
         with:
-          working-directory: src-tauri
+          workspaces: src-tauri
 
       - name: Install Node
-        uses: actions/setup-node@v1
+        uses: actions/setup-node@v4
         with:
-          node-version: 14
+          node-version: "16"
+          cache: "yarn"
+
+      - name: Delete current release assets
+        if: startsWith(matrix.os, 'ubuntu-')
+        uses: mknejp/delete-release-assets@v1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          tag: alpha
+          fail-if-no-assets: false
+          fail-if-no-release: false
+          assets: |
+            *.zip
+            *.gz
+            *.AppImage
+            *.deb
+            *.dmg
+            *.msi
+            *.sig
+            *.exe
 
       - name: Install Dependencies (ubuntu only)
-        if: matrix.os == 'ubuntu-latest'
+        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)"
-
-      - 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-
+          sudo apt-get install -y libgtk-3-dev webkit2gtk-4.0 libappindicator3-dev librsvg2-dev patchelf openssl
 
       - name: Yarn install and check
         run: |
-          yarn install --network-timeout 1000000
-          yarn run check
+          yarn install --network-timeout 1000000 --frozen-lockfile
+          yarn run check --force
 
       - name: Tauri build
-        uses: tauri-apps/tauri-action@743a37fd53cbdd122910b818b9bef7b7aa019134
-        # enable cache even though failed
-        continue-on-error: true
+        uses: tauri-apps/tauri-action@v0
         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
+          releaseBody: "Alpha Version (include debug)"
+          releaseDraft: false
           prerelease: true
+          includeDebug: ${{ github.event.inputs.debug }}
 
-      # - name: Portable Bundle
-      #   if: matrix.os == 'windows-latest'
-      #   run: |
-      #     yarn run portable
-      #   env:
-      #     GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - name: Portable Bundle
+        if: startsWith(matrix.os, 'windows-')
+        run: |
+          yarn build
+          yarn run portable
+        env:
+          TAG_NAME: alpha
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+          VITE_WIN_PORTABLE: 1

.github/workflows/ci.yml

@@ -1,6 +1,7 @@
 name: Release CI
 
 on:
+  workflow_dispatch:
   push:
     tags:
       - v**
@@ -15,56 +16,38 @@ jobs:
       matrix:
         os: [windows-latest, ubuntu-latest, macos-latest]
     runs-on: ${{ matrix.os }}
-    if: |
-      startsWith(github.repository, 'zzzgydi') &&
-      startsWith(github.ref, 'refs/tags/v')
+    if: startsWith(github.repository, 'zzzgydi')
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
-      - name: Install Rust
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          profile: minimal
-          override: true
+      - name: install Rust stable
+        uses: dtolnay/rust-toolchain@stable
 
       - name: Rust Cache
-        uses: Swatinem/rust-cache@ce325b60658c1b38465c06cc965b79baf32c1e72
+        uses: Swatinem/rust-cache@v2
         with:
-          working-directory: src-tauri
+          workspaces: src-tauri
 
       - name: Install Node
-        uses: actions/setup-node@v1
+        uses: actions/setup-node@v4
         with:
-          node-version: 14
+          node-version: "16"
+          cache: "yarn"
 
       - 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)"
-
-      - 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-
+          sudo apt-get install -y libgtk-3-dev webkit2gtk-4.0 libappindicator3-dev librsvg2-dev patchelf openssl
 
       - name: Yarn install and check
         run: |
-          yarn install --network-timeout 1000000
+          yarn install --network-timeout 1000000 --frozen-lockfile
           yarn run check
 
       - name: Tauri build
-        uses: tauri-apps/tauri-action@0e558392ccadcb49bcc89e7df15a400e8f0c954d
+        uses: tauri-apps/tauri-action@v0
         # enable cache even though failed
         # continue-on-error: true
         env:
@@ -79,7 +62,7 @@ jobs:
           prerelease: true
 
       - name: Portable Bundle
-        if: matrix.os == 'windows-latest'
+        if: startsWith(matrix.os, 'windows-')
         # rebuild with env settings
         run: |
           yarn build
@@ -92,29 +75,22 @@ jobs:
 
   release-update:
     needs: release
-    runs-on: macos-latest
+    runs-on: ubuntu-latest
     if: |
       startsWith(github.repository, 'zzzgydi') &&
       startsWith(github.ref, 'refs/tags/v')
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
-      - 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
+      - name: Install Node
+        uses: actions/setup-node@v4
         with:
-          path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
-          key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-yarn-
+          node-version: "16"
+          cache: "yarn"
 
       - name: Yarn install
-        run: yarn install
+        run: yarn install --network-timeout 1000000 --frozen-lockfile
 
       - name: Release updater file
         run: yarn run updater

.github/workflows/compatible.yml

@@ -2,9 +2,9 @@ name: Compatible CI
 
 on:
   workflow_dispatch:
-  push:
-    tags:
-      - v**
+  # push:
+  #   tags:
+  #     - v**
 
 env:
   CARGO_INCREMENTAL: 0
@@ -37,14 +37,14 @@ jobs:
           override: true
 
       - name: Rust Cache
-        uses: Swatinem/rust-cache@ce325b60658c1b38465c06cc965b79baf32c1e72
+        uses: Swatinem/rust-cache@v2
         with:
-          working-directory: src-tauri
+          workspaces: src-tauri
 
       - name: Install Node
         uses: actions/setup-node@v1
         with:
-          node-version: 14
+          node-version: 16
 
       # - name: Install Dependencies (ubuntu18 only)
       #   if: matrix.targets.os == 'ubuntu-18.04'

.github/workflows/meta.yml

@@ -0,0 +1,107 @@
+name: Meta CI
+
+on:
+  workflow_dispatch:
+  push:
+    tags:
+      - v**
+
+env:
+  CARGO_INCREMENTAL: 0
+  RUST_BACKTRACE: short
+
+jobs:
+  release:
+    strategy:
+      fail-fast: false
+      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@v2
+        with:
+          workspaces: src-tauri
+
+      - name: Install Node
+        uses: actions/setup-node@v1
+        with:
+          node-version: 16
+
+      - name: Delete current release assets
+        if: matrix.os == 'ubuntu-latest'
+        uses: mknejp/delete-release-assets@v1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          tag: meta
+          fail-if-no-assets: false
+          fail-if-no-release: false
+          assets: |
+            *.zip
+            *.gz
+            *.AppImage
+            *.deb
+            *.dmg
+            *.msi
+            *.sig
+
+      - name: Install Dependencies (ubuntu only)
+        if: startsWith(matrix.os, 'ubuntu-')
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libgtk-3-dev webkit2gtk-4.0 libappindicator3-dev librsvg2-dev patchelf openssl
+
+      - 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@v0
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+        with:
+          tagName: meta
+          releaseName: "Clash Verge Meta"
+          releaseBody: ""
+          releaseDraft: false
+          prerelease: true
+          args: -f default-meta
+
+      - name: Portable Bundle
+        if: matrix.os == 'windows-latest'
+        run: |
+          yarn build -f default-meta
+          yarn run portable
+        env:
+          TAG_NAME: meta
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+          VITE_WIN_PORTABLE: 1

.github/workflows/test.yml

@@ -35,52 +35,42 @@ jobs:
           echo ${{ github.event.inputs.os }}
 
       - name: Checkout repository
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
-      - name: Install Rust
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          profile: minimal
-          override: true
+      - name: install Rust stable
+        uses: dtolnay/rust-toolchain@stable
 
       - name: Rust Cache
-        uses: Swatinem/rust-cache@v1
+        uses: Swatinem/rust-cache@v2
         with:
-          working-directory: src-tauri
+          workspaces: src-tauri
 
       - name: Install Node
-        uses: actions/setup-node@v1
+        uses: actions/setup-node@v4
         with:
-          node-version: 14
+          node-version: "16"
+          cache: "yarn"
 
       - name: Install Dependencies (ubuntu only)
         if: startsWith(github.event.inputs.os, 'ubuntu-')
         run: |
           sudo apt-get update
-          sudo apt-get install -y libgtk-3-dev webkit2gtk-4.0 libappindicator3-dev librsvg2-dev patchelf
-
-      - 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-
+          sudo apt-get install -y libgtk-3-dev libwebkit2gtk-4.0-dev libappindicator3-dev librsvg2-dev patchelf
 
       - name: Yarn install and check
         run: |
-          yarn install --network-timeout 1000000
+          yarn install --network-timeout 1000000 --frozen-lockfile
           yarn run check
 
       - name: Tauri build
-        uses: tauri-apps/tauri-action@0e558392ccadcb49bcc89e7df15a400e8f0c954d
+        uses: tauri-apps/tauri-action@v0
         env:
           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 (include debug)"
+          releaseDraft: false
+          includeUpdaterJson: false

.github/workflows/updater.yml

@@ -4,27 +4,20 @@ on: workflow_dispatch
 
 jobs:
   release-update:
-    runs-on: macos-latest
+    runs-on: ubuntu-latest
     if: startsWith(github.repository, 'zzzgydi')
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
-      - 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
+      - name: Install Node
+        uses: actions/setup-node@v4
         with:
-          path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
-          key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-yarn-
+          node-version: "16"
+          cache: "yarn"
 
       - name: Yarn install
-        run: yarn install
+        run: yarn install --network-timeout 1000000 --frozen-lockfile
 
       - name: Release updater file
         run: yarn run updater

README.md

@@ -17,17 +17,69 @@ A <a href="https://github.com/Dreamacro/clash">Clash</a> GUI based on <a href="h
 - Built-in support [Clash.Meta](https://github.com/MetaCubeX/Clash.Meta) core.
 - System proxy setting and guard.
 
+## Promotion
+
+[狗狗加速 —— 技术流机场 Doggygo VPN](https://dg1.top)
+
+- High-performance overseas VPN, free trial, discounted packages, unlock streaming media, the world's first to support Hysteria protocol.
+- 高性能海外机场，免费试用，优惠套餐，解锁流媒体，全球首家支持 Hysteria 协议。
+- 使用 Clash Verge 专属邀请链接注册送 15 天，每天 1G 流量免费试用：https://panel.dg1.top/#/register?code=sFCDayZf
+
+<details>
+<summary>Promotion Detail</summary>
+
+- Clash Verge 专属 8 折优惠码: verge20 (仅有 500 份)
+- 优惠套餐每月仅需 15.8 元，160G 流量，年付 8 折
+- 海外团队，无跑路风险，高达 50% 返佣
+- 集群负载均衡设计，高速专线(兼容老客户端)，极低延迟，无视晚高峰，4K 秒开
+- 全球首家 Hysteria 协议机场，将在今年 10 月上线更快的 `tuic` 协议(Clash Verge 客户端最佳搭配)
+- 解锁流媒体及 ChatGPT
+- 官网：https://dg1.top
+
+</details>
+
+<br />
+
+[EEVPN —— 海外运营机场 ※ 支持 ChatGPT](https://www.eejsq.net/#/register?code=yRr6qBO3)
+
+- 年付低至 9.99 元，价格低，速度不减
+
+<details>
+<summary>Promotion Detail</summary>
+
+- 中国大陆 BGP 网络接入
+- IEPL 专线网络
+- 最高 2500Mbps 速率可用
+- 不限制在线客户端
+- 解锁流媒体及 ChatGPT
+- 海外运营 数据安全
+
+</details>
+
 ## Install
 
 Download from [release](https://github.com/zzzgydi/clash-verge/releases). Supports Windows x64, Linux x86_64 and macOS 11+
 
+- [Windows x64](https://github.com/zzzgydi/clash-verge/releases/download/v1.3.8/Clash.Verge_1.3.8_x64_en-US.msi)
+- [macOS intel](https://github.com/zzzgydi/clash-verge/releases/download/v1.3.8/Clash.Verge_1.3.8_x64.dmg)
+- [macOS arm](https://github.com/zzzgydi/clash-verge/releases/download/v1.3.8/Clash.Verge_1.3.8_aarch64.dmg)
+- [Linux AppImage](https://github.com/zzzgydi/clash-verge/releases/download/v1.3.8/clash-verge_1.3.8_amd64.AppImage)
+- [Linux deb](https://github.com/zzzgydi/clash-verge/releases/download/v1.3.8/clash-verge_1.3.8_amd64.deb)
+- [Fedora Linux](https://github.com/zzzgydi/clash-verge/issues/352)
+
 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.
 
+### FAQ
+
+#### 1. **macOS** "Clash Verge" is damaged and can't be opened
+
+open the terminal and run `sudo xattr -r -d com.apple.quarantine /Applications/Clash\ Verge.app`
+
 ## Development
 
-You should install Rust and Nodejs, see [here](https://tauri.studio/docs/getting-started/prerequisites) for more details. Then install Nodejs packages.
+You should install Rust and Nodejs, see [here](https://tauri.app/v1/guides/getting-started/prerequisites) for more details. Then install Nodejs packages.
 
 ```shell
 yarn install
@@ -36,6 +88,9 @@ 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/docs/api/config/#tauri.bundle.externalBin).
 
 ```shell
+# force update to latest version
+# yarn run check --force
+
 yarn run check
 ```
 
@@ -43,6 +98,9 @@ Then run
 
 ```shell
 yarn dev
+
+# run it in another way if app instance exists
+yarn dev:diff
 ```
 
 Or you can build it

UPDATELOG.md

@@ -1,3 +1,221 @@
+## v1.3.8
+
+### Features
+
+- update clash meta core
+- add default valid keys
+- adjust the delay display interval and color
+
+### Bug Fixes
+
+- fix connections page undefined exception
+
+---
+
+## v1.3.7
+
+### Features
+
+- update clash and clash meta core
+- profiles page add paste button
+- subscriptions url textfield use multi lines
+- set min window size
+- add check for updates buttons
+- add open dashboard to the hotkey list
+
+### Bug Fixes
+
+- fix profiles page undefined exception
+
+---
+
+## v1.3.6
+
+### Features
+
+- add russian translation
+- support to show connection detail
+- support clash meta memory usage display
+- support proxy provider update ui
+- update geo data file from meta repo
+- adjust setting page
+
+### Bug Fixes
+
+- center the window when it is out of screen
+- use `sudo` when `pkexec` not found (Linux)
+- reconnect websocket when window focus
+
+### Notes
+
+- The current version of the Linux installation package is built by Ubuntu 20.04 (Github Action).
+
+---
+
+## v1.3.5
+
+### Features
+
+- update clash core
+
+### Bug Fixes
+
+- fix blurry system tray icon (Windows)
+- fix v1.3.4 wintun.dll not found (Windows)
+- fix v1.3.4 clash core not found (macOS, Linux)
+
+---
+
+## v1.3.4
+
+### Features
+
+- update clash and clash meta core
+- optimize traffic graph high CPU usage when window hidden
+- use polkit to elevate permission (Linux)
+- support app log level setting
+- support copy environment variable
+- overwrite resource file according to file modified
+- save window size and position
+
+### Bug Fixes
+
+- remove fallback group select status
+- enable context menu on editable element (Windows)
+
+---
+
+## v1.3.3
+
+### Features
+
+- update clash and clash meta core
+- show tray icon variants in different system proxy status (Windows)
+- close all connections when mode changed
+
+### Bug Fixes
+
+- encode controller secret into uri
+- error boundary for each page
+
+---
+
+## v1.3.2
+
+### Features
+
+- update clash and clash meta core
+
+### Bug Fixes
+
+- fix import url issue
+- fix profile undefined issue
+
+---
+
+## v1.3.1
+
+### Features
+
+- update clash and clash meta core
+
+### Bug Fixes
+
+- fix open url issue
+- fix appimage path panic
+- fix grant root permission in macOS
+- fix linux system proxy default bypass
+
+---
+
+## v1.3.0
+
+### Features
+
+- update clash and clash meta
+- support opening dir on tray
+- support updating all profiles with one click
+- support granting root permission to clash core(Linux, macOS)
+- support enable/disable clash fields filter, feel free to experience the latest features of Clash Meta
+
+### Bug Fixes
+
+- deb add openssl depend(Linux)
+- fix the AppImage auto launch path(Linux)
+- fix get the default network service(macOS)
+- remove the esc key listener in macOS, cmd+w instead(macOS)
+- fix infinite retry when websocket error
+
+---
+
+## v1.2.3
+
+### Features
+
+- update clash
+- adjust macOS window style
+- profile supports UTF8 with BOM
+
+### Bug Fixes
+
+- fix selected proxy
+- fix error log
+
+---
+
+## v1.2.2
+
+### Features
+
+- update clash meta
+- recover clash core after panic
+- use system window decorations(Linux)
+
+### Bug Fixes
+
+- flush system proxy settings(Windows)
+- fix parse log panic
+- fix ui bug
+
+---
+
+## v1.2.1
+
+### Features
+
+- update clash version
+- proxy groups support multi columns
+- optimize ui
+
+### Bug Fixes
+
+- fix ui websocket connection
+- adjust delay check concurrency
+- avoid setting login item repeatedly(macOS)
+
+---
+
+## v1.2.0
+
+### Features
+
+- update clash meta version
+- support to change external-controller
+- support to change default latency test URL
+- close all connections when proxy changed or profile changed
+- check the config by using the core
+- increase the robustness of the program
+- optimize windows service mode (need to reinstall)
+- optimize ui
+
+### Bug Fixes
+
+- invalid hotkey cause panic
+- invalid theme setting cause panic
+- fix some other glitches
+
+---
+
 ## v1.1.2
 
 ### Features

package.json

@@ -1,6 +1,6 @@
 {
   "name": "clash-verge",
-  "version": "1.1.2",
+  "version": "1.3.8",
   "license": "GPL-3.0",
   "scripts": {
     "dev": "tauri dev",
@@ -18,34 +18,38 @@
     "prepare": "husky install"
   },
   "dependencies": {
-    "@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": "^3.1.0",
-    "recoil": "^0.7.5",
+    "@emotion/react": "^11.10.5",
+    "@emotion/styled": "^11.10.5",
+    "@juggle/resize-observer": "^3.4.0",
+    "@mui/icons-material": "^5.10.9",
+    "@mui/material": "^5.10.13",
+    "@mui/x-data-grid": "^5.17.11",
+    "@tauri-apps/api": "^1.3.0",
+    "ahooks": "^3.7.2",
+    "axios": "^1.1.3",
+    "dayjs": "1.11.5",
+    "i18next": "^22.0.4",
+    "lodash-es": "^4.17.21",
+    "monaco-editor": "^0.34.1",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "react-error-boundary": "^3.1.4",
+    "react-hook-form": "^7.39.5",
+    "react-i18next": "^12.0.0",
+    "react-router-dom": "^6.4.3",
+    "react-virtuoso": "^3.1.3",
+    "recoil": "^0.7.6",
     "snarkdown": "^2.0.0",
     "swr": "^1.3.0"
   },
   "devDependencies": {
     "@actions/github": "^5.0.3",
-    "@tauri-apps/cli": "^1.1.1",
+    "@tauri-apps/cli": "^1.3.1",
     "@types/fs-extra": "^9.0.13",
     "@types/js-cookie": "^3.0.2",
     "@types/lodash": "^4.14.180",
-    "@types/react": "^17.0.0",
-    "@types/react-dom": "^17.0.0",
+    "@types/lodash-es": "^4.17.7",
+    "@types/react-dom": "^18.0.11",
     "@vitejs/plugin-react": "^2.0.1",
     "adm-zip": "^0.5.9",
     "cross-env": "^7.0.3",
@@ -57,7 +61,7 @@
     "pretty-quick": "^3.1.3",
     "sass": "^1.54.0",
     "typescript": "^4.7.4",
-    "vite": "^3.0.9",
+    "vite": "^3.2.5",
     "vite-plugin-monaco-editor": "^1.1.0",
     "vite-plugin-svgr": "^2.2.1"
   },
@@ -67,4 +71,4 @@
     "singleQuote": false,
     "endOfLine": "lf"
   }
-}
+}

scripts/aarch.mjs

@@ -1,12 +1,19 @@
 /**
- * Build and upload assets for macOS(aarch)
+ * Build and upload assets
+ * for macOS(aarch)
  */
 import fs from "fs-extra";
 import path from "path";
 import { exit } from "process";
+import { execSync } from "child_process";
 import { createRequire } from "module";
 import { getOctokit, context } from "@actions/github";
 
+// to `meta` tag
+const META = process.argv.includes("--meta");
+// to `alpha` tag
+const ALPHA = process.argv.includes("--alpha");
+
 const require = createRequire(import.meta.url);
 
 async function resolve() {
@@ -25,6 +32,14 @@ async function resolve() {
 
   const { version } = require("../package.json");
 
+  const tag = META ? "meta" : ALPHA ? "alpha" : `v${version}`;
+  const buildCmd = META ? `yarn build -f default-meta` : `yarn build`;
+
+  console.log(`[INFO]: Upload to tag "${tag}"`);
+  console.log(`[INFO]: Building app. "${buildCmd}"`);
+
+  execSync(buildCmd);
+
   const cwd = process.cwd();
   const bundlePath = path.join(cwd, "src-tauri/target/release/bundle");
   const join = (p) => path.join(bundlePath, p);
@@ -48,7 +63,7 @@ async function resolve() {
 
   const { data: release } = await github.rest.repos.getReleaseByTag({
     ...options,
-    tag: `v${version}`,
+    tag,
   });
 
   if (!release.id) throw new Error("failed to find the release");

scripts/check.mjs

@@ -8,180 +8,174 @@ import { execSync } from "child_process";
 
 const cwd = process.cwd();
 const TEMP_DIR = path.join(cwd, "node_modules/.verge");
-
 const FORCE = process.argv.includes("--force");
-const NO_META = process.argv.includes("--no-meta") || false;
+
+const SIDECAR_HOST = execSync("rustc -vV")
+  .toString()
+  .match(/(?<=host: ).+(?=\s*)/g)[0];
+
+/* ======= clash ======= */
+const CLASH_STORAGE_PREFIX = "https://release.dreamacro.workers.dev/";
+const CLASH_URL_PREFIX =
+  "https://github.com/Dreamacro/clash/releases/download/premium/";
+const CLASH_LATEST_DATE = "latest";
+
+const CLASH_MAP = {
+  "win32-x64": "clash-windows-amd64",
+  "darwin-x64": "clash-darwin-amd64",
+  "darwin-arm64": "clash-darwin-arm64",
+  "linux-x64": "clash-linux-amd64",
+  "linux-arm64": "clash-linux-arm64",
+};
+
+/* ======= clash meta ======= */
+const META_URL_PREFIX = `https://github.com/MetaCubeX/Clash.Meta/releases/download/`;
+const META_VERSION = "v1.16.0";
+
+const META_MAP = {
+  "win32-x64": "clash.meta-windows-amd64-compatible",
+  "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",
+};
 
 /**
- * get the correct clash release infomation
+ * check available
  */
-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";
+const { platform, arch } = process;
+if (!CLASH_MAP[`${platform}-${arch}`]) {
+  throw new Error(`clash unsupported platform "${platform}-${arch}"`);
+}
+if (!META_MAP[`${platform}-${arch}`]) {
+  throw new Error(`clash meta unsupported platform "${platform}-${arch}"`);
+}
 
-  // todo
-  const map = {
-    "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}`];
-
-  if (!name) {
-    throw new Error(`unsupport platform "${platform}-${arch}"`);
-  }
+function clash() {
+  const name = CLASH_MAP[`${platform}-${arch}`];
 
   const isWin = platform === "win32";
-  const zip = isWin ? "zip" : "gz";
-  const url = `${CLASH_URL_PREFIX}${name}-${CLASH_LATEST_DATE}.${zip}`;
-  const exefile = `${name}${isWin ? ".exe" : ""}`;
-  const zipfile = `${name}.${zip}`;
+  const urlExt = isWin ? "zip" : "gz";
+  const downloadURL = `${CLASH_URL_PREFIX}${name}-${CLASH_LATEST_DATE}.${urlExt}`;
+  const exeFile = `${name}${isWin ? ".exe" : ""}`;
+  const zipFile = `${name}.${urlExt}`;
 
-  return { url, zip, exefile, zipfile };
+  return {
+    name: "clash",
+    targetFile: `clash-${SIDECAR_HOST}${isWin ? ".exe" : ""}`,
+    exeFile,
+    zipFile,
+    downloadURL,
+  };
+}
+
+function clashS3() {
+  const name = CLASH_MAP[`${platform}-${arch}`];
+
+  const isWin = platform === "win32";
+  const urlExt = isWin ? "zip" : "gz";
+  const downloadURL = `${CLASH_STORAGE_PREFIX}${CLASH_LATEST_DATE}/${name}-${CLASH_LATEST_DATE}.${urlExt}`;
+  const exeFile = `${name}${isWin ? ".exe" : ""}`;
+  const zipFile = `${name}.${urlExt}`;
+
+  return {
+    name: "clash",
+    targetFile: `clash-${SIDECAR_HOST}${isWin ? ".exe" : ""}`,
+    exeFile,
+    zipFile,
+    downloadURL,
+  };
+}
+
+function clashMeta() {
+  const name = META_MAP[`${platform}-${arch}`];
+  const isWin = platform === "win32";
+  const urlExt = isWin ? "zip" : "gz";
+  const downloadURL = `${META_URL_PREFIX}${META_VERSION}/${name}-${META_VERSION}.${urlExt}`;
+  const exeFile = `${name}${isWin ? ".exe" : ""}`;
+  const zipFile = `${name}-${META_VERSION}.${urlExt}`;
+
+  return {
+    name: "clash-meta",
+    targetFile: `clash-meta-${SIDECAR_HOST}${isWin ? ".exe" : ""}`,
+    exeFile,
+    zipFile,
+    downloadURL,
+  };
 }
 
 /**
- * get the correct Clash.Meta release infomation
+ * download sidecar and rename
  */
-async function resolveClashMeta() {
-  const { platform, arch } = process;
+async function resolveSidecar(binInfo) {
+  const { name, targetFile, zipFile, exeFile, downloadURL } = binInfo;
 
-  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 sidecarPath = path.join(sidecarDir, targetFile);
 
-  const host = execSync("rustc -vV")
-    .toString()
-    .match(/(?<=host: ).+(?=\s*)/g)[0];
+  await fs.mkdirp(sidecarDir);
+  if (!FORCE && (await fs.pathExists(sidecarPath))) return;
 
-  const ext = process.platform === "win32" ? ".exe" : "";
+  const tempDir = path.join(TEMP_DIR, name);
+  const tempZip = path.join(tempDir, zipFile);
+  const tempExe = path.join(tempDir, exeFile);
 
-  await clash();
-  if (!NO_META) await clashMeta();
+  await fs.mkdirp(tempDir);
+  try {
+    if (!(await fs.pathExists(tempZip))) {
+      await downloadFile(downloadURL, tempZip);
+    }
 
-  async function clash() {
-    const sidecarFile = `clash-${host}${ext}`;
-    const sidecarPath = path.join(sidecarDir, sidecarFile);
-
-    await fs.mkdirp(sidecarDir);
-    if (!FORCE && (await fs.pathExists(sidecarPath))) return;
-
-    // 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") {
+    if (zipFile.endsWith(".zip")) {
       const zip = new AdmZip(tempZip);
       zip.getEntries().forEach((entry) => {
-        console.log("[INFO]: entry name", entry.entryName);
+        console.log(`[DEBUG]: "${name}" entry name`, entry.entryName);
       });
       zip.extractAllTo(tempDir, true);
-      // save as sidecar
       await fs.rename(tempExe, sidecarPath);
-      console.log(`[INFO]: unzip finished`);
+      console.log(`[INFO]: "${name}" 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));
+      await new Promise((resolve, reject) => {
+        const onError = (error) => {
+          console.error(`[ERROR]: "${name}" gz failed:`, error.message);
+          reject(error);
+        };
+        readStream
+          .pipe(zlib.createGunzip().on("error", onError))
+          .pipe(writeStream)
+          .on("finish", () => {
+            console.log(`[INFO]: "${name}" gunzip finished`);
+            execSync(`chmod 755 ${sidecarPath}`);
+            console.log(`[INFO]: "${name}" chmod binary finished`);
+            resolve();
+          })
+          .on("error", onError);
+      });
     }
-
+  } catch (err) {
+    // 需要删除文件
+    await fs.remove(sidecarPath);
+    throw err;
+  } finally {
     // delete temp dir
     await fs.remove(tempDir);
   }
+}
 
-  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);
+/**
+ * prepare clash core
+ * if the core version is not updated in time, use S3 storage as a backup.
+ */
+async function resolveClash() {
+  try {
+    return await resolveSidecar(clash());
+  } catch {
+    console.log(`[WARN]: clash core needs to be updated`);
+    return await resolveSidecar(clashS3());
   }
 }
 
@@ -225,58 +219,26 @@ async function resolveWintun() {
 }
 
 /**
- * only Windows
- * get the clash-verge-service.exe
+ * download the file to the resources dir
  */
-async function resolveService() {
-  const { platform } = process;
-
-  if (platform !== "win32") return;
+async function resolveResource(binInfo) {
+  const { file, downloadURL } = binInfo;
 
   const resDir = path.join(cwd, "src-tauri/resources");
+  const targetPath = path.join(resDir, file);
 
-  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);
-  }
+  if (!FORCE && (await fs.pathExists(targetPath))) return;
 
   await fs.mkdirp(resDir);
-  await help("clash-verge-service.exe");
-  await help("install-service.exe");
-  await help("uninstall-service.exe");
+  await downloadFile(downloadURL, targetPath);
 
-  console.log(`[INFO]: resolve Service finished`);
-}
-
-/**
- * get the Country.mmdb (not required)
- */
-async function resolveMmdb() {
-  const url =
-    "https://github.com/Dreamacro/maxmind-geoip/releases/download/20221012/Country.mmdb";
-
-  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);
+  console.log(`[INFO]: ${file} finished`);
 }
 
 /**
  * download file and save to `path`
  */
 async function downloadFile(url, path) {
-  console.log(`[INFO]: downloading from "${url}"`);
-
   const options = {};
 
   const httpProxy =
@@ -300,8 +262,71 @@ async function downloadFile(url, path) {
   console.log(`[INFO]: download finished "${url}"`);
 }
 
-/// main
-resolveSidecar().catch(console.error);
-resolveWintun().catch(console.error);
-resolveMmdb().catch(console.error);
-resolveService().catch(console.error);
+/**
+ * main
+ */
+const SERVICE_URL =
+  "https://github.com/zzzgydi/clash-verge-service/releases/download/latest";
+
+const resolveService = () =>
+  resolveResource({
+    file: "clash-verge-service.exe",
+    downloadURL: `${SERVICE_URL}/clash-verge-service.exe`,
+  });
+const resolveInstall = () =>
+  resolveResource({
+    file: "install-service.exe",
+    downloadURL: `${SERVICE_URL}/install-service.exe`,
+  });
+const resolveUninstall = () =>
+  resolveResource({
+    file: "uninstall-service.exe",
+    downloadURL: `${SERVICE_URL}/uninstall-service.exe`,
+  });
+const resolveMmdb = () =>
+  resolveResource({
+    file: "Country.mmdb",
+    downloadURL: `https://github.com/Dreamacro/maxmind-geoip/releases/download/20230812/Country.mmdb`,
+  });
+const resolveGeosite = () =>
+  resolveResource({
+    file: "geosite.dat",
+    downloadURL: `https://github.com/MetaCubeX/meta-rules-dat/releases/download/latest/geosite.dat`,
+  });
+const resolveGeoIP = () =>
+  resolveResource({
+    file: "geoip.dat",
+    downloadURL: `https://github.com/MetaCubeX/meta-rules-dat/releases/download/latest/geoip.dat`,
+  });
+
+const tasks = [
+  { name: "clash", func: () => resolveSidecar(clashS3()), retry: 5 },
+  { name: "clash-meta", func: () => resolveSidecar(clashMeta()), retry: 5 },
+  { name: "wintun", func: resolveWintun, retry: 5, winOnly: true },
+  { name: "service", func: resolveService, retry: 5, winOnly: true },
+  { name: "install", func: resolveInstall, retry: 5, winOnly: true },
+  { name: "uninstall", func: resolveUninstall, retry: 5, winOnly: true },
+  { name: "mmdb", func: resolveMmdb, retry: 5 },
+  { name: "geosite", func: resolveGeosite, retry: 5 },
+  { name: "geoip", func: resolveGeoIP, retry: 5 },
+];
+
+async function runTask() {
+  const task = tasks.shift();
+  if (!task) return;
+  if (task.winOnly && process.platform !== "win32") return runTask();
+
+  for (let i = 0; i < task.retry; i++) {
+    try {
+      await task.func();
+      break;
+    } catch (err) {
+      console.error(`[ERROR]: task::${task.name} try ${i} ==`, err.message);
+      if (i === task.retry - 1) throw err;
+    }
+  }
+  return runTask();
+}
+
+runTask();
+runTask();

scripts/portable.mjs

@@ -4,8 +4,6 @@ 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() {
@@ -41,9 +39,11 @@ async function resolvePortable() {
   const options = { owner: context.repo.owner, repo: context.repo.repo };
   const github = getOctokit(process.env.GITHUB_TOKEN);
 
+  console.log("[INFO]: upload to ", process.env.TAG_NAME || `v${version}`);
+
   const { data: release } = await github.rest.repos.getReleaseByTag({
     ...options,
-    tag: `v${version}`,
+    tag: process.env.TAG_NAME || `v${version}`,
   });
 
   console.log(release.name);
@@ -56,54 +56,4 @@ async function resolvePortable() {
   });
 }
 
-/// 打包包含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);
+resolvePortable().catch(console.error);

scripts/updater.mjs

@@ -43,6 +43,7 @@ async function resolveUpdater() {
       darwin: { signature: "", url: "" }, // compatible with older formats
       "darwin-aarch64": { signature: "", url: "" },
       "darwin-intel": { signature: "", url: "" },
+      "darwin-x86_64": { signature: "", url: "" },
       "linux-x86_64": { signature: "", url: "" },
       "windows-x86_64": { signature: "", url: "" },
       "windows-i686": { signature: "", url: "" }, // no supported
@@ -68,12 +69,14 @@ async function resolveUpdater() {
     if (name.endsWith(".app.tar.gz") && !name.includes("aarch")) {
       updateData.platforms.darwin.url = browser_download_url;
       updateData.platforms["darwin-intel"].url = browser_download_url;
+      updateData.platforms["darwin-x86_64"].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;
+      updateData.platforms["darwin-x86_64"].signature = sig;
     }
 
     // darwin url (aarch)
@@ -117,10 +120,7 @@ async function resolveUpdater() {
 
   Object.entries(updateDataNew.platforms).forEach(([key, value]) => {
     if (value.url) {
-      updateDataNew.platforms[key].url = value.url.replace(
-        "https://github.com/",
-        "https://hub.fastgit.xyz/"
-      );
+      updateDataNew.platforms[key].url = "https://ghproxy.com/" + value.url;
     } else {
       console.log(`[Error]: updateDataNew.platforms.${key} is null`);
     }

src-tauri/Cargo.toml

@@ -16,42 +16,51 @@ tauri-build = { version = "1", features = [] }
 warp = "0.3"
 which = "4.2.2"
 anyhow = "1.0"
-dirs = "4.0.0"
-open = "3.0.3"
+dirs = "5.0.0"
+open = "4.0.1"
 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"
+sysinfo = "0.29"
+sysproxy = "0.3"
+rquickjs = "0.1.7"
 serde_json = "1.0"
 serde_yaml = "0.9"
-auto-launch = "0.4"
+auto-launch = "0.5"
 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" }
+reqwest = { version = "0.11", features = ["json","rustls-tls"] }
+tauri = { version = "1.2.4", features = ["global-shortcut-all", "process-all", "shell-all", "system-tray", "updater", "window-all"] }
 window-vibrancy = { version = "0.3.0" }
+window-shadows = { version = "0.2.0" }
+wry = { version = "0.24.3" }
+
 
 [target.'cfg(windows)'.dependencies]
-runas = "0.2.1"
+runas = "1.1.0"
 deelevate = "0.2.0"
-winreg = { version = "0.10", features = ["transactions"] }
-windows-sys = { version = "0.36", features = ["Win32_System_LibraryLoader", "Win32_System_SystemInformation"] }
+winreg = { version = "0.50", features = ["transactions"] }
+windows-sys = { version = "0.48", features = ["Win32_System_LibraryLoader", "Win32_System_SystemInformation"] }
+
+[target.'cfg(windows)'.dependencies.tauri]
+features = ["global-shortcut-all", "icon-png", "process-all", "shell-all", "system-tray", "updater", "window-all"]
+
+[target.'cfg(linux)'.dependencies.tauri]
+features = ["global-shortcut-all", "process-all", "shell-all", "system-tray", "updater", "window-all", "native-tls-vendored", "reqwest-native-tls-vendored"]
+
 
 [features]
 default = ["custom-protocol"]
 custom-protocol = ["tauri/custom-protocol"]
 verge-dev = []
-debug-yml = []
+default-meta = []
 
 [profile.release]
 panic = "abort"

src-tauri/build.rs

@@ -1,3 +1,3 @@
 fn main() {
-  tauri_build::build()
+    tauri_build::build()
 }

src-tauri/rustfmt.toml

@@ -1,6 +1,6 @@
 max_width = 100
 hard_tabs = false
-tab_spaces = 2
+tab_spaces = 4
 newline_style = "Auto"
 use_small_heuristics = "Default"
 reorder_imports = true

src-tauri/src/cmds.rs

@@ -1,361 +1,280 @@
 use crate::{
-  core::Core,
-  data::{ClashInfo, Data, PrfItem, PrfOption, Profiles, Verge},
-  utils::{dirs, help},
+    config::*,
+    core::*,
+    feat,
+    utils::{dirs, help},
 };
-use crate::{log_if_err, ret_err, wrap_err};
-use anyhow::Result;
+use crate::{ret_err, wrap_err};
+use anyhow::{Context, Result};
 use serde_yaml::Mapping;
 use std::collections::{HashMap, VecDeque};
 use sysproxy::Sysproxy;
 
 type CmdResult<T = ()> = Result<T, String>;
 
-/// get all profiles from `profiles.yaml`
 #[tauri::command]
-pub fn get_profiles() -> CmdResult<Profiles> {
-  let global = Data::global();
-  let profiles = global.profiles.lock();
-  Ok(profiles.clone())
+pub fn get_profiles() -> CmdResult<IProfiles> {
+    Ok(Config::profiles().data().clone())
 }
 
-/// manually exec enhanced profile
 #[tauri::command]
-pub fn enhance_profiles() -> CmdResult {
-  let core = Core::global();
-  wrap_err!(core.activate())
+pub async fn enhance_profiles() -> CmdResult {
+    wrap_err!(CoreManager::global().update_config().await)?;
+    handle::Handle::refresh_clash();
+    Ok(())
 }
 
-/// import the profile from url
-/// and save to `profiles.yaml`
 #[tauri::command]
 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))
+    let item = wrap_err!(PrfItem::from_url(&url, None, None, option).await)?;
+    wrap_err!(Config::profiles().data().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 create_profile(item: PrfItem, file_data: Option<String>) -> CmdResult {
-  let item = wrap_err!(PrfItem::from(item, file_data).await)?;
-
-  let global = Data::global();
-  let mut profiles = global.profiles.lock();
-  wrap_err!(profiles.append_item(item))
+    let item = wrap_err!(PrfItem::from(item, file_data).await)?;
+    wrap_err!(Config::profiles().data().append_item(item))
 }
 
-/// Update the profile
 #[tauri::command]
 pub async fn update_profile(index: String, option: Option<PrfOption>) -> CmdResult {
-  let core = Core::global();
-  wrap_err!(core.update_profile_item(index, option).await)
+    wrap_err!(feat::update_profile(index, option).await)
 }
 
-/// change the current profile
 #[tauri::command]
-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);
+pub async fn delete_profile(index: String) -> CmdResult {
+    let should_update = wrap_err!({ Config::profiles().data().delete_item(index) })?;
+    if should_update {
+        wrap_err!(CoreManager::global().update_config().await)?;
+        handle::Handle::refresh_clash();
+    }
 
-  let core = Core::global();
-  wrap_err!(core.activate())
+    Ok(())
 }
 
-/// change the profile chain
+/// 修改profiles的
 #[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);
+pub async fn patch_profiles_config(profiles: IProfiles) -> CmdResult {
+    wrap_err!({ Config::profiles().draft().patch_config(profiles) })?;
 
-  let core = Core::global();
-  wrap_err!(core.activate())
+    match CoreManager::global().update_config().await {
+        Ok(_) => {
+            handle::Handle::refresh_clash();
+            Config::profiles().apply();
+            wrap_err!(Config::profiles().data().save_file())?;
+            Ok(())
+        }
+        Err(err) => {
+            Config::profiles().discard();
+            log::error!(target: "app", "{err}");
+            Err(format!("{err}"))
+        }
+    }
 }
 
-/// 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: 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
+/// 修改某个profile item的
 #[tauri::command]
 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())
+    wrap_err!(Config::profiles().data().patch_item(index, profile))?;
+    wrap_err!(timer::Timer::global().refresh())
 }
 
-/// run vscode command to edit the profile
 #[tauri::command]
 pub fn view_profile(index: String) -> CmdResult {
-  let global = Data::global();
-  let profiles = global.profiles.lock();
-  let item = wrap_err!(profiles.get_item(&index))?;
+    let file = {
+        wrap_err!(Config::profiles().latest().get_item(&index))?
+            .file
+            .clone()
+            .ok_or("the file field is null")
+    }?;
 
-  let file = item.file.clone();
-  if file.is_none() {
-    ret_err!("file is null");
-  }
+    let path = wrap_err!(dirs::app_profiles_dir())?.join(file);
+    if !path.exists() {
+        ret_err!("the file not found");
+    }
 
-  let path = dirs::app_profiles_dir().join(file.unwrap());
-  if !path.exists() {
-    ret_err!("file not found");
-  }
-
-  wrap_err!(help::open_file(path))
+    wrap_err!(help::open_file(path))
 }
 
-/// read the profile item file data
 #[tauri::command]
 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)
+    let profiles = Config::profiles();
+    let profiles = profiles.latest();
+    let item = wrap_err!(profiles.get_item(&index))?;
+    let data = wrap_err!(item.read_file())?;
+    Ok(data)
 }
 
-/// 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(());
-  }
+    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()))
+    let profiles = Config::profiles();
+    let profiles = profiles.latest();
+    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() -> CmdResult<ClashInfo> {
-  let global = Data::global();
-  let clash = global.clash.lock();
-  Ok(clash.info.clone())
+    Ok(Config::clash().latest().get_client_info())
 }
 
-/// 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())
+    Ok(Config::runtime().latest().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())
+pub fn get_runtime_yaml() -> CmdResult<String> {
+    let runtime = Config::runtime();
+    let runtime = runtime.latest();
+    let config = runtime.config.as_ref();
+    wrap_err!(config
+        .ok_or(anyhow::anyhow!("failed to parse config to yaml file"))
+        .and_then(
+            |config| serde_yaml::to_string(config).context("failed to convert config to yaml")
+        ))
 }
 
-/// 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())
+    Ok(Config::runtime().latest().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) -> CmdResult {
-  let core = Core::global();
-  wrap_err!(core.patch_clash(payload))
+    Ok(Config::runtime().latest().chain_logs.clone())
 }
 
 #[tauri::command]
-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 fn patch_verge_config(payload: Verge) -> CmdResult {
-  let core = Core::global();
-  wrap_err!(core.patch_verge(payload))
+pub async fn patch_clash_config(payload: Mapping) -> CmdResult {
+    wrap_err!(feat::patch_clash(payload).await)
 }
 
 #[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))
+pub fn get_verge_config() -> CmdResult<IVerge> {
+    Ok(Config::verge().data().clone())
 }
 
-/// 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))
+pub async fn patch_verge_config(payload: IVerge) -> CmdResult {
+    wrap_err!(feat::patch_verge(payload).await)
+}
+
+#[tauri::command]
+pub async fn change_clash_core(clash_core: Option<String>) -> CmdResult {
+    wrap_err!(CoreManager::global().change_core(clash_core).await)
 }
 
 /// restart the sidecar
 #[tauri::command]
-pub fn restart_sidecar() -> CmdResult {
-  let core = Core::global();
-  wrap_err!(core.restart_clash())
+pub async fn restart_sidecar() -> CmdResult {
+    wrap_err!(CoreManager::global().run_core().await)
 }
 
-/// kill all sidecars when update app
 #[tauri::command]
-pub fn kill_sidecar() {
-  tauri::api::process::kill_children();
+pub fn grant_permission(core: String) -> CmdResult {
+    #[cfg(any(target_os = "macos", target_os = "linux"))]
+    return wrap_err!(manager::grant_permission(core));
+
+    #[cfg(not(any(target_os = "macos", target_os = "linux")))]
+    return Err("Unsupported target".into());
 }
 
 /// get the system proxy
 #[tauri::command]
 pub fn get_sys_proxy() -> CmdResult<Mapping> {
-  let current = wrap_err!(Sysproxy::get_system_proxy())?;
+    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());
+    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)
+    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())
+    Ok(logger::Logger::global().get_log())
 }
 
-/// 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))
+    let app_dir = wrap_err!(dirs::app_home_dir())?;
+    wrap_err!(open::that(app_dir))
+}
+
+#[tauri::command]
+pub fn open_core_dir() -> CmdResult<()> {
+    let core_dir = wrap_err!(tauri::utils::platform::current_exe())?;
+    let core_dir = core_dir.parent().ok_or(format!("failed to get core dir"))?;
+    wrap_err!(open::that(core_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))
+    let log_dir = wrap_err!(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))
+    wrap_err!(open::that(url))
+}
+
+#[tauri::command]
+pub async fn clash_api_get_proxy_delay(
+    name: String,
+    url: Option<String>,
+) -> CmdResult<clash_api::DelayRes> {
+    match clash_api::get_proxy_delay(name, url).await {
+        Ok(res) => Ok(res),
+        Err(err) => Err(format!("{}", err.to_string())),
+    }
 }
 
-/// service mode
 #[cfg(windows)]
 pub mod service {
-  use super::*;
-  use crate::core::win_service::JsonResponse;
+    use super::*;
+    use crate::core::win_service;
 
-  #[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 check_service() -> CmdResult<win_service::JsonResponse> {
+        wrap_err!(win_service::check_service().await)
     }
-  }
 
-  #[tauri::command]
-  pub async fn install_service() -> CmdResult<()> {
-    wrap_err!(crate::core::Service::install_service().await)
-  }
+    #[tauri::command]
+    pub async fn install_service() -> CmdResult {
+        wrap_err!(win_service::install_service().await)
+    }
 
-  #[tauri::command]
-  pub async fn uninstall_service() -> CmdResult<()> {
-    wrap_err!(crate::core::Service::uninstall_service().await)
-  }
+    #[tauri::command]
+    pub async fn uninstall_service() -> CmdResult {
+        wrap_err!(win_service::uninstall_service().await)
+    }
 }
 
 #[cfg(not(windows))]
 pub mod service {
-  use super::*;
+    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(())
-  }
+    #[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/clash.rs

@@ -0,0 +1,262 @@
+use crate::utils::{dirs, help};
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+use serde_yaml::{Mapping, Value};
+use std::{
+    net::{IpAddr, Ipv4Addr, SocketAddr},
+    str::FromStr,
+};
+
+#[derive(Default, Debug, Clone)]
+pub struct IClashTemp(pub Mapping);
+
+impl IClashTemp {
+    pub fn new() -> Self {
+        match dirs::clash_path().and_then(|path| help::read_merge_mapping(&path)) {
+            Ok(map) => Self(Self::guard(map)),
+            Err(err) => {
+                log::error!(target: "app", "{err}");
+                Self::template()
+            }
+        }
+    }
+
+    pub fn template() -> Self {
+        let mut map = Mapping::new();
+
+        map.insert(
+            "mixed-port".into(),
+            match cfg!(feature = "default-meta") {
+                false => 7890.into(),
+                true => 7898.into(),
+            },
+        );
+        map.insert("log-level".into(), "info".into());
+        map.insert("allow-lan".into(), false.into());
+        map.insert("mode".into(), "rule".into());
+        map.insert(
+            "external-controller".into(),
+            match cfg!(feature = "default-meta") {
+                false => "127.0.0.1:9090".into(),
+                true => "127.0.0.1:9098".into(),
+            },
+        );
+        map.insert("secret".into(), "".into());
+
+        Self(map)
+    }
+
+    fn guard(mut config: Mapping) -> Mapping {
+        let port = Self::guard_mixed_port(&config);
+        let ctrl = Self::guard_server_ctrl(&config);
+
+        config.insert("mixed-port".into(), port.into());
+        config.insert("external-controller".into(), ctrl.into());
+        config
+    }
+
+    pub fn patch_config(&mut self, patch: Mapping) {
+        for (key, value) in patch.into_iter() {
+            self.0.insert(key, value);
+        }
+    }
+
+    pub fn save_config(&self) -> Result<()> {
+        help::save_yaml(
+            &dirs::clash_path()?,
+            &self.0,
+            Some("# Generated by Clash Verge"),
+        )
+    }
+
+    pub fn get_mixed_port(&self) -> u16 {
+        Self::guard_mixed_port(&self.0)
+    }
+
+    pub fn get_client_info(&self) -> ClashInfo {
+        let config = &self.0;
+
+        ClashInfo {
+            port: Self::guard_mixed_port(&config),
+            server: Self::guard_client_ctrl(&config),
+            secret: config.get("secret").and_then(|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,
+            }),
+        }
+    }
+
+    pub fn guard_mixed_port(config: &Mapping) -> u16 {
+        let mut port = config
+            .get("mixed-port")
+            .and_then(|value| match value {
+                Value::String(val_str) => val_str.parse().ok(),
+                Value::Number(val_num) => val_num.as_u64().map(|u| u as u16),
+                _ => None,
+            })
+            .unwrap_or(7890);
+        if port == 0 {
+            port = 7890;
+        }
+        port
+    }
+
+    pub fn guard_server_ctrl(config: &Mapping) -> String {
+        config
+            .get("external-controller")
+            .and_then(|value| match value.as_str() {
+                Some(val_str) => {
+                    let val_str = val_str.trim();
+
+                    let val = match val_str.starts_with(":") {
+                        true => format!("127.0.0.1{val_str}"),
+                        false => val_str.to_owned(),
+                    };
+
+                    SocketAddr::from_str(val.as_str())
+                        .ok()
+                        .map(|s| s.to_string())
+                }
+                None => None,
+            })
+            .unwrap_or("127.0.0.1:9090".into())
+    }
+
+    pub fn guard_client_ctrl(config: &Mapping) -> String {
+        let value = Self::guard_server_ctrl(config);
+        match SocketAddr::from_str(value.as_str()) {
+            Ok(mut socket) => {
+                if socket.ip().is_unspecified() {
+                    socket.set_ip(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)));
+                }
+                socket.to_string()
+            }
+            Err(_) => "127.0.0.1:9090".into(),
+        }
+    }
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
+pub struct ClashInfo {
+    /// clash core port
+    pub port: u16,
+    /// same as `external-controller`
+    pub server: String,
+    /// clash secret
+    pub secret: Option<String>,
+}
+
+#[test]
+fn test_clash_info() {
+    fn get_case<T: Into<Value>, D: Into<Value>>(mp: T, ec: D) -> ClashInfo {
+        let mut map = Mapping::new();
+        map.insert("mixed-port".into(), mp.into());
+        map.insert("external-controller".into(), ec.into());
+
+        IClashTemp(IClashTemp::guard(map)).get_client_info()
+    }
+
+    fn get_result<S: Into<String>>(port: u16, server: S) -> ClashInfo {
+        ClashInfo {
+            port,
+            server: server.into(),
+            secret: None,
+        }
+    }
+
+    assert_eq!(
+        IClashTemp(IClashTemp::guard(Mapping::new())).get_client_info(),
+        get_result(7890, "127.0.0.1:9090")
+    );
+
+    assert_eq!(get_case("", ""), get_result(7890, "127.0.0.1:9090"));
+
+    assert_eq!(get_case(65537, ""), get_result(1, "127.0.0.1:9090"));
+
+    assert_eq!(
+        get_case(8888, "127.0.0.1:8888"),
+        get_result(8888, "127.0.0.1:8888")
+    );
+
+    assert_eq!(
+        get_case(8888, "   :98888 "),
+        get_result(8888, "127.0.0.1:9090")
+    );
+
+    assert_eq!(
+        get_case(8888, "0.0.0.0:8080  "),
+        get_result(8888, "127.0.0.1:8080")
+    );
+
+    assert_eq!(
+        get_case(8888, "0.0.0.0:8080"),
+        get_result(8888, "127.0.0.1:8080")
+    );
+
+    assert_eq!(
+        get_case(8888, "[::]:8080"),
+        get_result(8888, "127.0.0.1:8080")
+    );
+
+    assert_eq!(
+        get_case(8888, "192.168.1.1:8080"),
+        get_result(8888, "192.168.1.1:8080")
+    );
+
+    assert_eq!(
+        get_case(8888, "192.168.1.1:80800"),
+        get_result(8888, "127.0.0.1:9090")
+    );
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "kebab-case")]
+pub struct IClash {
+    pub mixed_port: Option<u16>,
+    pub allow_lan: Option<bool>,
+    pub log_level: Option<String>,
+    pub ipv6: Option<bool>,
+    pub mode: Option<String>,
+    pub external_controller: Option<String>,
+    pub secret: Option<String>,
+    pub dns: Option<IClashDNS>,
+    pub tun: Option<IClashTUN>,
+    pub interface_name: Option<String>,
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "kebab-case")]
+pub struct IClashTUN {
+    pub enable: Option<bool>,
+    pub stack: Option<String>,
+    pub auto_route: Option<bool>,
+    pub auto_detect_interface: Option<bool>,
+    pub dns_hijack: Option<Vec<String>>,
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "kebab-case")]
+pub struct IClashDNS {
+    pub enable: Option<bool>,
+    pub listen: Option<String>,
+    pub default_nameserver: Option<Vec<String>>,
+    pub enhanced_mode: Option<String>,
+    pub fake_ip_range: Option<String>,
+    pub use_hosts: Option<bool>,
+    pub fake_ip_filter: Option<Vec<String>>,
+    pub nameserver: Option<Vec<String>>,
+    pub fallback: Option<Vec<String>>,
+    pub fallback_filter: Option<IClashFallbackFilter>,
+    pub nameserver_policy: Option<Vec<String>>,
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "kebab-case")]
+pub struct IClashFallbackFilter {
+    pub geoip: Option<bool>,
+    pub geoip_code: Option<String>,
+    pub ipcidr: Option<Vec<String>>,
+    pub domain: Option<Vec<String>>,
+}

src-tauri/src/config/config.rs

@@ -0,0 +1,103 @@
+use super::{Draft, IClashTemp, IProfiles, IRuntime, IVerge};
+use crate::{
+    enhance,
+    utils::{dirs, help},
+};
+use anyhow::{anyhow, Result};
+use once_cell::sync::OnceCell;
+use std::{env::temp_dir, path::PathBuf};
+
+pub const RUNTIME_CONFIG: &str = "clash-verge.yaml";
+pub const CHECK_CONFIG: &str = "clash-verge-check.yaml";
+
+pub struct Config {
+    clash_config: Draft<IClashTemp>,
+    verge_config: Draft<IVerge>,
+    profiles_config: Draft<IProfiles>,
+    runtime_config: Draft<IRuntime>,
+}
+
+impl Config {
+    pub fn global() -> &'static Config {
+        static CONFIG: OnceCell<Config> = OnceCell::new();
+
+        CONFIG.get_or_init(|| Config {
+            clash_config: Draft::from(IClashTemp::new()),
+            verge_config: Draft::from(IVerge::new()),
+            profiles_config: Draft::from(IProfiles::new()),
+            runtime_config: Draft::from(IRuntime::new()),
+        })
+    }
+
+    pub fn clash() -> Draft<IClashTemp> {
+        Self::global().clash_config.clone()
+    }
+
+    pub fn verge() -> Draft<IVerge> {
+        Self::global().verge_config.clone()
+    }
+
+    pub fn profiles() -> Draft<IProfiles> {
+        Self::global().profiles_config.clone()
+    }
+
+    pub fn runtime() -> Draft<IRuntime> {
+        Self::global().runtime_config.clone()
+    }
+
+    /// 初始化配置
+    pub fn init_config() -> Result<()> {
+        crate::log_err!(Self::generate());
+        if let Err(err) = Self::generate_file(ConfigType::Run) {
+            log::error!(target: "app", "{err}");
+
+            let runtime_path = dirs::app_home_dir()?.join(RUNTIME_CONFIG);
+            // 如果不存在就将默认的clash文件拿过来
+            if !runtime_path.exists() {
+                help::save_yaml(
+                    &runtime_path,
+                    &Config::clash().latest().0,
+                    Some("# Clash Verge Runtime"),
+                )?;
+            }
+        }
+        Ok(())
+    }
+
+    /// 将配置丢到对应的文件中
+    pub fn generate_file(typ: ConfigType) -> Result<PathBuf> {
+        let path = match typ {
+            ConfigType::Run => dirs::app_home_dir()?.join(RUNTIME_CONFIG),
+            ConfigType::Check => temp_dir().join(CHECK_CONFIG),
+        };
+
+        let runtime = Config::runtime();
+        let runtime = runtime.latest();
+        let config = runtime
+            .config
+            .as_ref()
+            .ok_or(anyhow!("failed to get runtime config"))?;
+
+        help::save_yaml(&path, &config, Some("# Generated by Clash Verge"))?;
+        Ok(path)
+    }
+
+    /// 生成配置存好
+    pub fn generate() -> Result<()> {
+        let (config, exists_keys, logs) = enhance::enhance();
+
+        *Config::runtime().draft() = IRuntime {
+            config: Some(config),
+            exists_keys,
+            chain_logs: logs,
+        };
+
+        Ok(())
+    }
+}
+
+#[derive(Debug)]
+pub enum ConfigType {
+    Run,
+    Check,
+}

src-tauri/src/config/draft.rs

@@ -0,0 +1,127 @@
+use super::{IClashTemp, IProfiles, IRuntime, IVerge};
+use parking_lot::{MappedMutexGuard, Mutex, MutexGuard};
+use std::sync::Arc;
+
+#[derive(Debug, Clone)]
+pub struct Draft<T: Clone + ToOwned> {
+    inner: Arc<Mutex<(T, Option<T>)>>,
+}
+
+macro_rules! draft_define {
+    ($id: ident) => {
+        impl Draft<$id> {
+            #[allow(unused)]
+            pub fn data(&self) -> MappedMutexGuard<$id> {
+                MutexGuard::map(self.inner.lock(), |guard| &mut guard.0)
+            }
+
+            pub fn latest(&self) -> MappedMutexGuard<$id> {
+                MutexGuard::map(self.inner.lock(), |inner| {
+                    if inner.1.is_none() {
+                        &mut inner.0
+                    } else {
+                        inner.1.as_mut().unwrap()
+                    }
+                })
+            }
+
+            pub fn draft(&self) -> MappedMutexGuard<$id> {
+                MutexGuard::map(self.inner.lock(), |inner| {
+                    if inner.1.is_none() {
+                        inner.1 = Some(inner.0.clone());
+                    }
+
+                    inner.1.as_mut().unwrap()
+                })
+            }
+
+            pub fn apply(&self) -> Option<$id> {
+                let mut inner = self.inner.lock();
+
+                match inner.1.take() {
+                    Some(draft) => {
+                        let old_value = inner.0.to_owned();
+                        inner.0 = draft.to_owned();
+                        Some(old_value)
+                    }
+                    None => None,
+                }
+            }
+
+            pub fn discard(&self) -> Option<$id> {
+                let mut inner = self.inner.lock();
+                inner.1.take()
+            }
+        }
+
+        impl From<$id> for Draft<$id> {
+            fn from(data: $id) -> Self {
+                Draft {
+                    inner: Arc::new(Mutex::new((data, None))),
+                }
+            }
+        }
+    };
+}
+
+// draft_define!(IClash);
+draft_define!(IClashTemp);
+draft_define!(IProfiles);
+draft_define!(IRuntime);
+draft_define!(IVerge);
+
+#[test]
+fn test_draft() {
+    let verge = IVerge {
+        enable_auto_launch: Some(true),
+        enable_tun_mode: Some(false),
+        ..IVerge::default()
+    };
+
+    let draft = Draft::from(verge);
+
+    assert_eq!(draft.data().enable_auto_launch, Some(true));
+    assert_eq!(draft.data().enable_tun_mode, Some(false));
+
+    assert_eq!(draft.draft().enable_auto_launch, Some(true));
+    assert_eq!(draft.draft().enable_tun_mode, Some(false));
+
+    let mut d = draft.draft();
+    d.enable_auto_launch = Some(false);
+    d.enable_tun_mode = Some(true);
+    drop(d);
+
+    assert_eq!(draft.data().enable_auto_launch, Some(true));
+    assert_eq!(draft.data().enable_tun_mode, Some(false));
+
+    assert_eq!(draft.draft().enable_auto_launch, Some(false));
+    assert_eq!(draft.draft().enable_tun_mode, Some(true));
+
+    assert_eq!(draft.latest().enable_auto_launch, Some(false));
+    assert_eq!(draft.latest().enable_tun_mode, Some(true));
+
+    assert!(draft.apply().is_some());
+    assert!(draft.apply().is_none());
+
+    assert_eq!(draft.data().enable_auto_launch, Some(false));
+    assert_eq!(draft.data().enable_tun_mode, Some(true));
+
+    assert_eq!(draft.draft().enable_auto_launch, Some(false));
+    assert_eq!(draft.draft().enable_tun_mode, Some(true));
+
+    let mut d = draft.draft();
+    d.enable_auto_launch = Some(true);
+    drop(d);
+
+    assert_eq!(draft.data().enable_auto_launch, Some(false));
+
+    assert_eq!(draft.draft().enable_auto_launch, Some(true));
+
+    assert!(draft.discard().is_some());
+
+    assert_eq!(draft.data().enable_auto_launch, Some(false));
+
+    assert!(draft.discard().is_none());
+
+    assert_eq!(draft.draft().enable_auto_launch, Some(false));
+}

src-tauri/src/config/field.rs

@@ -1,118 +0,0 @@
-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

@@ -1,93 +0,0 @@
-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

@@ -1,69 +1,15 @@
-mod field;
-mod merge;
-mod script;
-mod tun;
+mod clash;
+mod config;
+mod draft;
+mod prfitem;
+mod profiles;
+mod runtime;
+mod verge;
 
-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)
-}
+pub use self::clash::*;
+pub use self::config::*;
+pub use self::draft::*;
+pub use self::prfitem::*;
+pub use self::profiles::*;
+pub use self::runtime::*;
+pub use self::verge::*;

src-tauri/src/config/prfitem.rs

@@ -0,0 +1,374 @@
+use crate::utils::{dirs, help, tmpl};
+use anyhow::{bail, Context, Result};
+use reqwest::StatusCode;
+use serde::{Deserialize, Serialize};
+use serde_yaml::Mapping;
+use std::fs;
+use sysproxy::Sysproxy;
+
+use super::Config;
+
+#[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 information
+    #[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
+    /// use system proxy
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub with_proxy: Option<bool>,
+
+    /// for `remote` profile
+    /// use self proxy
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub self_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> {
+        match (one, other) {
+            (Some(mut a), Some(b)) => {
+                a.user_agent = b.user_agent.or(a.user_agent);
+                a.with_proxy = b.with_proxy.or(a.with_proxy);
+                a.self_proxy = b.self_proxy.or(a.self_proxy);
+                a.update_interval = b.update_interval.or(a.update_interval);
+                Some(a)
+            }
+            t @ _ => t.0.or(t.1),
+        }
+    }
+}
+
+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(chrono::Local::now().timestamp() as usize),
+            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 opt_ref = option.as_ref();
+        let with_proxy = opt_ref.map_or(false, |o| o.with_proxy.unwrap_or(false));
+        let self_proxy = opt_ref.map_or(false, |o| o.self_proxy.unwrap_or(false));
+        let user_agent = opt_ref.map_or(None, |o| o.user_agent.clone());
+
+        let mut builder = reqwest::ClientBuilder::new().use_rustls_tls().no_proxy();
+
+        // 使用软件自己的代理
+        if self_proxy {
+            let port = Config::clash().data().get_mixed_port();
+
+            let proxy_scheme = format!("http://127.0.0.1:{port}");
+
+            if let Ok(proxy) = reqwest::Proxy::http(&proxy_scheme) {
+                builder = builder.proxy(proxy);
+            }
+            if let Ok(proxy) = reqwest::Proxy::https(&proxy_scheme) {
+                builder = builder.proxy(proxy);
+            }
+            if let Ok(proxy) = reqwest::Proxy::all(&proxy_scheme) {
+                builder = builder.proxy(proxy);
+            }
+        }
+        // 使用系统代理
+        else if with_proxy {
+            match Sysproxy::get_system_proxy() {
+                Ok(p @ Sysproxy { enable: true, .. }) => {
+                    let proxy_scheme = format!("http://{}:{}", p.host, p.port);
+
+                    if let Ok(proxy) = reqwest::Proxy::http(&proxy_scheme) {
+                        builder = builder.proxy(proxy);
+                    }
+                    if let Ok(proxy) = reqwest::Proxy::https(&proxy_scheme) {
+                        builder = builder.proxy(proxy);
+                    }
+                    if let Ok(proxy) = reqwest::Proxy::all(&proxy_scheme) {
+                        builder = builder.proxy(proxy);
+                    }
+                }
+                _ => {}
+            };
+        }
+
+        let version = unsafe { dirs::APP_VERSION };
+        let version = format!("clash-verge/{version}");
+        builder = builder.user_agent(user_agent.unwrap_or(version));
+
+        let resp = builder.build()?.get(url).send().await?;
+
+        let status_code = resp.status();
+        if !StatusCode::is_success(&status_code) {
+            bail!("failed to fetch remote profile with status {status_code}")
+        }
+
+        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?;
+
+        // process the charset "UTF-8 with BOM"
+        let data = data.trim_start_matches('\u{feff}');
+
+        // check the data whether the valid yaml format
+        let yaml = serde_yaml::from_str::<Mapping>(data)
+            .context("the remote profile data is invalid yaml")?;
+
+        if !yaml.contains_key("proxies") && !yaml.contains_key("proxy-providers") {
+            bail!("profile does not contain `proxies` or `proxy-providers`");
+        }
+
+        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(chrono::Local::now().timestamp() as usize),
+            file_data: Some(data.into()),
+        })
+    }
+
+    /// ## 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(chrono::Local::now().timestamp() as usize),
+            file_data: Some(tmpl::ITEM_MERGE.into()),
+        })
+    }
+
+    /// ## Script type (enhance)
+    /// create the enhanced item by using javascript quick.js
+    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(chrono::Local::now().timestamp() as usize),
+            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")
+    }
+}

src-tauri/src/config/profiles.rs

@@ -0,0 +1,280 @@
+use super::prfitem::PrfItem;
+use crate::utils::{dirs, help};
+use anyhow::{bail, Context, Result};
+use serde::{Deserialize, Serialize};
+use serde_yaml::Mapping;
+use std::{fs, io::Write};
+
+/// Define the `profiles.yaml` schema
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct IProfiles {
+    /// same as PrfConfig.current
+    pub current: Option<String>,
+
+    /// same as PrfConfig.chain
+    pub chain: Option<Vec<String>>,
+
+    /// record valid fields for clash
+    pub valid: Option<Vec<String>>,
+
+    /// profile list
+    pub items: Option<Vec<PrfItem>>,
+}
+
+macro_rules! patch {
+    ($lv: expr, $rv: expr, $key: tt) => {
+        if ($rv.$key).is_some() {
+            $lv.$key = $rv.$key;
+        }
+    };
+}
+
+impl IProfiles {
+    pub fn new() -> Self {
+        match dirs::profiles_path().and_then(|path| help::read_yaml::<Self>(&path)) {
+            Ok(mut profiles) => {
+                if profiles.items.is_none() {
+                    profiles.items = Some(vec![]);
+                }
+                // compatible with the old old old version
+                profiles.items.as_mut().map(|items| {
+                    for item in items.iter_mut() {
+                        if item.uid.is_none() {
+                            item.uid = Some(help::get_uid("d"));
+                        }
+                    }
+                });
+                profiles
+            }
+            Err(err) => {
+                log::error!(target: "app", "{err}");
+                Self::template()
+            }
+        }
+    }
+
+    pub fn template() -> Self {
+        Self {
+            valid: Some(vec!["dns".into(), "sub-rules".into(), "unified-delay".into()]),
+            items: Some(vec![]),
+            ..Self::default()
+        }
+    }
+
+    pub fn save_file(&self) -> Result<()> {
+        help::save_yaml(
+            &dirs::profiles_path()?,
+            self,
+            Some("# Profiles Config for Clash Verge"),
+        )
+    }
+
+    /// 只修改current，valid和chain
+    pub fn patch_config(&mut self, patch: IProfiles) -> Result<()> {
+        if self.items.is_none() {
+            self.items = Some(vec![]);
+        }
+
+        if let Some(current) = patch.current {
+            let items = self.items.as_ref().unwrap();
+            let some_uid = Some(current);
+
+            if items.iter().any(|e| e.uid == some_uid) {
+                self.current = some_uid;
+            }
+        }
+
+        if let Some(chain) = patch.chain {
+            self.chain = Some(chain);
+        }
+
+        if let Some(valid) = patch.valid {
+            self.valid = Some(valid);
+        }
+
+        Ok(())
+    }
+
+    pub fn get_current(&self) -> Option<String> {
+        self.current.clone()
+    }
+
+    /// 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 let Some(items) = self.items.as_ref() {
+            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)
+                .with_context(|| format!("failed to create file \"{}\"", file))?
+                .write(file_data.as_bytes())
+                .with_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 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 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)
+                            .with_context(|| format!("failed to create file \"{}\"", file))?
+                            .write(file_data.as_bytes())
+                            .with_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 _ = dirs::app_profiles_dir().map(|path| {
+                    let path = path.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)
+    }
+
+    /// 获取current指向的配置内容
+    pub fn current_mapping(&self) -> Result<Mapping> {
+        match (self.current.as_ref(), self.items.as_ref()) {
+            (Some(current), Some(items)) => {
+                if let Some(item) = items.iter().find(|e| e.uid.as_ref() == Some(current)) {
+                    let file_path = match item.file.as_ref() {
+                        Some(file) => dirs::app_profiles_dir()?.join(file),
+                        None => bail!("failed to get the file field"),
+                    };
+                    return Ok(help::read_merge_mapping(&file_path)?);
+                }
+                bail!("failed to find the current profile \"uid:{current}\"");
+            }
+            _ => Ok(Mapping::new()),
+        }
+    }
+}

src-tauri/src/config/runtime.rs

@@ -0,0 +1,31 @@
+use serde::{Deserialize, Serialize};
+use serde_yaml::Mapping;
+use std::collections::HashMap;
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct IRuntime {
+    pub config: Option<Mapping>,
+    // 记录在配置中（包括merge和script生成的）出现过的keys
+    // 这些keys不一定都生效
+    pub exists_keys: Vec<String>,
+    pub chain_logs: HashMap<String, Vec<(String, String)>>,
+}
+
+impl IRuntime {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    // 这里只更改 allow-lan | ipv6 | log-level
+    pub fn patch_config(&mut self, patch: Mapping) {
+        if let Some(config) = self.config.as_mut() {
+            ["allow-lan", "ipv6", "log-level"]
+                .into_iter()
+                .for_each(|key| {
+                    if let Some(value) = patch.get(key).to_owned() {
+                        config.insert(key.into(), value.clone());
+                    }
+                });
+        }
+    }
+}

src-tauri/src/config/script.rs

@@ -1,94 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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);
-
-  append!(dns_val, "enhanced-mode", "fake-ip");
-  append!(dns_val, "fake-ip-range", "198.18.0.1/16");
-  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/config/verge.rs

@@ -0,0 +1,224 @@
+use crate::utils::{dirs, help};
+use anyhow::Result;
+use log::LevelFilter;
+use serde::{Deserialize, Serialize};
+
+/// ### `verge.yaml` schema
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct IVerge {
+    /// app listening port for app singleton
+    pub app_singleton_port: Option<u16>,
+
+    /// app log level
+    /// silent | error | warn | info | debug | trace
+    pub app_log_level: Option<String>,
+
+    // 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>,
+
+    /// show memory info (only for Clash Meta)
+    pub enable_memory_usage: 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<IVergeTheme>,
+
+    /// 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>>,
+
+    /// 切换代理时自动关闭连接
+    pub auto_close_connection: Option<bool>,
+
+    /// 默认的延迟测试连接
+    pub default_latency_test: Option<String>,
+
+    /// 支持关闭字段过滤，避免meta的新字段都被过滤掉，默认为真
+    pub enable_clash_fields: Option<bool>,
+
+    /// 是否使用内部的脚本支持，默认为真
+    pub enable_builtin_enhanced: Option<bool>,
+
+    /// proxy 页面布局 列数
+    pub proxy_layout_column: Option<i32>,
+
+    /// 日志清理
+    /// 0: 不清理; 1: 7天; 2: 30天; 3: 90天
+    pub auto_log_clean: Option<i32>,
+
+    /// window size and position
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub window_size_position: Option<Vec<f64>>,
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct IVergeTheme {
+    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 IVerge {
+    pub fn new() -> Self {
+        match dirs::verge_path().and_then(|path| help::read_yaml::<IVerge>(&path)) {
+            Ok(config) => config,
+            Err(err) => {
+                log::error!(target: "app", "{err}");
+                Self::template()
+            }
+        }
+    }
+
+    pub fn template() -> Self {
+        Self {
+            clash_core: match cfg!(feature = "default-meta") {
+                false => Some("clash".into()),
+                true => Some("clash-meta".into()),
+            },
+            language: match cfg!(feature = "default-meta") {
+                false => Some("en".into()),
+                true => Some("zh".into()),
+            },
+            theme_mode: Some("system".into()),
+            theme_blur: Some(false),
+            traffic_graph: Some(true),
+            enable_memory_usage: Some(true),
+            enable_auto_launch: Some(false),
+            enable_silent_start: Some(false),
+            enable_system_proxy: Some(false),
+            enable_proxy_guard: Some(false),
+            proxy_guard_duration: Some(30),
+            auto_close_connection: Some(true),
+            enable_builtin_enhanced: Some(true),
+            enable_clash_fields: Some(true),
+            auto_log_clean: Some(3),
+            ..Self::default()
+        }
+    }
+
+    /// Save IVerge App Config
+    pub fn save_file(&self) -> Result<()> {
+        help::save_yaml(&dirs::verge_path()?, &self, Some("# Clash Verge Config"))
+    }
+
+    /// patch verge config
+    /// only save to file
+    pub fn patch_config(&mut self, patch: IVerge) {
+        macro_rules! patch {
+            ($key: tt) => {
+                if patch.$key.is_some() {
+                    self.$key = patch.$key;
+                }
+            };
+        }
+
+        patch!(app_log_level);
+        patch!(language);
+        patch!(theme_mode);
+        patch!(theme_blur);
+        patch!(traffic_graph);
+        patch!(enable_memory_usage);
+
+        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);
+
+        patch!(auto_close_connection);
+        patch!(default_latency_test);
+        patch!(enable_builtin_enhanced);
+        patch!(proxy_layout_column);
+        patch!(enable_clash_fields);
+        patch!(auto_log_clean);
+        patch!(window_size_position);
+    }
+
+    /// 在初始化前尝试拿到单例端口的值
+    pub fn get_singleton_port() -> u16 {
+        #[cfg(not(feature = "verge-dev"))]
+        const SERVER_PORT: u16 = 33331;
+        #[cfg(feature = "verge-dev")]
+        const SERVER_PORT: u16 = 11233;
+
+        match dirs::verge_path().and_then(|path| help::read_yaml::<IVerge>(&path)) {
+            Ok(config) => config.app_singleton_port.unwrap_or(SERVER_PORT),
+            Err(_) => SERVER_PORT, // 这里就不log错误了
+        }
+    }
+
+    /// 获取日志等级
+    pub fn get_log_level(&self) -> LevelFilter {
+        if let Some(level) = self.app_log_level.as_ref() {
+            match level.to_lowercase().as_str() {
+                "silent" => LevelFilter::Off,
+                "error" => LevelFilter::Error,
+                "warn" => LevelFilter::Warn,
+                "info" => LevelFilter::Info,
+                "debug" => LevelFilter::Debug,
+                "trace" => LevelFilter::Trace,
+                _ => LevelFilter::Info,
+            }
+        } else {
+            LevelFilter::Info
+        }
+    }
+}

src-tauri/src/core/clash_api.rs

@@ -0,0 +1,141 @@
+use crate::config::Config;
+use anyhow::{bail, Result};
+use reqwest::header::HeaderMap;
+use serde::{Deserialize, Serialize};
+use serde_yaml::Mapping;
+use std::collections::HashMap;
+
+/// PUT /configs
+/// path 是绝对路径
+pub async fn put_configs(path: &str) -> Result<()> {
+    let (url, headers) = clash_client_info()?;
+    let url = format!("{url}/configs");
+
+    let mut data = HashMap::new();
+    data.insert("path", path);
+
+    let client = reqwest::ClientBuilder::new().no_proxy().build()?;
+    let builder = client.put(&url).headers(headers).json(&data);
+    let response = builder.send().await?;
+
+    match response.status().as_u16() {
+        204 => Ok(()),
+        status @ _ => {
+            bail!("failed to put configs with status \"{status}\"")
+        }
+    }
+}
+
+/// PATCH /configs
+pub async fn patch_configs(config: &Mapping) -> Result<()> {
+    let (url, headers) = clash_client_info()?;
+    let url = format!("{url}/configs");
+
+    let client = reqwest::ClientBuilder::new().no_proxy().build()?;
+    let builder = client.patch(&url).headers(headers.clone()).json(config);
+    builder.send().await?;
+    Ok(())
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct DelayRes {
+    delay: u64,
+}
+
+/// GET /proxies/{name}/delay
+/// 获取代理延迟
+pub async fn get_proxy_delay(name: String, test_url: Option<String>) -> Result<DelayRes> {
+    let (url, headers) = clash_client_info()?;
+    let url = format!("{url}/proxies/{name}/delay");
+
+    let default_url = "http://www.gstatic.com/generate_204";
+    let test_url = test_url
+        .map(|s| if s.is_empty() { default_url.into() } else { s })
+        .unwrap_or(default_url.into());
+
+    let client = reqwest::ClientBuilder::new().no_proxy().build()?;
+    let builder = client
+        .get(&url)
+        .headers(headers)
+        .query(&[("timeout", "10000"), ("url", &test_url)]);
+    let response = builder.send().await?;
+
+    Ok(response.json::<DelayRes>().await?)
+}
+
+/// 根据clash info获取clash服务地址和请求头
+fn clash_client_info() -> Result<(String, HeaderMap)> {
+    let client = { Config::clash().data().get_client_info() };
+
+    let server = format!("http://{}", client.server);
+
+    let mut headers = HeaderMap::new();
+    headers.insert("Content-Type", "application/json".parse()?);
+
+    if let Some(secret) = client.secret {
+        let secret = format!("Bearer {}", secret).parse()?;
+        headers.insert("Authorization", secret);
+    }
+
+    Ok((server, headers))
+}
+
+/// 缩短clash的日志
+pub fn parse_log(log: String) -> String {
+    if log.starts_with("time=") && log.len() > 33 {
+        return (&log[33..]).to_owned();
+    }
+    if log.len() > 9 {
+        return (&log[9..]).to_owned();
+    }
+    return log;
+}
+
+/// 缩短clash -t的错误输出
+/// 仅适配 clash p核 8-26、clash meta 1.13.1
+pub fn parse_check_output(log: String) -> String {
+    let t = log.find("time=");
+    let m = log.find("msg=");
+    let mr = log.rfind('"');
+
+    if let (Some(_), Some(m), Some(mr)) = (t, m, mr) {
+        let e = match log.find("level=error msg=") {
+            Some(e) => e + 17,
+            None => m + 5,
+        };
+
+        if mr > m {
+            return (&log[e..mr]).to_owned();
+        }
+    }
+
+    let l = log.find("error=");
+    let r = log.find("path=").or(Some(log.len()));
+
+    if let (Some(l), Some(r)) = (l, r) {
+        return (&log[(l + 6)..(r - 1)]).to_owned();
+    }
+
+    log
+}
+
+#[test]
+fn test_parse_check_output() {
+    let str1 = r#"xxxx\n time="2022-11-18T20:42:58+08:00" level=error msg="proxy 0: 'alpn' expected type 'string', got unconvertible type '[]interface {}'""#;
+    let str2 = r#"20:43:49 ERR [Config] configuration file test failed error=proxy 0: unsupport proxy type: hysteria path=xxx"#;
+    let str3 = r#"
+    "time="2022-11-18T21:38:01+08:00" level=info msg="Start initial configuration in progress"
+    time="2022-11-18T21:38:01+08:00" level=error msg="proxy 0: 'alpn' expected type 'string', got unconvertible type '[]interface {}'"
+    configuration file xxx\n
+    "#;
+
+    let res1 = parse_check_output(str1.into());
+    let res2 = parse_check_output(str2.into());
+    let res3 = parse_check_output(str3.into());
+
+    println!("res1: {res1}");
+    println!("res2: {res2}");
+    println!("res3: {res3}");
+
+    assert_eq!(res1, res3);
+}

src-tauri/src/core/core.rs

@@ -0,0 +1,325 @@
+use super::{clash_api, logger::Logger};
+use crate::log_err;
+use crate::{config::*, utils::dirs};
+use anyhow::{bail, Context, Result};
+use once_cell::sync::OnceCell;
+use parking_lot::Mutex;
+use std::{fs, io::Write, sync::Arc, time::Duration};
+use sysinfo::{Pid, PidExt, ProcessExt, System, SystemExt};
+use tauri::api::process::{Command, CommandChild, CommandEvent};
+use tokio::time::sleep;
+
+#[derive(Debug)]
+pub struct CoreManager {
+    sidecar: Arc<Mutex<Option<CommandChild>>>,
+
+    #[allow(unused)]
+    use_service_mode: Arc<Mutex<bool>>,
+}
+
+impl CoreManager {
+    pub fn global() -> &'static CoreManager {
+        static CORE_MANAGER: OnceCell<CoreManager> = OnceCell::new();
+
+        CORE_MANAGER.get_or_init(|| CoreManager {
+            sidecar: Arc::new(Mutex::new(None)),
+            use_service_mode: Arc::new(Mutex::new(false)),
+        })
+    }
+
+    pub fn init(&self) -> Result<()> {
+        // kill old clash process
+        let _ = dirs::clash_pid_path()
+            .and_then(|path| fs::read(path).map(|p| p.to_vec()).context(""))
+            .and_then(|pid| String::from_utf8_lossy(&pid).parse().context(""))
+            .map(|pid| {
+                let mut system = System::new();
+                system.refresh_all();
+                system.process(Pid::from_u32(pid)).map(|proc| {
+                    if proc.name().contains("clash") {
+                        log::debug!(target: "app", "kill old clash process");
+                        proc.kill();
+                    }
+                });
+            });
+
+        tauri::async_runtime::spawn(async {
+            // 启动clash
+            log_err!(Self::global().run_core().await);
+        });
+
+        Ok(())
+    }
+
+    /// 检查配置是否正确
+    pub fn check_config(&self) -> Result<()> {
+        let config_path = Config::generate_file(ConfigType::Check)?;
+        let config_path = dirs::path_to_str(&config_path)?;
+
+        let clash_core = { Config::verge().latest().clash_core.clone() };
+        let clash_core = clash_core.unwrap_or("clash".into());
+
+        let app_dir = dirs::app_home_dir()?;
+        let app_dir = dirs::path_to_str(&app_dir)?;
+
+        let output = Command::new_sidecar(clash_core)?
+            .args(["-t", "-d", app_dir, "-f", config_path])
+            .output()?;
+
+        if !output.status.success() {
+            let error = clash_api::parse_check_output(output.stdout.clone());
+            let error = match error.len() > 0 {
+                true => error,
+                false => output.stdout.clone(),
+            };
+            Logger::global().set_log(output.stdout);
+            bail!("{error}");
+        }
+
+        Ok(())
+    }
+
+    /// 启动核心
+    pub async fn run_core(&self) -> Result<()> {
+        let config_path = Config::generate_file(ConfigType::Run)?;
+
+        #[allow(unused_mut)]
+        let mut should_kill = match self.sidecar.lock().take() {
+            Some(child) => {
+                log::debug!(target: "app", "stop the core by sidecar");
+                let _ = child.kill();
+                true
+            }
+            None => false,
+        };
+
+        #[cfg(target_os = "windows")]
+        if *self.use_service_mode.lock() {
+            log::debug!(target: "app", "stop the core by service");
+            log_err!(super::win_service::stop_core_by_service().await);
+            should_kill = true;
+        }
+
+        // 这里得等一会儿
+        if should_kill {
+            sleep(Duration::from_millis(500)).await;
+        }
+
+        #[cfg(target_os = "windows")]
+        {
+            use super::win_service;
+
+            // 服务模式
+            let enable = { Config::verge().latest().enable_service_mode.clone() };
+            let enable = enable.unwrap_or(false);
+
+            *self.use_service_mode.lock() = enable;
+
+            if enable {
+                // 服务模式启动失败就直接运行sidecar
+                log::debug!(target: "app", "try to run core in service mode");
+
+                match (|| async {
+                    win_service::check_service().await?;
+                    win_service::run_core_by_service(&config_path).await
+                })()
+                .await
+                {
+                    Ok(_) => return Ok(()),
+                    Err(err) => {
+                        // 修改这个值，免得stop出错
+                        *self.use_service_mode.lock() = false;
+                        log::error!(target: "app", "{err}");
+                    }
+                }
+            }
+        }
+
+        let app_dir = dirs::app_home_dir()?;
+        let app_dir = dirs::path_to_str(&app_dir)?;
+
+        let clash_core = { Config::verge().latest().clash_core.clone() };
+        let clash_core = clash_core.unwrap_or("clash".into());
+        let is_clash = clash_core == "clash";
+
+        let config_path = dirs::path_to_str(&config_path)?;
+
+        // fix #212
+        let args = match clash_core.as_str() {
+            "clash-meta" => vec!["-m", "-d", app_dir, "-f", config_path],
+            _ => vec!["-d", app_dir, "-f", config_path],
+        };
+
+        let cmd = Command::new_sidecar(clash_core)?;
+        let (mut rx, cmd_child) = cmd.args(args).spawn()?;
+
+        // 将pid写入文件中
+        crate::log_err!((|| {
+            let pid = cmd_child.pid();
+            let path = dirs::clash_pid_path()?;
+            fs::File::create(path)
+                .context("failed to create the pid file")?
+                .write(format!("{pid}").as_bytes())
+                .context("failed to write pid to the file")?;
+            <Result<()>>::Ok(())
+        })());
+
+        let mut sidecar = self.sidecar.lock();
+        *sidecar = Some(cmd_child);
+        drop(sidecar);
+
+        tauri::async_runtime::spawn(async move {
+            while let Some(event) = rx.recv().await {
+                match event {
+                    CommandEvent::Stdout(line) => {
+                        if is_clash {
+                            let stdout = clash_api::parse_log(line.clone());
+                            log::info!(target: "app", "[clash]: {stdout}");
+                        } else {
+                            log::info!(target: "app", "[clash]: {line}");
+                        };
+                        Logger::global().set_log(line);
+                    }
+                    CommandEvent::Stderr(err) => {
+                        // let stdout = clash_api::parse_log(err.clone());
+                        log::error!(target: "app", "[clash]: {err}");
+                        Logger::global().set_log(err);
+                    }
+                    CommandEvent::Error(err) => {
+                        log::error!(target: "app", "[clash]: {err}");
+                        Logger::global().set_log(err);
+                    }
+                    CommandEvent::Terminated(_) => {
+                        log::info!(target: "app", "clash core terminated");
+                        let _ = CoreManager::global().recover_core();
+                        break;
+                    }
+                    _ => {}
+                }
+            }
+        });
+
+        Ok(())
+    }
+
+    /// 重启内核
+    pub fn recover_core(&'static self) -> Result<()> {
+        // 服务模式不管
+        #[cfg(target_os = "windows")]
+        if *self.use_service_mode.lock() {
+            return Ok(());
+        }
+
+        // 清空原来的sidecar值
+        if let Some(sidecar) = self.sidecar.lock().take() {
+            let _ = sidecar.kill();
+        }
+
+        tauri::async_runtime::spawn(async move {
+            // 6秒之后再查看服务是否正常 (时间随便搞的)
+            // terminated 可能是切换内核 (切换内核已经有500ms的延迟)
+            sleep(Duration::from_millis(6666)).await;
+
+            if self.sidecar.lock().is_none() {
+                log::info!(target: "app", "recover clash core");
+
+                // 重新启动app
+                if let Err(err) = self.run_core().await {
+                    log::error!(target: "app", "failed to recover clash core");
+                    log::error!(target: "app", "{err}");
+
+                    let _ = self.recover_core();
+                }
+            }
+        });
+
+        Ok(())
+    }
+
+    /// 停止核心运行
+    pub fn stop_core(&self) -> Result<()> {
+        #[cfg(target_os = "windows")]
+        if *self.use_service_mode.lock() {
+            log::debug!(target: "app", "stop the core by service");
+            tauri::async_runtime::block_on(async move {
+                log_err!(super::win_service::stop_core_by_service().await);
+            });
+            return Ok(());
+        }
+
+        let mut sidecar = self.sidecar.lock();
+        if let Some(child) = sidecar.take() {
+            log::debug!(target: "app", "stop the core by sidecar");
+            let _ = child.kill();
+        }
+        Ok(())
+    }
+
+    /// 切换核心
+    pub async fn change_core(&self, clash_core: Option<String>) -> Result<()> {
+        let clash_core = clash_core.ok_or(anyhow::anyhow!("clash core is null"))?;
+
+        if &clash_core != "clash" && &clash_core != "clash-meta" {
+            bail!("invalid clash core name \"{clash_core}\"");
+        }
+
+        log::debug!(target: "app", "change core to `{clash_core}`");
+
+        Config::verge().draft().clash_core = Some(clash_core);
+
+        // 更新配置
+        Config::generate()?;
+
+        self.check_config()?;
+
+        // 清掉旧日志
+        Logger::global().clear_log();
+
+        match self.run_core().await {
+            Ok(_) => {
+                Config::verge().apply();
+                Config::runtime().apply();
+                log_err!(Config::verge().latest().save_file());
+                Ok(())
+            }
+            Err(err) => {
+                Config::verge().discard();
+                Config::runtime().discard();
+                Err(err)
+            }
+        }
+    }
+
+    /// 更新proxies那些
+    /// 如果涉及端口和外部控制则需要重启
+    pub async fn update_config(&self) -> Result<()> {
+        log::debug!(target: "app", "try to update clash config");
+
+        // 更新配置
+        Config::generate()?;
+
+        // 检查配置是否正常
+        self.check_config()?;
+
+        // 更新运行时配置
+        let path = Config::generate_file(ConfigType::Run)?;
+        let path = dirs::path_to_str(&path)?;
+
+        // 发送请求 发送5次
+        for i in 0..5 {
+            match clash_api::put_configs(path).await {
+                Ok(_) => break,
+                Err(err) => {
+                    if i < 4 {
+                        log::info!(target: "app", "{err}");
+                    } else {
+                        bail!(err);
+                    }
+                }
+            }
+            sleep(Duration::from_millis(250)).await;
+        }
+
+        Ok(())
+    }
+}

src-tauri/src/core/handle.rs

@@ -1,66 +1,77 @@
 use super::tray::Tray;
-use crate::log_if_err;
+use crate::log_err;
 use anyhow::{bail, Result};
+use once_cell::sync::OnceCell;
+use parking_lot::Mutex;
+use std::sync::Arc;
 use tauri::{AppHandle, Manager, Window};
 
 #[derive(Debug, Default, Clone)]
 pub struct Handle {
-  pub app_handle: Option<AppHandle>,
+    pub app_handle: Arc<Mutex<Option<AppHandle>>>,
 }
 
 impl Handle {
-  pub fn set_inner(&mut self, app_handle: AppHandle) {
-    self.app_handle = Some(app_handle);
-  }
+    pub fn global() -> &'static Handle {
+        static HANDLE: OnceCell<Handle> = OnceCell::new();
 
-  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"));
+        HANDLE.get_or_init(|| Handle {
+            app_handle: Arc::new(Mutex::new(None)),
+        })
     }
-  }
 
-  pub fn refresh_verge(&self) {
-    if let Some(window) = self.get_window() {
-      log_if_err!(window.emit("verge://refresh-verge-config", "yes"));
+    pub fn init(&self, app_handle: AppHandle) {
+        *self.app_handle.lock() = Some(app_handle);
     }
-  }
 
-  #[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 get_window(&self) -> Option<Window> {
+        self.app_handle
+            .lock()
+            .as_ref()
+            .map_or(None, |a| a.get_window("main"))
     }
-  }
 
-  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)));
+    pub fn refresh_clash() {
+        if let Some(window) = Self::global().get_window() {
+            log_err!(window.emit("verge://refresh-clash-config", "yes"));
+        }
     }
-  }
 
-  pub fn update_systray(&self) -> Result<()> {
-    if self.app_handle.is_none() {
-      bail!("update_systray unhandle error");
+    pub fn refresh_verge() {
+        if let Some(window) = Self::global().get_window() {
+            log_err!(window.emit("verge://refresh-verge-config", "yes"));
+        }
     }
-    let app_handle = self.app_handle.as_ref().unwrap();
-    Tray::update_systray(app_handle)?;
-    Ok(())
-  }
 
-  /// update the system tray state
-  pub fn update_systray_part(&self) -> Result<()> {
-    if self.app_handle.is_none() {
-      bail!("update_systray unhandle error");
+    #[allow(unused)]
+    pub fn refresh_profiles() {
+        if let Some(window) = Self::global().get_window() {
+            log_err!(window.emit("verge://refresh-profiles-config", "yes"));
+        }
+    }
+
+    pub fn notice_message<S: Into<String>, M: Into<String>>(status: S, msg: M) {
+        if let Some(window) = Self::global().get_window() {
+            log_err!(window.emit("verge://notice-message", (status.into(), msg.into())));
+        }
+    }
+
+    pub fn update_systray() -> Result<()> {
+        let app_handle = Self::global().app_handle.lock();
+        if app_handle.is_none() {
+            bail!("update_systray unhandled error");
+        }
+        Tray::update_systray(app_handle.as_ref().unwrap())?;
+        Ok(())
+    }
+
+    /// update the system tray state
+    pub fn update_systray_part() -> Result<()> {
+        let app_handle = Self::global().app_handle.lock();
+        if app_handle.is_none() {
+            bail!("update_systray unhandled error");
+        }
+        Tray::update_part(app_handle.as_ref().unwrap())?;
+        Ok(())
     }
-    let app_handle = self.app_handle.as_ref().unwrap();
-    Tray::update_part(app_handle)?;
-    Ok(())
-  }
 }

src-tauri/src/core/hotkey.rs

@@ -1,153 +1,181 @@
-use crate::{data::*, feat, log_if_err};
+use crate::{config::Config, feat, log_err};
 use anyhow::{bail, Result};
-use std::collections::HashMap;
+use once_cell::sync::OnceCell;
+use parking_lot::Mutex;
+use std::{collections::HashMap, sync::Arc};
 use tauri::{AppHandle, GlobalShortcutManager};
+use wry::application::accelerator::Accelerator;
 
 pub struct Hotkey {
-  current: Vec<String>, // 保存当前的热键设置
-  manager: Option<AppHandle>,
+    current: Arc<Mutex<Vec<String>>>, // 保存当前的热键设置
+
+    app_handle: Arc<Mutex<Option<AppHandle>>>,
 }
 
 impl Hotkey {
-  pub fn new() -> Hotkey {
-    Hotkey {
-      current: Vec::new(),
-      manager: None,
+    pub fn global() -> &'static Hotkey {
+        static HOTKEY: OnceCell<Hotkey> = OnceCell::new();
+
+        HOTKEY.get_or_init(|| Hotkey {
+            current: Arc::new(Mutex::new(Vec::new())),
+            app_handle: Arc::new(Mutex::new(None)),
+        })
     }
-  }
 
-  pub fn init(&mut self, app_handle: AppHandle) -> Result<()> {
-    self.manager = Some(app_handle);
-    let data = Data::global();
-    let verge = data.verge.lock();
+    pub fn init(&self, app_handle: AppHandle) -> Result<()> {
+        *self.app_handle.lock() = Some(app_handle);
 
-    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();
+        let verge = Config::verge();
 
-        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"));
+        if let Some(hotkeys) = verge.latest().hotkeys.as_ref() {
+            for hotkey in hotkeys.iter() {
+                let mut iter = hotkey.split(',');
+                let func = iter.next();
+                let key = iter.next();
+
+                match (key, func) {
+                    (Some(key), Some(func)) => {
+                        log_err!(Self::check_key(key).and_then(|_| self.register(key, func)));
+                    }
+                    _ => {
+                        let key = key.unwrap_or("None");
+                        let func = func.unwrap_or("None");
+                        log::error!(target: "app", "invalid hotkey `{key}`:`{func}`");
+                    }
+                }
+            }
+            *self.current.lock() = hotkeys.clone();
         }
-      }
-      self.current = hotkeys.clone();
+
+        Ok(())
     }
 
-    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));
-          }
+    /// 检查一个键是否合法
+    fn check_key(hotkey: &str) -> Result<()> {
+        // fix #287
+        // tauri的这几个方法全部有Result expect，会panic，先检测一遍避免挂了
+        if hotkey.parse::<Accelerator>().is_err() {
+            bail!("invalid hotkey `{hotkey}`");
         }
-        None => del_list.push(key),
-      };
-    });
+        Ok(())
+    }
 
-    new_map.iter().for_each(|(&key, &func)| {
-      if old_map.get(key).is_none() {
-        add_list.push((key, func));
-      }
-    });
+    fn get_manager(&self) -> Result<impl GlobalShortcutManager> {
+        let app_handle = self.app_handle.lock();
+        if app_handle.is_none() {
+            bail!("failed to get the hotkey manager");
+        }
+        Ok(app_handle.as_ref().unwrap().global_shortcut_manager())
+    }
 
-    (del_list, add_list)
-  }
+    fn register(&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() {
+            "open_dashboard" => || feat::open_dashboard(),
+            "clash_mode_rule" => || feat::change_clash_mode("rule".into()),
+            "clash_mode_global" => || feat::change_clash_mode("global".into()),
+            "clash_mode_direct" => || feat::change_clash_mode("direct".into()),
+            "clash_mode_script" => || feat::change_clash_mode("script".into()),
+            "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(&self, hotkey: &str) -> Result<()> {
+        self.get_manager()?.unregister(&hotkey)?;
+        log::info!(target: "app", "unregister hotkey {hotkey}");
+        Ok(())
+    }
+
+    pub fn update(&self, new_hotkeys: Vec<String>) -> Result<()> {
+        let mut current = self.current.lock();
+        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);
+
+        // 先检查一遍所有新的热键是不是可以用的
+        for (hotkey, _) in add.iter() {
+            Self::check_key(hotkey)?;
+        }
+
+        del.iter().for_each(|key| {
+            let _ = self.unregister(key);
+        });
+
+        add.iter().for_each(|(key, func)| {
+            log_err!(self.register(key, func));
+        });
+
+        *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();
+    fn drop(&mut self) {
+        if let Ok(mut manager) = self.get_manager() {
+            let _ = manager.unregister_all();
+        }
     }
-  }
 }

src-tauri/src/core/logger.rs

@@ -0,0 +1,36 @@
+use once_cell::sync::OnceCell;
+use parking_lot::Mutex;
+use std::{collections::VecDeque, sync::Arc};
+
+const LOGS_QUEUE_LEN: usize = 100;
+
+pub struct Logger {
+    log_data: Arc<Mutex<VecDeque<String>>>,
+}
+
+impl Logger {
+    pub fn global() -> &'static Logger {
+        static LOGGER: OnceCell<Logger> = OnceCell::new();
+
+        LOGGER.get_or_init(|| Logger {
+            log_data: Arc::new(Mutex::new(VecDeque::with_capacity(LOGS_QUEUE_LEN + 10))),
+        })
+    }
+
+    pub fn get_log(&self) -> VecDeque<String> {
+        self.log_data.lock().clone()
+    }
+
+    pub fn set_log(&self, text: String) {
+        let mut logs = self.log_data.lock();
+        if logs.len() > LOGS_QUEUE_LEN {
+            logs.pop_front();
+        }
+        logs.push_back(text);
+    }
+
+    pub fn clear_log(&self) {
+        let mut logs = self.log_data.lock();
+        logs.clear();
+    }
+}

src-tauri/src/core/manager.rs

@@ -0,0 +1,82 @@
+use std::borrow::Cow;
+
+/// 给clash内核的tun模式授权
+#[cfg(any(target_os = "macos", target_os = "linux"))]
+pub fn grant_permission(core: String) -> anyhow::Result<()> {
+    use std::process::Command;
+    use tauri::utils::platform::current_exe;
+
+    let path = current_exe()?.with_file_name(core).canonicalize()?;
+    let path = path.display().to_string();
+
+    log::debug!("grant_permission path: {path}");
+
+    #[cfg(target_os = "macos")]
+    let output = {
+        // the path of clash /Applications/Clash Verge.app/Contents/MacOS/clash
+        // https://apple.stackexchange.com/questions/82967/problem-with-empty-spaces-when-executing-shell-commands-in-applescript
+        // let path = escape(&path);
+        let path = path.replace(' ', "\\\\ ");
+        let shell = format!("chown root:admin {path}\nchmod +sx {path}");
+        let command = format!(r#"do shell script "{shell}" with administrator privileges"#);
+        Command::new("osascript")
+            .args(vec!["-e", &command])
+            .output()?
+    };
+
+    #[cfg(target_os = "linux")]
+    let output = {
+        let path = path.replace(' ', "\\ "); // 避免路径中有空格
+        let shell = format!("setcap cap_net_bind_service,cap_net_admin=+ep {path}");
+
+        let sudo = match Command::new("which").arg("pkexec").output() {
+            Ok(output) => {
+                if output.stdout.is_empty() {
+                    "sudo"
+                } else {
+                    "pkexec"
+                }
+            }
+            Err(_) => "sudo",
+        };
+
+        Command::new(sudo).arg("sh").arg("-c").arg(shell).output()?
+    };
+
+    if output.status.success() {
+        Ok(())
+    } else {
+        let stderr = std::str::from_utf8(&output.stderr).unwrap_or("");
+        anyhow::bail!("{stderr}");
+    }
+}
+
+#[allow(unused)]
+pub fn escape<'a>(text: &'a str) -> Cow<'a, str> {
+    let bytes = text.as_bytes();
+
+    let mut owned = None;
+
+    for pos in 0..bytes.len() {
+        let special = match bytes[pos] {
+            b' ' => Some(b' '),
+            _ => None,
+        };
+        if let Some(s) = special {
+            if owned.is_none() {
+                owned = Some(bytes[0..pos].to_owned());
+            }
+            owned.as_mut().unwrap().push(b'\\');
+            owned.as_mut().unwrap().push(b'\\');
+            owned.as_mut().unwrap().push(s);
+        } else if let Some(owned) = owned.as_mut() {
+            owned.push(bytes[pos]);
+        }
+    }
+
+    if let Some(owned) = owned {
+        unsafe { Cow::Owned(String::from_utf8_unchecked(owned)) }
+    } else {
+        unsafe { Cow::Borrowed(std::str::from_utf8_unchecked(bytes)) }
+    }
+}

src-tauri/src/core/mod.rs

@@ -1,346 +1,12 @@
-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::OnceCell;
-use parking_lot::Mutex;
-use serde_yaml::{Mapping, Value};
-use std::sync::Arc;
-
-mod handle;
-mod hotkey;
-mod service;
-mod sysopt;
-mod timer;
+pub mod clash_api;
+mod core;
+pub mod handle;
+pub mod hotkey;
+pub mod logger;
+pub mod manager;
+pub mod sysopt;
+pub mod timer;
 pub mod tray;
+pub mod win_service;
 
-pub use self::service::*;
-
-#[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() -> &'static Core {
-    static CORE: OnceCell<Core> = OnceCell::new();
-
-    CORE.get_or_init(|| 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())),
-    })
-  }
-
-  /// 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_part());
-    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_part()?;
-    }
-
-    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;
-    let language = patch.language;
-
-    #[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();
-    }
-
-    // 更新tray
-    if language.is_some() {
-      let handle = self.handle.lock();
-      handle.update_systray()?;
-    } else if system_proxy.is_some() || tun_mode.is_some() {
-      let handle = self.handle.lock();
-      handle.update_systray_part()?;
-    }
-
-    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_part());
-    });
-
-    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(())
-  }
-}
+pub use self::core::*;

src-tauri/src/core/service.rs

@@ -1,535 +0,0 @@
-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>>>,
-
-  #[allow(unused)]
-  use_service_mode: bool,
-}
-
-impl Service {
-  pub fn new() -> Service {
-    let queue = VecDeque::with_capacity(LOGS_QUEUE_LEN + 10);
-
-    Service {
-      sidecar: None,
-      logs: Arc::new(RwLock::new(queue)),
-      use_service_mode: false,
-    }
-  }
-
-  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)
-      };
-
-      self.use_service_mode = enable;
-
-      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();
-
-      if self.use_service_mode {
-        tauri::async_runtime::block_on(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);
-          }
-          CommandEvent::Error(err) => log::error!(target: "app" ,"{err}"),
-          CommandEvent::Terminated(_) => break,
-          _ => {}
-        }
-      }
-    });
-
-    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

@@ -1,285 +1,304 @@
-use crate::{data::*, log_if_err};
-use anyhow::{anyhow, bail, Result};
+use crate::{config::Config, log_err};
+use anyhow::{anyhow, Result};
 use auto_launch::{AutoLaunch, AutoLaunchBuilder};
+use once_cell::sync::OnceCell;
+use parking_lot::Mutex;
 use std::sync::Arc;
 use sysproxy::Sysproxy;
-use tauri::{async_runtime::Mutex, utils::platform::current_exe};
+use tauri::{async_runtime::Mutex as TokioMutex, utils::platform::current_exe};
 
 pub struct Sysopt {
-  /// current system proxy setting
-  cur_sysproxy: Option<Sysproxy>,
+    /// current system proxy setting
+    cur_sysproxy: Arc<Mutex<Option<Sysproxy>>>,
 
-  /// record the original system proxy
-  /// recover it when exit
-  old_sysproxy: Option<Sysproxy>,
+    /// record the original system proxy
+    /// recover it when exit
+    old_sysproxy: Arc<Mutex<Option<Sysproxy>>>,
 
-  /// helps to auto launch the app
-  auto_launch: Option<AutoLaunch>,
+    /// helps to auto launch the app
+    auto_launch: Arc<Mutex<Option<AutoLaunch>>>,
 
-  /// record whether the guard async is running or not
-  guard_state: Arc<Mutex<bool>>,
+    /// record whether the guard async is running or not
+    guard_state: Arc<TokioMutex<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";
+static DEFAULT_BYPASS: &str = "localhost,127.0.0.1,::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)),
-    }
-  }
+    pub fn global() -> &'static Sysopt {
+        static SYSOPT: OnceCell<Sysopt> = OnceCell::new();
 
-  /// 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");
+        SYSOPT.get_or_init(|| Sysopt {
+            cur_sysproxy: Arc::new(Mutex::new(None)),
+            old_sysproxy: Arc::new(Mutex::new(None)),
+            auto_launch: Arc::new(Mutex::new(None)),
+            guard_state: Arc::new(TokioMutex::new(false)),
+        })
     }
 
-    let verge = data.verge.lock();
+    /// init the sysproxy
+    pub fn init_sysproxy(&self) -> Result<()> {
+        let port = { Config::clash().latest().get_mixed_port() };
 
-    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 (enable, bypass) = {
+            let verge = Config::verge();
+            let verge = verge.latest();
+            (
+                verge.enable_system_proxy.clone().unwrap_or(false),
+                verge.system_proxy_bypass.clone(),
+            )
+        };
 
-    let port = port.unwrap().parse::<u16>()?;
-    let host = String::from("127.0.0.1");
+        let current = Sysproxy {
+            enable,
+            host: String::from("127.0.0.1"),
+            port,
+            bypass: bypass.unwrap_or(DEFAULT_BYPASS.into()),
+        };
 
-    self.cur_sysproxy = Some(Sysproxy {
-      enable,
-      host,
-      port,
-      bypass,
-    });
+        if enable {
+            let old = Sysproxy::get_system_proxy().map_or(None, |p| Some(p));
+            current.set_system_proxy()?;
 
-    if enable {
-      self.old_sysproxy = Sysproxy::get_system_proxy().map_or(None, |p| Some(p));
-      self.cur_sysproxy.as_ref().unwrap().set_system_proxy()?;
-    }
-
-    // run 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() || self.old_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<()> {
-    let cur = self.cur_sysproxy.take();
-
-    if let Some(mut old) = self.old_sysproxy.take() {
-      // 如果原代理和当前代理 端口一致，就disable关闭，否则就恢复原代理设置
-      // 当前没有设置代理的时候，不确定旧设置是否和当前一致，全关了
-      let port_same = cur.map_or(true, |cur| old.port == cur.port);
-
-      if old.enable && port_same {
-        old.enable = false;
-        log::info!(target: "app", "reset proxy by disabling the original proxy");
-      } else {
-        log::info!(target: "app", "reset proxy to the original proxy");
-      }
-
-      old.set_system_proxy()?;
-    } else if let Some(mut cur @ Sysproxy { enable: true, .. }) = cur {
-      // 没有原代理，就按现在的代理设置disable即可
-      log::info!(target: "app", "reset proxy by disabling the current proxy");
-      cur.enable = false;
-      cur.set_system_proxy()?;
-    } else {
-      log::info!(target: "app", "reset proxy with no action");
-    }
-
-    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;
+            *self.old_sysproxy.lock() = old;
+            *self.cur_sysproxy.lock() = Some(current);
         }
 
-        // update duration
-        wait_secs = guard_duration;
+        // run the system proxy guard
+        self.guard_proxy();
+        Ok(())
+    }
 
-        let clash = global.clash.lock();
-        let port = clash.info.port.clone();
-        let port = port.unwrap_or("".into()).parse::<u16>();
-        drop(clash);
+    /// update the system proxy
+    pub fn update_sysproxy(&self) -> Result<()> {
+        let mut cur_sysproxy = self.cur_sysproxy.lock();
+        let old_sysproxy = self.old_sysproxy.lock();
 
-        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"),
+        if cur_sysproxy.is_none() || old_sysproxy.is_none() {
+            drop(cur_sysproxy);
+            drop(old_sysproxy);
+            return self.init_sysproxy();
         }
-      }
 
-      let mut state = guard_state.lock().await;
-      *state = false;
-    });
-  }
+        let (enable, bypass) = {
+            let verge = Config::verge();
+            let verge = verge.latest();
+            (
+                verge.enable_system_proxy.clone().unwrap_or(false),
+                verge.system_proxy_bypass.clone(),
+            )
+        };
+        let mut sysproxy = cur_sysproxy.take().unwrap();
+
+        sysproxy.enable = enable;
+        sysproxy.bypass = bypass.unwrap_or(DEFAULT_BYPASS.into());
+
+        sysproxy.set_system_proxy()?;
+        *cur_sysproxy = Some(sysproxy);
+
+        Ok(())
+    }
+
+    /// reset the sysproxy
+    pub fn reset_sysproxy(&self) -> Result<()> {
+        let mut cur_sysproxy = self.cur_sysproxy.lock();
+        let mut old_sysproxy = self.old_sysproxy.lock();
+
+        let cur_sysproxy = cur_sysproxy.take();
+
+        if let Some(mut old) = old_sysproxy.take() {
+            // 如果原代理和当前代理 端口一致，就disable关闭，否则就恢复原代理设置
+            // 当前没有设置代理的时候，不确定旧设置是否和当前一致，全关了
+            let port_same = cur_sysproxy.map_or(true, |cur| old.port == cur.port);
+
+            if old.enable && port_same {
+                old.enable = false;
+                log::info!(target: "app", "reset proxy by disabling the original proxy");
+            } else {
+                log::info!(target: "app", "reset proxy to the original proxy");
+            }
+
+            old.set_system_proxy()?;
+        } else if let Some(mut cur @ Sysproxy { enable: true, .. }) = cur_sysproxy {
+            // 没有原代理，就按现在的代理设置disable即可
+            log::info!(target: "app", "reset proxy by disabling the current proxy");
+            cur.enable = false;
+            cur.set_system_proxy()?;
+        } else {
+            log::info!(target: "app", "reset proxy with no action");
+        }
+
+        Ok(())
+    }
+
+    /// init the auto launch
+    pub fn init_launch(&self) -> Result<()> {
+        let enable = { Config::verge().latest().enable_auto_launch.clone() };
+        let enable = enable.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);
+
+        // fix #403
+        #[cfg(target_os = "linux")]
+        let app_path = {
+            use crate::core::handle::Handle;
+            use tauri::Manager;
+
+            let handle = Handle::global();
+            match handle.app_handle.lock().as_ref() {
+                Some(app_handle) => {
+                    let appimage = app_handle.env().appimage;
+                    appimage
+                        .and_then(|p| p.to_str().map(|s| s.to_string()))
+                        .unwrap_or(app_path)
+                }
+                None => app_path,
+            }
+        };
+
+        let auto = AutoLaunchBuilder::new()
+            .set_app_name(app_name)
+            .set_app_path(&app_path)
+            .build()?;
+
+        // 避免在开发时将自启动关了
+        #[cfg(feature = "verge-dev")]
+        if !enable {
+            return Ok(());
+        }
+
+        #[cfg(target_os = "macos")]
+        {
+            if enable && !auto.is_enabled().unwrap_or(false) {
+                // 避免重复设置登录项
+                let _ = auto.disable();
+                auto.enable()?;
+            } else if !enable {
+                let _ = auto.disable();
+            }
+        }
+
+        #[cfg(not(target_os = "macos"))]
+        if enable {
+            auto.enable()?;
+        }
+
+        *self.auto_launch.lock() = Some(auto);
+
+        Ok(())
+    }
+
+    /// update the startup
+    pub fn update_launch(&self) -> Result<()> {
+        let auto_launch = self.auto_launch.lock();
+
+        if auto_launch.is_none() {
+            drop(auto_launch);
+            return self.init_launch();
+        }
+        let enable = { Config::verge().latest().enable_auto_launch.clone() };
+        let enable = enable.unwrap_or(false);
+        let auto_launch = auto_launch.as_ref().unwrap();
+
+        match enable {
+            true => auto_launch.enable()?,
+            false => log_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 (enable, guard, guard_duration, bypass) = {
+                    let verge = Config::verge();
+                    let verge = verge.latest();
+                    (
+                        verge.enable_system_proxy.clone().unwrap_or(false),
+                        verge.enable_proxy_guard.clone().unwrap_or(false),
+                        verge.proxy_guard_duration.clone().unwrap_or(10),
+                        verge.system_proxy_bypass.clone(),
+                    )
+                };
+
+                // stop loop
+                if !enable || !guard {
+                    break;
+                }
+
+                // update duration
+                wait_secs = guard_duration;
+
+                log::debug!(target: "app", "try to guard the system proxy");
+
+                let port = { Config::clash().latest().get_mixed_port() };
+
+                let sysproxy = Sysproxy {
+                    enable: true,
+                    host: "127.0.0.1".into(),
+                    port,
+                    bypass: bypass.unwrap_or(DEFAULT_BYPASS.into()),
+                };
+
+                log_err!(sysproxy.set_system_proxy());
+            }
+
+            let mut state = guard_state.lock().await;
+            *state = false;
+            drop(state);
+        });
+    }
 }

src-tauri/src/core/timer.rs

@@ -1,172 +1,184 @@
-use super::Core;
-use crate::utils::help::get_now;
-use crate::{data::Data, log_if_err};
+use crate::config::Config;
+use crate::feat;
 use anyhow::{Context, Result};
 use delay_timer::prelude::{DelayTimer, DelayTimerBuilder, TaskBuilder};
+use once_cell::sync::OnceCell;
+use parking_lot::Mutex;
 use std::collections::HashMap;
+use std::sync::Arc;
 
 type TaskID = u64;
 
 pub struct Timer {
-  /// cron manager
-  delay_timer: DelayTimer,
+    /// cron manager
+    delay_timer: Arc<Mutex<DelayTimer>>,
 
-  /// save the current state
-  timer_map: HashMap<String, (TaskID, u64)>,
+    /// save the current state
+    timer_map: Arc<Mutex<HashMap<String, (TaskID, u64)>>>,
 
-  /// increment id
-  timer_count: TaskID,
+    /// increment id
+    timer_count: Arc<Mutex<TaskID>>,
 }
 
 impl Timer {
-  pub fn new() -> Self {
-    Timer {
-      delay_timer: DelayTimerBuilder::default().build(),
-      timer_map: HashMap::new(),
-      timer_count: 1,
-    }
-  }
+    pub fn global() -> &'static Timer {
+        static TIMER: OnceCell<Timer> = OnceCell::new();
 
-  /// 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));
-        }
-      }
+        TIMER.get_or_init(|| Timer {
+            delay_timer: Arc::new(Mutex::new(DelayTimerBuilder::default().build())),
+            timer_map: Arc::new(Mutex::new(HashMap::new())),
+            timer_count: Arc::new(Mutex::new(1)),
+        })
     }
 
-    Ok(())
-  }
+    /// restore timer
+    pub fn init(&self) -> Result<()> {
+        self.refresh()?;
 
-  /// restore timer
-  pub fn restore(&mut self) -> Result<()> {
-    self.refresh()?;
+        let cur_timestamp = chrono::Local::now().timestamp();
 
-    let cur_timestamp = get_now(); // seconds
+        let timer_map = self.timer_map.lock();
+        let delay_timer = self.delay_timer.lock();
 
-    let global = Data::global();
-    let profiles = global.profiles.lock();
+        Config::profiles().latest().get_items().map(|items| {
+            items
+                .iter()
+                .filter_map(|item| {
+                    // mins to seconds
+                    let interval = ((item.option.as_ref()?.update_interval?) as i64) * 60;
+                    let updated = item.updated? as i64;
 
-    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));
-        }
-      });
+                    if interval > 0 && cur_timestamp - updated >= interval {
+                        Some(item)
+                    } else {
+                        None
+                    }
+                })
+                .for_each(|item| {
+                    if let Some(uid) = item.uid.as_ref() {
+                        if let Some((task_id, _)) = timer_map.get(uid) {
+                            crate::log_err!(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);
-          }
-        }
-      }
+        Ok(())
     }
 
-    new_map
-  }
+    /// Correctly update all cron tasks
+    pub fn refresh(&self) -> Result<()> {
+        let diff_map = self.gen_diff();
 
-  /// generate the diff map for refresh
-  fn gen_diff(&mut self) -> HashMap<String, DiffFlag> {
-    let mut diff_map = HashMap::new();
+        let mut timer_map = self.timer_map.lock();
+        let mut delay_timer = self.delay_timer.lock();
 
-    let new_map = self.gen_map();
-    let cur_map = &self.timer_map;
+        for (uid, diff) in diff_map.into_iter() {
+            match diff {
+                DiffFlag::Del(tid) => {
+                    let _ = timer_map.remove(&uid);
+                    crate::log_err!(delay_timer.remove_task(tid));
+                }
+                DiffFlag::Add(tid, val) => {
+                    let _ = timer_map.insert(uid.clone(), (tid, val));
+                    crate::log_err!(self.add_task(&mut delay_timer, uid, tid, val));
+                }
+                DiffFlag::Mod(tid, val) => {
+                    let _ = timer_map.insert(uid.clone(), (tid, val));
+                    crate::log_err!(delay_timer.remove_task(tid));
+                    crate::log_err!(self.add_task(&mut delay_timer, uid, tid, val));
+                }
+            }
+        }
 
-    cur_map.iter().for_each(|(uid, (tid, val))| {
-      let new_val = new_map.get(uid).unwrap_or(&0);
+        Ok(())
+    }
 
-      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));
-      }
-    });
+    /// generate a uid -> update_interval map
+    fn gen_map(&self) -> HashMap<String, u64> {
+        let mut new_map = HashMap::new();
 
-    let mut count = self.timer_count;
+        if let Some(items) = Config::profiles().latest().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);
 
-    new_map.iter().for_each(|(uid, val)| {
-      if cur_map.get(uid).is_none() {
-        diff_map.insert(uid.clone(), DiffFlag::Add(count, *val));
+                    if interval > 0 {
+                        new_map.insert(item.uid.clone().unwrap(), interval);
+                    }
+                }
+            }
+        }
 
-        count += 1;
-      }
-    });
+        new_map
+    }
 
-    self.timer_count = count;
+    /// generate the diff map for refresh
+    fn gen_diff(&self) -> HashMap<String, DiffFlag> {
+        let mut diff_map = HashMap::new();
 
-    diff_map
-  }
+        let timer_map = self.timer_map.lock();
 
-  /// add a cron task
-  fn add_task(&self, uid: String, tid: TaskID, minutes: u64) -> Result<()> {
-    let core = Core::global();
+        let new_map = self.gen_map();
+        let cur_map = &timer_map;
 
-    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")?;
+        cur_map.iter().for_each(|(uid, (tid, val))| {
+            let new_val = new_map.get(uid).unwrap_or(&0);
 
-    self
-      .delay_timer
-      .add_task(task)
-      .context("failed to add timer task")?;
+            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));
+            }
+        });
 
-    Ok(())
-  }
+        let mut count = self.timer_count.lock();
 
-  /// 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);
-  }
+        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;
+            }
+        });
+
+        diff_map
+    }
+
+    /// add a cron task
+    fn add_task(
+        &self,
+        delay_timer: &mut DelayTimer,
+        uid: String,
+        tid: TaskID,
+        minutes: u64,
+    ) -> Result<()> {
+        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(uid.to_owned()))
+            .context("failed to create timer task")?;
+
+        delay_timer
+            .add_task(task)
+            .context("failed to add timer task")?;
+
+        Ok(())
+    }
+
+    /// the task runner
+    async fn async_task(uid: String) {
+        log::info!(target: "app", "running timer task `{uid}`");
+        crate::log_err!(feat::update_profile(uid, None).await);
+    }
 }
 
 #[derive(Debug)]
 enum DiffFlag {
-  Del(TaskID),
-  Add(TaskID, u64),
-  Mod(TaskID, u64),
+    Del(TaskID),
+    Add(TaskID, u64),
+    Mod(TaskID, u64),
 }

src-tauri/src/core/tray.rs

@@ -1,124 +1,175 @@
-use crate::{data::Data, feat, utils::resolve};
-use anyhow::{Ok, Result};
+use crate::{cmds, config::Config, feat, utils::resolve};
+use anyhow::Result;
 use tauri::{
-  api, AppHandle, CustomMenuItem, Manager, SystemTrayEvent, SystemTrayMenu, SystemTrayMenuItem,
-  SystemTraySubmenu,
+    api, AppHandle, CustomMenuItem, Manager, SystemTrayEvent, SystemTrayMenu, SystemTrayMenuItem,
+    SystemTraySubmenu,
 };
 
 pub struct Tray {}
 
 impl Tray {
-  pub fn tray_menu(app_handle: &AppHandle) -> SystemTrayMenu {
-    let data = Data::global();
-    let zh = {
-      let verge = data.verge.lock();
-      verge.language == Some("zh".into())
-    };
+    pub fn tray_menu(app_handle: &AppHandle) -> SystemTrayMenu {
+        let zh = { Config::verge().latest().language == Some("zh".into()) };
 
-    let version = app_handle.package_info().version.to_string();
+        let version = app_handle.package_info().version.to_string();
 
-    if zh {
-      SystemTrayMenu::new()
-        .add_item(CustomMenuItem::new("open_window", "打开面板"))
-        .add_native_item(SystemTrayMenuItem::Separator)
-        .add_item(CustomMenuItem::new("rule_mode", "规则模式"))
-        .add_item(CustomMenuItem::new("global_mode", "全局模式"))
-        .add_item(CustomMenuItem::new("direct_mode", "直连模式"))
-        .add_item(CustomMenuItem::new("script_mode", "脚本模式"))
-        .add_native_item(SystemTrayMenuItem::Separator)
-        .add_item(CustomMenuItem::new("system_proxy", "系统代理"))
-        .add_item(CustomMenuItem::new("tun_mode", "TUN 模式"))
-        .add_submenu(SystemTraySubmenu::new(
-          "更多",
-          SystemTrayMenu::new()
-            .add_item(CustomMenuItem::new("restart_clash", "重启 Clash"))
-            .add_item(CustomMenuItem::new("restart_app", "重启应用"))
-            .add_item(CustomMenuItem::new("app_version", format!("Version {version}")).disabled()),
-        ))
-        .add_native_item(SystemTrayMenuItem::Separator)
-        .add_item(CustomMenuItem::new("quit", "退出").accelerator("CmdOrControl+Q"))
-    } else {
-      SystemTrayMenu::new()
-        .add_item(CustomMenuItem::new("open_window", "Dashboard"))
-        .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_submenu(SystemTraySubmenu::new(
-          "More",
-          SystemTrayMenu::new()
-            .add_item(CustomMenuItem::new("restart_clash", "Restart Clash"))
-            .add_item(CustomMenuItem::new("restart_app", "Restart App"))
-            .add_item(CustomMenuItem::new("app_version", format!("Version {version}")).disabled()),
-        ))
-        .add_native_item(SystemTrayMenuItem::Separator)
-        .add_item(CustomMenuItem::new("quit", "Quit").accelerator("CmdOrControl+Q"))
-    }
-  }
-
-  pub fn update_systray(app_handle: &AppHandle) -> Result<()> {
-    app_handle
-      .tray_handle()
-      .set_menu(Tray::tray_menu(app_handle))?;
-    Tray::update_part(app_handle)?;
-    Ok(())
-  }
-
-  pub fn update_part(app_handle: &AppHandle) -> Result<()> {
-    let global = Data::global();
-    let clash = global.clash.lock();
-    let mode = clash
-      .config
-      .get(&serde_yaml::Value::from("mode"))
-      .map(|val| val.as_str().unwrap_or("rule"))
-      .unwrap_or("rule");
-
-    let tray = app_handle.tray_handle();
-
-    let _ = tray.get_item("rule_mode").set_selected(mode == "rule");
-    let _ = tray.get_item("global_mode").set_selected(mode == "global");
-    let _ = tray.get_item("direct_mode").set_selected(mode == "direct");
-    let _ = tray.get_item("script_mode").set_selected(mode == "script");
-
-    let verge = global.verge.lock();
-    let system_proxy = verge.enable_system_proxy.as_ref().unwrap_or(&false);
-    let tun_mode = verge.enable_tun_mode.as_ref().unwrap_or(&false);
-
-    let _ = tray.get_item("system_proxy").set_selected(*system_proxy);
-    let _ = tray.get_item("tun_mode").set_selected(*tun_mode);
-
-    Ok(())
-  }
-
-  pub fn on_system_tray_event(app_handle: &AppHandle, event: SystemTrayEvent) {
-    match event {
-      SystemTrayEvent::MenuItemClick { id, .. } => match id.as_str() {
-        mode @ ("rule_mode" | "global_mode" | "direct_mode" | "script_mode") => {
-          let mode = &mode[0..mode.len() - 5];
-          feat::change_clash_mode(mode);
+        macro_rules! t {
+            ($en: expr, $zh: expr) => {
+                if zh {
+                    $zh
+                } else {
+                    $en
+                }
+            };
         }
 
-        "open_window" => resolve::create_window(app_handle),
-        "system_proxy" => feat::toggle_system_proxy(),
-        "tun_mode" => feat::toggle_tun_mode(),
-        "restart_clash" => feat::restart_clash_core(),
-        "restart_app" => api::process::restart(&app_handle.env()),
-        "quit" => {
-          resolve::resolve_reset();
-          api::process::kill_children();
-          app_handle.exit(0);
-        }
-        _ => {}
-      },
-      #[cfg(target_os = "windows")]
-      SystemTrayEvent::LeftClick { .. } => {
-        resolve::create_window(app_handle);
-      }
-      _ => {}
+        SystemTrayMenu::new()
+            .add_item(CustomMenuItem::new(
+                "open_window",
+                t!("Dashboard", "打开面板"),
+            ))
+            .add_native_item(SystemTrayMenuItem::Separator)
+            .add_item(CustomMenuItem::new(
+                "rule_mode",
+                t!("Rule Mode", "规则模式"),
+            ))
+            .add_item(CustomMenuItem::new(
+                "global_mode",
+                t!("Global Mode", "全局模式"),
+            ))
+            .add_item(CustomMenuItem::new(
+                "direct_mode",
+                t!("Direct Mode", "直连模式"),
+            ))
+            .add_item(CustomMenuItem::new(
+                "script_mode",
+                t!("Script Mode", "脚本模式"),
+            ))
+            .add_native_item(SystemTrayMenuItem::Separator)
+            .add_item(CustomMenuItem::new(
+                "system_proxy",
+                t!("System Proxy", "系统代理"),
+            ))
+            .add_item(CustomMenuItem::new("tun_mode", t!("TUN Mode", "Tun 模式")))
+            .add_item(CustomMenuItem::new(
+                "copy_env",
+                t!("Copy Env", "复制环境变量"),
+            ))
+            .add_submenu(SystemTraySubmenu::new(
+                t!("Open Dir", "打开目录"),
+                SystemTrayMenu::new()
+                    .add_item(CustomMenuItem::new(
+                        "open_app_dir",
+                        t!("App Dir", "应用目录"),
+                    ))
+                    .add_item(CustomMenuItem::new(
+                        "open_core_dir",
+                        t!("Core Dir", "内核目录"),
+                    ))
+                    .add_item(CustomMenuItem::new(
+                        "open_logs_dir",
+                        t!("Logs Dir", "日志目录"),
+                    )),
+            ))
+            .add_submenu(SystemTraySubmenu::new(
+                t!("More", "更多"),
+                SystemTrayMenu::new()
+                    .add_item(CustomMenuItem::new(
+                        "restart_clash",
+                        t!("Restart Clash", "重启 Clash"),
+                    ))
+                    .add_item(CustomMenuItem::new(
+                        "restart_app",
+                        t!("Restart App", "重启应用"),
+                    ))
+                    .add_item(
+                        CustomMenuItem::new("app_version", format!("Version {version}")).disabled(),
+                    ),
+            ))
+            .add_native_item(SystemTrayMenuItem::Separator)
+            .add_item(CustomMenuItem::new("quit", t!("Quit", "退出")).accelerator("CmdOrControl+Q"))
+    }
+
+    pub fn update_systray(app_handle: &AppHandle) -> Result<()> {
+        app_handle
+            .tray_handle()
+            .set_menu(Tray::tray_menu(app_handle))?;
+        Tray::update_part(app_handle)?;
+        Ok(())
+    }
+
+    pub fn update_part(app_handle: &AppHandle) -> Result<()> {
+        let mode = {
+            Config::clash()
+                .latest()
+                .0
+                .get("mode")
+                .map(|val| val.as_str().unwrap_or("rule"))
+                .unwrap_or("rule")
+                .to_owned()
+        };
+
+        let tray = app_handle.tray_handle();
+
+        let _ = tray.get_item("rule_mode").set_selected(mode == "rule");
+        let _ = tray.get_item("global_mode").set_selected(mode == "global");
+        let _ = tray.get_item("direct_mode").set_selected(mode == "direct");
+        let _ = tray.get_item("script_mode").set_selected(mode == "script");
+
+        let verge = Config::verge();
+        let verge = verge.latest();
+        let system_proxy = verge.enable_system_proxy.as_ref().unwrap_or(&false);
+        let tun_mode = verge.enable_tun_mode.as_ref().unwrap_or(&false);
+
+        #[cfg(target_os = "windows")]
+        {
+            let indication_icon = if *system_proxy {
+                include_bytes!("../../icons/win-tray-icon-activated.png").to_vec()
+            } else {
+                include_bytes!("../../icons/win-tray-icon.png").to_vec()
+            };
+
+            let _ = tray.set_icon(tauri::Icon::Raw(indication_icon));
+        }
+
+        let _ = tray.get_item("system_proxy").set_selected(*system_proxy);
+        let _ = tray.get_item("tun_mode").set_selected(*tun_mode);
+
+        Ok(())
+    }
+
+    pub fn on_system_tray_event(app_handle: &AppHandle, event: SystemTrayEvent) {
+        match event {
+            SystemTrayEvent::MenuItemClick { id, .. } => match id.as_str() {
+                mode @ ("rule_mode" | "global_mode" | "direct_mode" | "script_mode") => {
+                    let mode = &mode[0..mode.len() - 5];
+                    feat::change_clash_mode(mode.into());
+                }
+
+                "open_window" => resolve::create_window(app_handle),
+                "system_proxy" => feat::toggle_system_proxy(),
+                "tun_mode" => feat::toggle_tun_mode(),
+                "copy_env" => feat::copy_clash_env(),
+                "open_app_dir" => crate::log_err!(cmds::open_app_dir()),
+                "open_core_dir" => crate::log_err!(cmds::open_core_dir()),
+                "open_logs_dir" => crate::log_err!(cmds::open_logs_dir()),
+                "restart_clash" => feat::restart_clash_core(),
+                "restart_app" => api::process::restart(&app_handle.env()),
+                "quit" => {
+                    let _ = resolve::save_window_size_position(app_handle, true);
+
+                    resolve::resolve_reset();
+                    api::process::kill_children();
+                    app_handle.exit(0);
+                    std::process::exit(0);
+                }
+                _ => {}
+            },
+            #[cfg(target_os = "windows")]
+            SystemTrayEvent::LeftClick { .. } => {
+                resolve::create_window(app_handle);
+            }
+            _ => {}
+        }
     }
-  }
 }

src-tauri/src/core/win_service.rs

@@ -0,0 +1,178 @@
+#![cfg(target_os = "windows")]
+
+use crate::config::Config;
+use crate::utils::dirs;
+use anyhow::{bail, Context, Result};
+use deelevate::{PrivilegeLevel, Token};
+use runas::Command as RunasCommand;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::os::windows::process::CommandExt;
+use std::path::PathBuf;
+use std::time::Duration;
+use std::{env::current_exe, process::Command as StdCommand};
+use tokio::time::sleep;
+
+const SERVICE_URL: &str = "http://127.0.0.1:33211";
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct ResponseBody {
+    pub core_type: Option<String>,
+    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>,
+}
+
+/// 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).show(false).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).show(false).status()?,
+        _ => StdCommand::new(uninstall_path)
+            .creation_flags(0x08000000)
+            .status()?,
+    };
+
+    if !status.success() {
+        bail!(
+            "failed to uninstall service with status {}",
+            status.code().unwrap()
+        );
+    }
+
+    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
+        .context("failed to connect to the Clash Verge Service")?
+        .json::<JsonResponse>()
+        .await
+        .context("failed to parse the Clash Verge Service response")?;
+
+    Ok(response)
+}
+
+/// start the clash by service
+pub(super) async fn run_core_by_service(config_file: &PathBuf) -> Result<()> {
+    let status = check_service().await?;
+
+    if status.code == 0 {
+        stop_core_by_service().await?;
+        sleep(Duration::from_secs(1)).await;
+    }
+
+    let clash_core = { Config::verge().latest().clash_core.clone() };
+    let clash_core = clash_core.unwrap_or("clash".into());
+
+    let clash_bin = format!("{clash_core}.exe");
+    let bin_path = current_exe()?.with_file_name(clash_bin);
+    let bin_path = dirs::path_to_str(&bin_path)?;
+
+    let config_dir = dirs::app_home_dir()?;
+    let config_dir = dirs::path_to_str(&config_dir)?;
+
+    let log_path = dirs::service_log_file()?;
+    let log_path = dirs::path_to_str(&log_path)?;
+
+    let config_file = dirs::path_to_str(config_file)?;
+
+    let mut map = HashMap::new();
+    map.insert("core_type", clash_core.as_str());
+    map.insert("bin_path", bin_path);
+    map.insert("config_dir", config_dir);
+    map.insert("config_file", config_file);
+    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_core_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/data/clash.rs

@@ -1,167 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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::OnceCell;
-use parking_lot::Mutex;
-use std::sync::Arc;
-
-#[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() -> &'static Data {
-    static DATA: OnceCell<Data> = OnceCell::new();
-
-    DATA.get_or_init(|| Data {
-      clash: Arc::new(Mutex::new(Clash::new())),
-      verge: Arc::new(Mutex::new(Verge::new())),
-      profiles: Arc::new(Mutex::new(Profiles::new())),
-    })
-  }
-}

src-tauri/src/data/prfitem.rs

@@ -1,406 +0,0 @@
-use crate::utils::{config, dirs, help, tmpl};
-use anyhow::{bail, Context, Result};
-use reqwest::StatusCode;
-use serde::{Deserialize, Serialize};
-use serde_yaml::Mapping;
-use std::fs;
-use sysproxy::Sysproxy;
-
-#[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
-  /// use system proxy
-  #[serde(skip_serializing_if = "Option::is_none")]
-  pub with_proxy: Option<bool>,
-
-  /// for `remote` profile
-  /// use self proxy
-  #[serde(skip_serializing_if = "Option::is_none")]
-  pub self_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> {
-    match (one, other) {
-      (Some(mut a), Some(b)) => {
-        a.user_agent = b.user_agent.or(a.user_agent);
-        a.with_proxy = b.with_proxy.or(a.with_proxy);
-        a.self_proxy = b.self_proxy.or(a.self_proxy);
-        a.update_interval = b.update_interval.or(a.update_interval);
-        Some(a)
-      }
-      t @ _ => t.0.or(t.1),
-    }
-  }
-}
-
-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 opt_ref = option.as_ref();
-    let with_proxy = opt_ref.map_or(false, |o| o.with_proxy.unwrap_or(false));
-    let self_proxy = opt_ref.map_or(false, |o| o.self_proxy.unwrap_or(false));
-    let user_agent = opt_ref.map_or(None, |o| o.user_agent.clone());
-
-    let mut builder = reqwest::ClientBuilder::new().no_proxy();
-
-    // 使用软件自己的代理
-    if self_proxy {
-      let data = super::Data::global();
-      let port = data.clash.lock().info.port.clone();
-      let port = port.ok_or(anyhow::anyhow!("failed to get clash info port"))?;
-      let proxy_scheme = format!("http://127.0.0.1:{port}");
-
-      if let Ok(proxy) = reqwest::Proxy::http(&proxy_scheme) {
-        builder = builder.proxy(proxy);
-      }
-      if let Ok(proxy) = reqwest::Proxy::https(&proxy_scheme) {
-        builder = builder.proxy(proxy);
-      }
-      if let Ok(proxy) = reqwest::Proxy::all(&proxy_scheme) {
-        builder = builder.proxy(proxy);
-      }
-    }
-    // 使用系统代理
-    else if with_proxy {
-      match Sysproxy::get_system_proxy() {
-        Ok(p @ Sysproxy { enable: true, .. }) => {
-          let proxy_scheme = format!("http://{}:{}", p.host, p.port);
-
-          if let Ok(proxy) = reqwest::Proxy::http(&proxy_scheme) {
-            builder = builder.proxy(proxy);
-          }
-          if let Ok(proxy) = reqwest::Proxy::https(&proxy_scheme) {
-            builder = builder.proxy(proxy);
-          }
-          if let Ok(proxy) = reqwest::Proxy::all(&proxy_scheme) {
-            builder = builder.proxy(proxy);
-          }
-        }
-        _ => {}
-      };
-    }
-
-    let version = unsafe { dirs::APP_VERSION };
-    let version = format!("clash-verge/{version}");
-    builder = builder.user_agent(user_agent.unwrap_or(version));
-
-    let resp = builder.build()?.get(url).send().await?;
-
-    let status_code = resp.status();
-    if !StatusCode::is_success(&status_code) {
-      bail!("failed to fetch remote profile with status {status_code}")
-    }
-
-    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
-    let yaml = serde_yaml::from_str::<Mapping>(&data) //
-      .context("the remote profile data is invalid yaml")?;
-
-    if !yaml.contains_key("proxies") && !yaml.contains_key("proxy-providers") {
-      bail!("profile does not contain `proxies` or `proxy-providers`");
-    }
-
-    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

@@ -1,328 +0,0 @@
-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

@@ -1,127 +0,0 @@
-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/enhance/builtin/meta_guard.js

@@ -0,0 +1,6 @@
+function main(params) {
+  if (params.mode === "script") {
+    params.mode = "rule";
+  }
+  return params;
+}

src-tauri/src/enhance/builtin/meta_hy_alpn.js

@@ -0,0 +1,10 @@
+function main(params) {
+  if (Array.isArray(params.proxies)) {
+    params.proxies.forEach((p, i) => {
+      if (p.type === "hysteria" && typeof p.alpn === "string") {
+        params.proxies[i].alpn = [p.alpn];
+      }
+    });
+  }
+  return params;
+}

src-tauri/src/enhance/chain.rs

@@ -0,0 +1,89 @@
+use crate::{
+    config::PrfItem,
+    utils::{dirs, help},
+};
+use serde_yaml::Mapping;
+use std::fs;
+
+#[derive(Debug, Clone)]
+pub struct ChainItem {
+    pub uid: String,
+    pub data: ChainType,
+}
+
+#[derive(Debug, Clone)]
+pub enum ChainType {
+    Merge(Mapping),
+    Script(String),
+}
+
+#[derive(Debug, Clone)]
+pub enum ChainSupport {
+    Clash,
+    ClashMeta,
+    All,
+}
+
+impl From<&PrfItem> for Option<ChainItem> {
+    fn from(item: &PrfItem) -> Self {
+        let itype = item.itype.as_ref()?.as_str();
+        let file = item.file.clone()?;
+        let uid = item.uid.clone().unwrap_or("".into());
+        let path = dirs::app_profiles_dir().ok()?.join(file);
+
+        if !path.exists() {
+            return None;
+        }
+
+        match itype {
+            "script" => Some(ChainItem {
+                uid,
+                data: ChainType::Script(fs::read_to_string(path).ok()?),
+            }),
+            "merge" => Some(ChainItem {
+                uid,
+                data: ChainType::Merge(help::read_merge_mapping(&path).ok()?),
+            }),
+            _ => None,
+        }
+    }
+}
+
+impl ChainItem {
+    /// 内建支持一些脚本
+    pub fn builtin() -> Vec<(ChainSupport, ChainItem)> {
+        // meta 的一些处理
+        let meta_guard =
+            ChainItem::to_script("verge_meta_guard", include_str!("./builtin/meta_guard.js"));
+
+        // meta 1.13.2 alpn string 转 数组
+        let hy_alpn =
+            ChainItem::to_script("verge_hy_alpn", include_str!("./builtin/meta_hy_alpn.js"));
+
+        vec![
+            (ChainSupport::ClashMeta, hy_alpn),
+            (ChainSupport::ClashMeta, meta_guard),
+        ]
+    }
+
+    pub fn to_script<U: Into<String>, D: Into<String>>(uid: U, data: D) -> Self {
+        Self {
+            uid: uid.into(),
+            data: ChainType::Script(data.into()),
+        }
+    }
+}
+
+impl ChainSupport {
+    pub fn is_support(&self, core: Option<&String>) -> bool {
+        match core {
+            Some(core) => match (self, core.as_str()) {
+                (ChainSupport::All, _) => true,
+                (ChainSupport::Clash, "clash") => true,
+                (ChainSupport::ClashMeta, "clash-meta") => true,
+                _ => false,
+            },
+            None => true,
+        }
+    }
+}

src-tauri/src/enhance/field.rs

@@ -0,0 +1,155 @@
+use serde_yaml::{Mapping, Value};
+use std::collections::HashSet;
+
+pub const HANDLE_FIELDS: [&str; 9] = [
+    "mode",
+    "port",
+    "socks-port",
+    "mixed-port",
+    "allow-lan",
+    "log-level",
+    "ipv6",
+    "secret",
+    "external-controller",
+];
+
+pub const DEFAULT_FIELDS: [&str; 5] = [
+    "proxies",
+    "proxy-groups",
+    "proxy-providers",
+    "rules",
+    "rule-providers",
+];
+
+pub const OTHERS_FIELDS: [&str; 30] = [
+    "dns",
+    "tun",
+    "ebpf",
+    "hosts",
+    "script",
+    "profile",
+    "payload",
+    "tunnels",
+    "auto-redir",
+    "experimental",
+    "interface-name",
+    "routing-mark",
+    "redir-port",
+    "tproxy-port",
+    "iptables",
+    "external-ui",
+    "bind-address",
+    "authentication",
+    "tls",                       // meta
+    "sniffer",                   // meta
+    "geox-url",                  // meta
+    "listeners",                 // meta
+    "sub-rules",                 // meta
+    "geodata-mode",              // meta
+    "unified-delay",             // meta
+    "tcp-concurrent",            // meta
+    "enable-process",            // meta
+    "find-process-mode",         // meta
+    "external-controller-tls",   // meta
+    "global-client-fingerprint", // 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>, enable: bool) -> Mapping {
+    if !enable {
+        return config;
+    }
+
+    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, enable_filter: bool) -> 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());
+            });
+        });
+
+    if !enable_filter {
+        let supported_keys: HashSet<&str> = HANDLE_FIELDS
+            .into_iter()
+            .chain(OTHERS_FIELDS)
+            .chain(DEFAULT_FIELDS)
+            .collect();
+
+        let config_keys: HashSet<&str> = config
+            .keys()
+            .filter_map(|e| e.as_str())
+            .into_iter()
+            .collect();
+
+        config_keys.difference(&supported_keys).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/enhance/merge.rs

@@ -0,0 +1,92 @@
+use super::{use_filter, use_lowercase};
+use serde_yaml::{self, Mapping, Sequence, Value};
+
+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(), true);
+
+    ["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/enhance/mod.rs

@@ -0,0 +1,126 @@
+mod chain;
+mod field;
+mod merge;
+mod script;
+mod tun;
+
+pub(self) use self::field::*;
+
+use self::chain::*;
+use self::merge::*;
+use self::script::*;
+use self::tun::*;
+use crate::config::Config;
+use serde_yaml::Mapping;
+use std::collections::HashMap;
+use std::collections::HashSet;
+
+type ResultLog = Vec<(String, String)>;
+
+/// Enhance mode
+/// 返回最终配置、该配置包含的键、和script执行的结果
+pub fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
+    // config.yaml 的配置
+    let clash_config = { Config::clash().latest().0.clone() };
+
+    let (clash_core, enable_tun, enable_builtin, enable_filter) = {
+        let verge = Config::verge();
+        let verge = verge.latest();
+        (
+            verge.clash_core.clone(),
+            verge.enable_tun_mode.clone().unwrap_or(false),
+            verge.enable_builtin_enhanced.clone().unwrap_or(true),
+            verge.enable_clash_fields.clone().unwrap_or(true),
+        )
+    };
+
+    // 从profiles里拿东西
+    let (mut config, chain, valid) = {
+        let profiles = Config::profiles();
+        let profiles = profiles.latest();
+
+        let current = profiles.current_mapping().unwrap_or(Mapping::new());
+
+        let chain = match profiles.chain.as_ref() {
+            Some(chain) => chain
+                .iter()
+                .filter_map(|uid| profiles.get_item(uid).ok())
+                .filter_map(|item| <Option<ChainItem>>::from(item))
+                .collect::<Vec<ChainItem>>(),
+            None => vec![],
+        };
+
+        let valid = profiles.valid.clone().unwrap_or(vec![]);
+
+        (current, chain, valid)
+    };
+
+    let mut result_map = HashMap::new(); // 保存脚本日志
+    let mut exists_keys = use_keys(&config); // 保存出现过的keys
+
+    let valid = use_valid_fields(valid);
+    config = use_filter(config, &valid, enable_filter);
+
+    // 处理用户的profile
+    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, enable_filter);
+        }
+        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, enable_filter);
+                    logs.extend(res_logs);
+                }
+                Err(err) => logs.push(("exception".into(), err.to_string())),
+            }
+
+            result_map.insert(item.uid, logs);
+        }
+    });
+
+    // 合并默认的config
+    for (key, value) in clash_config.into_iter() {
+        config.insert(key, value);
+    }
+
+    let clash_fields = use_clash_fields();
+
+    // 内建脚本最后跑
+    if enable_builtin {
+        ChainItem::builtin()
+            .into_iter()
+            .filter(|(s, _)| s.is_support(clash_core.as_ref()))
+            .map(|(_, c)| c)
+            .for_each(|item| {
+                log::debug!(target: "app", "run builtin script {}", item.uid);
+
+                match item.data {
+                    ChainType::Script(script) => match use_script(script, config.to_owned()) {
+                        Ok((res_config, _)) => {
+                            config = use_filter(res_config, &clash_fields, enable_filter);
+                        }
+                        Err(err) => {
+                            log::error!(target: "app", "builtin script error `{err}`");
+                        }
+                    },
+                    _ => {}
+                }
+            });
+    }
+
+    config = use_filter(config, &clash_fields, enable_filter);
+    config = use_tun(config, enable_tun);
+    config = use_sort(config, enable_filter);
+
+    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/enhance/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/enhance/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!["any: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);
+
+    append!(dns_val, "enhanced-mode", "fake-ip");
+    append!(dns_val, "fake-ip-range", "198.18.0.1/16");
+    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/feat.rs

@@ -1,102 +1,341 @@
+//！
+//! feat mod 里的函数主要用于
+//! - hotkey 快捷键
+//! - timer 定时器
+//! - cmds 页面调用
+//!
+use crate::config::*;
 use crate::core::*;
-use crate::data::*;
-use crate::log_if_err;
+use crate::log_err;
+use crate::utils::resolve;
+use anyhow::{bail, Result};
+use serde_yaml::{Mapping, Value};
+use wry::application::clipboard::Clipboard;
+
+// 打开面板
+pub fn open_dashboard() {
+    let handle = handle::Handle::global();
+    let app_handle = handle.app_handle.lock();
+    if let Some(app_handle) = app_handle.as_ref() {
+        resolve::create_window(app_handle);
+    }
+}
 
 // 重启clash
 pub fn restart_clash_core() {
-  let core = Core::global();
-  let mut service = core.service.lock();
-  log_if_err!(service.restart());
-  drop(service);
-  log_if_err!(core.activate());
+    tauri::async_runtime::spawn(async {
+        match CoreManager::global().run_core().await {
+            Ok(_) => {
+                handle::Handle::refresh_clash();
+                handle::Handle::notice_message("set_config::ok", "ok");
+            }
+            Err(err) => {
+                handle::Handle::notice_message("set_config::error", format!("{err}"));
+                log::error!(target:"app", "{err}");
+            }
+        }
+    });
 }
 
-// 切换模式
-pub fn change_clash_mode(mode: &str) {
-  let core = Core::global();
-  log_if_err!(core.update_mode(mode));
+// 切换模式 rule/global/direct/script mode
+pub fn change_clash_mode(mode: String) {
+    let mut mapping = Mapping::new();
+    mapping.insert(Value::from("mode"), mode.clone().into());
+
+    tauri::async_runtime::spawn(async move {
+        log::debug!(target: "app", "change clash mode to {mode}");
+
+        match clash_api::patch_configs(&mapping).await {
+            Ok(_) => {
+                // 更新配置
+                Config::clash().data().patch_config(mapping);
+
+                if Config::clash().data().save_config().is_ok() {
+                    handle::Handle::refresh_clash();
+                    log_err!(handle::Handle::update_systray_part());
+                }
+            }
+            Err(err) => log::error!(target: "app", "{err}"),
+        }
+    });
 }
 
 // 切换系统代理
 pub fn toggle_system_proxy() {
-  let core = Core::global();
-  let data = Data::global();
+    let enable = Config::verge().draft().enable_system_proxy.clone();
+    let enable = enable.unwrap_or(false);
 
-  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();
+    tauri::async_runtime::spawn(async move {
+        match patch_verge(IVerge {
+            enable_system_proxy: Some(!enable),
+            ..IVerge::default()
+        })
+        .await
+        {
+            Ok(_) => handle::Handle::refresh_verge(),
+            Err(err) => log::error!(target: "app", "{err}"),
+        }
+    });
 }
 
 // 打开系统代理
 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();
+    tauri::async_runtime::spawn(async {
+        match patch_verge(IVerge {
+            enable_system_proxy: Some(true),
+            ..IVerge::default()
+        })
+        .await
+        {
+            Ok(_) => handle::Handle::refresh_verge(),
+            Err(err) => log::error!(target: "app", "{err}"),
+        }
+    });
 }
 
 // 关闭系统代理
 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();
+    tauri::async_runtime::spawn(async {
+        match patch_verge(IVerge {
+            enable_system_proxy: Some(false),
+            ..IVerge::default()
+        })
+        .await
+        {
+            Ok(_) => handle::Handle::refresh_verge(),
+            Err(err) => log::error!(target: "app", "{err}"),
+        }
+    });
 }
 
 // 切换tun模式
 pub fn toggle_tun_mode() {
-  let core = Core::global();
-  let data = Data::global();
+    let enable = Config::verge().data().enable_tun_mode.clone();
+    let enable = enable.unwrap_or(false);
 
-  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();
+    tauri::async_runtime::spawn(async move {
+        match patch_verge(IVerge {
+            enable_tun_mode: Some(!enable),
+            ..IVerge::default()
+        })
+        .await
+        {
+            Ok(_) => handle::Handle::refresh_verge(),
+            Err(err) => log::error!(target: "app", "{err}"),
+        }
+    });
 }
 
 // 打开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();
+    tauri::async_runtime::spawn(async {
+        match patch_verge(IVerge {
+            enable_tun_mode: Some(true),
+            ..IVerge::default()
+        })
+        .await
+        {
+            Ok(_) => handle::Handle::refresh_verge(),
+            Err(err) => log::error!(target: "app", "{err}"),
+        }
+    });
 }
 
 // 关闭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();
+    tauri::async_runtime::spawn(async {
+        match patch_verge(IVerge {
+            enable_tun_mode: Some(false),
+            ..IVerge::default()
+        })
+        .await
+        {
+            Ok(_) => handle::Handle::refresh_verge(),
+            Err(err) => log::error!(target: "app", "{err}"),
+        }
+    });
+}
+
+/// 修改clash的配置
+pub async fn patch_clash(patch: Mapping) -> Result<()> {
+    Config::clash().draft().patch_config(patch.clone());
+
+    match {
+        let mixed_port = patch.get("mixed-port");
+        if mixed_port.is_some() {
+            let changed = mixed_port != Config::clash().data().0.get("mixed-port");
+            // 检查端口占用
+            if changed {
+                if let Some(port) = mixed_port.clone().unwrap().as_u64() {
+                    if !port_scanner::local_port_available(port as u16) {
+                        Config::clash().discard();
+                        bail!("port already in use");
+                    }
+                }
+            }
+        };
+
+        // 激活配置
+        if mixed_port.is_some()
+            || patch.get("secret").is_some()
+            || patch.get("external-controller").is_some()
+        {
+            Config::generate()?;
+            CoreManager::global().run_core().await?;
+            handle::Handle::refresh_clash();
+        }
+
+        // 更新系统代理
+        if mixed_port.is_some() {
+            log_err!(sysopt::Sysopt::global().init_sysproxy());
+        }
+
+        if patch.get("mode").is_some() {
+            log_err!(handle::Handle::update_systray_part());
+        }
+
+        Config::runtime().latest().patch_config(patch);
+
+        <Result<()>>::Ok(())
+    } {
+        Ok(()) => {
+            Config::clash().apply();
+            Config::clash().data().save_config()?;
+            Ok(())
+        }
+        Err(err) => {
+            Config::clash().discard();
+            Err(err)
+        }
+    }
+}
+
+/// 修改verge的配置
+/// 一般都是一个个的修改
+pub async fn patch_verge(patch: IVerge) -> Result<()> {
+    Config::verge().draft().patch_config(patch.clone());
+
+    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 language = patch.language;
+
+    match {
+        #[cfg(target_os = "windows")]
+        {
+            let service_mode = patch.enable_service_mode;
+
+            if service_mode.is_some() {
+                log::debug!(target: "app", "change service mode to {}", service_mode.unwrap());
+
+                Config::generate()?;
+                CoreManager::global().run_core().await?;
+            } else if tun_mode.is_some() {
+                update_core_config().await?;
+            }
+        }
+
+        #[cfg(not(target_os = "windows"))]
+        if tun_mode.is_some() {
+            update_core_config().await?;
+        }
+
+        if auto_launch.is_some() {
+            sysopt::Sysopt::global().update_launch()?;
+        }
+        if system_proxy.is_some() || proxy_bypass.is_some() {
+            sysopt::Sysopt::global().update_sysproxy()?;
+            sysopt::Sysopt::global().guard_proxy();
+        }
+
+        if let Some(true) = patch.enable_proxy_guard {
+            sysopt::Sysopt::global().guard_proxy();
+        }
+
+        if let Some(hotkeys) = patch.hotkeys {
+            hotkey::Hotkey::global().update(hotkeys)?;
+        }
+
+        if language.is_some() {
+            handle::Handle::update_systray()?;
+        } else if system_proxy.or(tun_mode).is_some() {
+            handle::Handle::update_systray_part()?;
+        }
+
+        <Result<()>>::Ok(())
+    } {
+        Ok(()) => {
+            Config::verge().apply();
+            Config::verge().data().save_file()?;
+            Ok(())
+        }
+        Err(err) => {
+            Config::verge().discard();
+            Err(err)
+        }
+    }
+}
+
+/// 更新某个profile
+/// 如果更新当前配置就激活配置
+pub async fn update_profile(uid: String, option: Option<PrfOption>) -> Result<()> {
+    let url_opt = {
+        let profiles = Config::profiles();
+        let profiles = profiles.latest();
+        let item = profiles.get_item(&uid)?;
+        let is_remote = item.itype.as_ref().map_or(false, |s| s == "remote");
+
+        if !is_remote {
+            None // 直接更新
+        } else if item.url.is_none() {
+            bail!("failed to get the profile item url");
+        } else {
+            Some((item.url.clone().unwrap(), item.option.clone()))
+        }
+    };
+
+    let should_update = match url_opt {
+        Some((url, opt)) => {
+            let merged_opt = PrfOption::merge(opt, option);
+            let item = PrfItem::from_url(&url, None, None, merged_opt).await?;
+
+            let profiles = Config::profiles();
+            let mut profiles = profiles.latest();
+            profiles.update_item(uid.clone(), item)?;
+
+            Some(uid) == profiles.get_current()
+        }
+        None => true,
+    };
+
+    if should_update {
+        update_core_config().await?;
+    }
+
+    Ok(())
+}
+
+/// 更新配置
+async fn update_core_config() -> Result<()> {
+    match CoreManager::global().update_config().await {
+        Ok(_) => {
+            handle::Handle::refresh_clash();
+            handle::Handle::notice_message("set_config::ok", "ok");
+            Ok(())
+        }
+        Err(err) => {
+            handle::Handle::notice_message("set_config::error", format!("{err}"));
+            Err(err)
+        }
+    }
+}
+
+/// copy env variable
+pub fn copy_clash_env() {
+    let port = { Config::clash().data().get_client_info().port };
+    let text = format!("export https_proxy=http://127.0.0.1:{port} http_proxy=http://127.0.0.1:{port} all_proxy=socks5://127.0.0.1:{port}");
+
+    let mut cliboard = Clipboard::new();
+    cliboard.write_text(text);
 }

src-tauri/src/main.rs

@@ -1,140 +1,142 @@
 #![cfg_attr(
-  all(not(debug_assertions), target_os = "windows"),
-  windows_subsystem = "windows"
+    all(not(debug_assertions), target_os = "windows"),
+    windows_subsystem = "windows"
 )]
 
 mod cmds;
 mod config;
 mod core;
-mod data;
+mod enhance;
 mod feat;
 mod utils;
 
 use crate::utils::{init, resolve, server};
-use tauri::{api, Manager, SystemTray};
+use tauri::{api, SystemTray};
 
 fn main() -> std::io::Result<()> {
-  // 单例检测
-  if server::check_singleton().is_err() {
-    println!("app exists");
-    return Ok(());
-  }
-
-  #[cfg(target_os = "windows")]
-  unsafe {
-    use crate::utils::dirs;
-    dirs::init_portable_flag();
-  }
-
-  crate::log_if_err!(init::init_config());
-
-  #[allow(unused_mut)]
-  let mut builder = tauri::Builder::default()
-    .setup(|app| Ok(resolve::resolve_setup(app)))
-    .system_tray(SystemTray::new())
-    .on_system_tray_event(core::tray::Tray::on_system_tray_event)
-    .invoke_handler(tauri::generate_handler![
-      // common
-      cmds::get_sys_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::view_profile,
-      cmds::patch_profile,
-      cmds::create_profile,
-      cmds::import_profile,
-      cmds::update_profile,
-      cmds::delete_profile,
-      cmds::select_profile,
-      cmds::get_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};
-
-    builder = builder.menu(
-      Menu::new().add_submenu(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),
-      )),
-    );
-  }
-
-  #[allow(unused_mut)]
-  let mut app = builder
-    .build(tauri::generate_context!())
-    .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();
-      app_handle.exit(0);
+    // 单例检测
+    if server::check_singleton().is_err() {
+        println!("app exists");
+        return Ok(());
     }
+
+    crate::log_err!(init::init_config());
+
+    #[allow(unused_mut)]
+    let mut builder = tauri::Builder::default()
+        .system_tray(SystemTray::new())
+        .setup(|app| Ok(resolve::resolve_setup(app)))
+        .on_system_tray_event(core::tray::Tray::on_system_tray_event)
+        .invoke_handler(tauri::generate_handler![
+            // common
+            cmds::get_sys_proxy,
+            cmds::open_app_dir,
+            cmds::open_logs_dir,
+            cmds::open_web_url,
+            cmds::open_core_dir,
+            // cmds::kill_sidecar,
+            cmds::restart_sidecar,
+            cmds::grant_permission,
+            // 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::get_profiles,
+            cmds::enhance_profiles,
+            cmds::patch_profiles_config,
+            cmds::view_profile,
+            cmds::patch_profile,
+            cmds::create_profile,
+            cmds::import_profile,
+            cmds::update_profile,
+            cmds::delete_profile,
+            cmds::read_profile_file,
+            cmds::save_profile_file,
+            // service mode
+            cmds::service::check_service,
+            cmds::service::install_service,
+            cmds::service::uninstall_service,
+            // clash api
+            cmds::clash_api_get_proxy_delay
+        ]);
+
     #[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();
-            });
-          }
-          _ => {}
-        }
-      }
-    }
-    _ => {}
-  });
+    {
+        use tauri::{Menu, MenuItem, Submenu};
 
-  Ok(())
+        builder = builder.menu(
+            Menu::new().add_submenu(Submenu::new(
+                "Edit",
+                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)
+                    .add_native_item(MenuItem::CloseWindow)
+                    .add_native_item(MenuItem::Quit),
+            )),
+        );
+    }
+
+    let app = builder
+        .build(tauri::generate_context!())
+        .expect("error while running tauri application");
+
+    app.run(|app_handle, e| match e {
+        tauri::RunEvent::ExitRequested { api, .. } => {
+            api.prevent_exit();
+        }
+        tauri::RunEvent::Exit => {
+            resolve::resolve_reset();
+            api::process::kill_children();
+            app_handle.exit(0);
+        }
+        #[cfg(target_os = "macos")]
+        tauri::RunEvent::WindowEvent { label, event, .. } => {
+            use tauri::Manager;
+
+            if label == "main" {
+                match event {
+                    tauri::WindowEvent::CloseRequested { api, .. } => {
+                        api.prevent_close();
+                        let _ = resolve::save_window_size_position(&app_handle, true);
+
+                        app_handle.get_window("main").map(|win| {
+                            let _ = win.hide();
+                        });
+                    }
+                    _ => {}
+                }
+            }
+        }
+        #[cfg(not(target_os = "macos"))]
+        tauri::RunEvent::WindowEvent { label, event, .. } => {
+            if label == "main" {
+                match event {
+                    tauri::WindowEvent::CloseRequested { .. } => {
+                        let _ = resolve::save_window_size_position(&app_handle, true);
+                    }
+                    tauri::WindowEvent::Moved(_) | tauri::WindowEvent::Resized(_) => {
+                        let _ = resolve::save_window_size_position(&app_handle, false);
+                    }
+                    _ => {}
+                }
+            }
+        }
+        _ => {}
+    });
+
+    Ok(())
 }

src-tauri/src/utils/config.rs

@@ -1,59 +0,0 @@
-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 {
-  if !path.exists() {
-    log::error!(target: "app", "file not found \"{}\"", path.display());
-    return T::default();
-  }
-
-  let yaml_str = fs::read_to_string(&path).unwrap_or("".into());
-
-  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()
-    }
-  }
-}
-
-/// 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,8 +1,8 @@
-use std::env::temp_dir;
+use anyhow::Result;
 use std::path::PathBuf;
 use tauri::{
-  api::path::{home_dir, resource_dir},
-  Env, PackageInfo,
+    api::path::{home_dir, resource_dir},
+    Env, PackageInfo,
 };
 
 #[cfg(not(feature = "verge-dev"))]
@@ -13,7 +13,6 @@ 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;
 
@@ -21,118 +20,140 @@ static mut RESOURCE_DIR: Option<PathBuf> = None;
 #[allow(unused)]
 static mut PORTABLE_FLAG: bool = false;
 
-pub static mut APP_VERSION: &str = "v1.1.1";
+pub static mut APP_VERSION: &str = "v1.2.0";
 
 /// initialize portable flag
-#[allow(unused)]
-pub unsafe fn init_portable_flag() {
-  #[cfg(target_os = "windows")]
-  {
+#[cfg(target_os = "windows")]
+pub unsafe fn init_portable_flag() -> Result<()> {
     use tauri::utils::platform::current_exe;
 
-    let exe = current_exe().unwrap();
-    let dir = exe.parent().unwrap();
-    let dir = PathBuf::from(dir).join(".config/PORTABLE");
+    let exe = current_exe()?;
 
-    if dir.exists() {
-      PORTABLE_FLAG = true;
+    if let Some(dir) = exe.parent() {
+        let dir = PathBuf::from(dir).join(".config/PORTABLE");
+
+        if dir.exists() {
+            PORTABLE_FLAG = true;
+        }
     }
-  }
+
+    Ok(())
 }
 
 /// get the verge app home dir
-pub fn app_home_dir() -> PathBuf {
-  #[cfg(target_os = "windows")]
-  unsafe {
-    use tauri::utils::platform::current_exe;
+pub fn app_home_dir() -> Result<PathBuf> {
+    #[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)
+        if !PORTABLE_FLAG {
+            Ok(home_dir()
+                .ok_or(anyhow::anyhow!("failed to get app home dir"))?
+                .join(".config")
+                .join(APP_DIR))
+        } else {
+            let app_exe = current_exe()?;
+            let app_exe = dunce::canonicalize(app_exe)?;
+            let app_dir = app_exe
+                .parent()
+                .ok_or(anyhow::anyhow!("failed to get the portable app dir"))?;
+            Ok(PathBuf::from(app_dir).join(".config").join(APP_DIR))
+        }
     }
-  }
 
-  #[cfg(not(target_os = "windows"))]
-  home_dir().unwrap().join(".config").join(APP_DIR)
+    #[cfg(not(target_os = "windows"))]
+    Ok(home_dir()
+        .ok_or(anyhow::anyhow!("failed to get the app home dir"))?
+        .join(".config")
+        .join(APP_DIR))
 }
 
 /// get the resources dir
-pub fn app_resources_dir(package_info: &PackageInfo) -> PathBuf {
-  let res_dir = resource_dir(package_info, &Env::default())
-    .unwrap()
-    .join("resources");
+pub fn app_resources_dir(package_info: &PackageInfo) -> Result<PathBuf> {
+    let res_dir = resource_dir(package_info, &Env::default())
+        .ok_or(anyhow::anyhow!("failed to get the resource dir"))?
+        .join("resources");
 
-  unsafe {
-    RESOURCE_DIR = Some(res_dir.clone());
+    unsafe {
+        RESOURCE_DIR = Some(res_dir.clone());
 
-    let ver = package_info.version.to_string();
-    let ver_str = format!("v{ver}");
-    APP_VERSION = Box::leak(Box::new(ver_str));
-  }
+        let ver = package_info.version.to_string();
+        let ver_str = format!("v{ver}");
+        APP_VERSION = Box::leak(Box::new(ver_str));
+    }
 
-  res_dir
+    Ok(res_dir)
 }
 
 /// profiles dir
-pub fn app_profiles_dir() -> PathBuf {
-  app_home_dir().join("profiles")
+pub fn app_profiles_dir() -> Result<PathBuf> {
+    Ok(app_home_dir()?.join("profiles"))
 }
 
 /// logs dir
-pub fn app_logs_dir() -> PathBuf {
-  app_home_dir().join("logs")
+pub fn app_logs_dir() -> Result<PathBuf> {
+    Ok(app_home_dir()?.join("logs"))
 }
 
-pub fn clash_path() -> PathBuf {
-  app_home_dir().join(CLASH_CONFIG)
+pub fn clash_path() -> Result<PathBuf> {
+    Ok(app_home_dir()?.join(CLASH_CONFIG))
 }
 
-pub fn verge_path() -> PathBuf {
-  app_home_dir().join(VERGE_CONFIG)
+pub fn verge_path() -> Result<PathBuf> {
+    Ok(app_home_dir()?.join(VERGE_CONFIG))
 }
 
-pub fn profiles_path() -> PathBuf {
-  app_home_dir().join(PROFILE_YAML)
+pub fn profiles_path() -> Result<PathBuf> {
+    Ok(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);
+#[allow(unused)]
+pub fn app_res_dir() -> Result<PathBuf> {
+    unsafe {
+        Ok(RESOURCE_DIR
+            .clone()
+            .ok_or(anyhow::anyhow!("failed to get the resource dir"))?)
+    }
 }
 
-pub fn clash_pid_path() -> PathBuf {
-  unsafe { RESOURCE_DIR.clone().unwrap().join("clash.pid") }
+pub fn clash_pid_path() -> Result<PathBuf> {
+    unsafe {
+        Ok(RESOURCE_DIR
+            .clone()
+            .ok_or(anyhow::anyhow!("failed to get the resource dir"))?
+            .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)
-  }
+pub fn service_path() -> Result<PathBuf> {
+    unsafe {
+        let res_dir = RESOURCE_DIR
+            .clone()
+            .ok_or(anyhow::anyhow!("failed to get the resource dir"))?;
+        Ok(res_dir.join("clash-verge-service.exe"))
+    }
 }
 
 #[cfg(windows)]
-pub fn service_log_file() -> PathBuf {
-  use chrono::Local;
+pub fn service_log_file() -> Result<PathBuf> {
+    use chrono::Local;
 
-  let log_dir = app_logs_dir().join("service");
+    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);
+    let local_time = Local::now().format("%Y-%m-%d-%H%M").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();
+    let _ = std::fs::create_dir_all(&log_dir);
 
-  log_file
+    Ok(log_file)
+}
+
+pub fn path_to_str(path: &PathBuf) -> Result<&str> {
+    let path_str = path
+        .as_os_str()
+        .to_str()
+        .ok_or(anyhow::anyhow!("failed to get path from {:?}", path))?;
+    Ok(path_str)
 }

src-tauri/src/utils/help.rs

@@ -1,122 +1,172 @@
-use anyhow::Result;
+use anyhow::{anyhow, bail, Context, Result};
 use nanoid::nanoid;
-use std::path::PathBuf;
-use std::process::Command;
-use std::str::FromStr;
-use std::time::{SystemTime, UNIX_EPOCH};
+use serde::{de::DeserializeOwned, Serialize};
+use serde_yaml::{Mapping, Value};
+use std::{fs, path::PathBuf, str::FromStr};
 
-pub fn get_now() -> usize {
-  SystemTime::now()
-    .duration_since(UNIX_EPOCH)
-    .unwrap()
-    .as_secs() as _
+/// read data from yaml as struct T
+pub fn read_yaml<T: DeserializeOwned>(path: &PathBuf) -> Result<T> {
+    if !path.exists() {
+        bail!("file not found \"{}\"", path.display());
+    }
+
+    let yaml_str = fs::read_to_string(&path)
+        .with_context(|| format!("failed to read the file \"{}\"", path.display()))?;
+
+    serde_yaml::from_str::<T>(&yaml_str).with_context(|| {
+        format!(
+            "failed to read the file with yaml format \"{}\"",
+            path.display()
+        )
+    })
+}
+
+/// read mapping from yaml fix #165
+pub fn read_merge_mapping(path: &PathBuf) -> Result<Mapping> {
+    let mut val: Value = read_yaml(path)?;
+    val.apply_merge()
+        .with_context(|| format!("failed to apply merge \"{}\"", path.display()))?;
+
+    Ok(val
+        .as_mapping()
+        .ok_or(anyhow!(
+            "failed to transform to yaml mapping \"{}\"",
+            path.display()
+        ))?
+        .to_owned())
+}
+
+/// 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}\n\n{data_str}"),
+        None => data_str,
+    };
+
+    let path_str = path.as_os_str().to_string_lossy().to_string();
+    fs::write(path, yaml_str.as_bytes())
+        .with_context(|| format!("failed to save file \"{path_str}\""))
 }
 
 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',
+    '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}")
+    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> {
-  target.find(key).and_then(|idx| {
-    let idx = idx + key.len();
-    let value = &target[idx..];
+    target.find(key).and_then(|idx| {
+        let idx = idx + key.len();
+        let value = &target[idx..];
 
-    match value.split(';').nth(0) {
-      Some(value) => value.trim().parse(),
-      None => value.trim().parse(),
-    }
-    .ok()
-  })
+        match value.split(';').nth(0) {
+            Some(value) => value.trim().parse(),
+            None => value.trim().parse(),
+        }
+        .ok()
+    })
 }
 
 /// open file
 /// use vscode by default
 pub fn open_file(path: PathBuf) -> Result<()> {
-  // use vscode first
-  if let Ok(code) = which::which("code") {
-    let mut command = Command::new(&code);
+    #[cfg(target_os = "macos")]
+    let code = "Visual Studio Code";
+    #[cfg(not(target_os = "macos"))]
+    let code = "code";
 
-    #[cfg(target_os = "windows")]
-    {
-      use std::os::windows::process::CommandExt;
-      if let Err(err) = command.creation_flags(0x08000000).arg(&path).spawn() {
-        log::error!(target: "app", "failed to open with VScode `{err}`");
+    // use vscode first
+    if let Err(err) = open::with(&path, code) {
+        log::error!(target: "app", "failed to open file with VScode `{err}`");
+        // default open
         open::that(path)?;
-      }
     }
 
-    #[cfg(not(target_os = "windows"))]
-    if let Err(err) = command.arg(&path).spawn() {
-      log::error!(target: "app", "failed to open with VScode `{err}`");
-      open::that(path)?;
-    }
-
-    return Ok(());
-  }
-
-  open::that(path)?;
-  Ok(())
+    Ok(())
 }
 
 #[macro_export]
-macro_rules! log_if_err {
-  ($result: expr) => {
-    if let Err(err) = $result {
-      log::error!(target: "app", "{err}");
+macro_rules! error {
+    ($result: expr) => {
+        log::error!(target: "app", "{}", $result);
+    };
+}
+
+#[macro_export]
+macro_rules! log_err {
+    ($result: expr) => {
+        if let Err(err) = $result {
+            log::error!(target: "app", "{err}");
+        }
+    };
+
+    ($result: expr, $err_str: expr) => {
+        if let Err(_) = $result {
+            log::error!(target: "app", "{}", $err_str);
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! trace_err {
+    ($result: expr, $err_str: expr) => {
+        if let Err(err) = $result {
+            log::trace!(target: "app", "{}, err {}", $err_str, 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()))
-      }
-    }
-  };
+    ($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())
-  };
+    ($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";
+    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, "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);
+    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,105 +1,243 @@
-use crate::utils::{dirs, tmpl};
+use crate::config::*;
+use crate::utils::{dirs, help};
 use anyhow::Result;
-use chrono::Local;
+use chrono::{DateTime, Local};
 use log::LevelFilter;
 use log4rs::append::console::ConsoleAppender;
 use log4rs::append::file::FileAppender;
-use log4rs::config::{Appender, Config, Logger, Root};
+use log4rs::config::{Appender, Logger, Root};
 use log4rs::encode::pattern::PatternEncoder;
-use std::fs;
-use std::io::Write;
+use std::fs::{self, DirEntry};
+use std::str::FromStr;
 use tauri::PackageInfo;
 
 /// initialize this instance's log file
 fn init_log() -> Result<()> {
-  let log_dir = dirs::app_logs_dir();
-  if !log_dir.exists() {
-    let _ = fs::create_dir_all(&log_dir);
-  }
-
-  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);
-
-  let time_format = "{d(%Y-%m-%d %H:%M:%S)} - {m}{n}";
-  let stdout = ConsoleAppender::builder()
-    .encoder(Box::new(PatternEncoder::new(time_format)))
-    .build();
-  let tofile = FileAppender::builder()
-    .encoder(Box::new(PatternEncoder::new(time_format)))
-    .build(log_file)?;
-
-  let config = Config::builder()
-    .appender(Appender::builder().build("stdout", Box::new(stdout)))
-    .appender(Appender::builder().build("file", Box::new(tofile)))
-    .logger(
-      Logger::builder()
-        .appenders(["file", "stdout"])
-        .additive(false)
-        .build("app", LevelFilter::Info),
-    )
-    .build(Root::builder().appender("stdout").build(LevelFilter::Info))?;
-
-  log4rs::init_config(config)?;
-
-  Ok(())
-}
-
-/// Initialize all the files from resources
-pub fn init_config() -> Result<()> {
-  let _ = init_log();
-
-  let app_dir = dirs::app_home_dir();
-  let profiles_dir = dirs::app_profiles_dir();
-
-  if !app_dir.exists() {
-    let _ = fs::create_dir_all(&app_dir);
-  }
-  if !profiles_dir.exists() {
-    let _ = fs::create_dir_all(&profiles_dir);
-  }
-
-  // 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");
-
-  if !clash_path.exists() {
-    fs::File::create(clash_path)?.write(tmpl::CLASH_CONFIG)?;
-  }
-  if !verge_path.exists() {
-    fs::File::create(verge_path)?.write(tmpl::VERGE_CONFIG)?;
-  }
-  if !profile_path.exists() {
-    fs::File::create(profile_path)?.write(tmpl::PROFILES_CONFIG)?;
-  }
-  Ok(())
-}
-
-/// initialize app
-pub fn init_resources(package_info: &PackageInfo) {
-  // create app dir
-  let app_dir = dirs::app_home_dir();
-  let res_dir = dirs::app_resources_dir(package_info);
-
-  if !app_dir.exists() {
-    let _ = fs::create_dir_all(&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);
+    let log_dir = dirs::app_logs_dir()?;
+    if !log_dir.exists() {
+        let _ = fs::create_dir_all(&log_dir);
     }
-  }
+
+    let log_level = Config::verge().data().get_log_level();
+    if log_level == LevelFilter::Off {
+        return Ok(());
+    }
+
+    let local_time = Local::now().format("%Y-%m-%d-%H%M").to_string();
+    let log_file = format!("{}.log", local_time);
+    let log_file = log_dir.join(log_file);
+
+    let log_pattern = match log_level {
+        LevelFilter::Trace => "{d(%Y-%m-%d %H:%M:%S)} {l} [{M}] - {m}{n}",
+        _ => "{d(%Y-%m-%d %H:%M:%S)} {l} - {m}{n}",
+    };
+
+    let encode = Box::new(PatternEncoder::new(log_pattern));
+
+    let stdout = ConsoleAppender::builder().encoder(encode.clone()).build();
+    let tofile = FileAppender::builder().encoder(encode).build(log_file)?;
+
+    let mut logger_builder = Logger::builder();
+    let mut root_builder = Root::builder();
+
+    let log_more = log_level == LevelFilter::Trace || log_level == LevelFilter::Debug;
+
+    #[cfg(feature = "verge-dev")]
+    {
+        logger_builder = logger_builder.appenders(["file", "stdout"]);
+        if log_more {
+            root_builder = root_builder.appenders(["file", "stdout"]);
+        } else {
+            root_builder = root_builder.appenders(["stdout"]);
+        }
+    }
+    #[cfg(not(feature = "verge-dev"))]
+    {
+        logger_builder = logger_builder.appenders(["file"]);
+        if log_more {
+            root_builder = root_builder.appenders(["file"]);
+        }
+    }
+
+    let (config, _) = log4rs::config::Config::builder()
+        .appender(Appender::builder().build("stdout", Box::new(stdout)))
+        .appender(Appender::builder().build("file", Box::new(tofile)))
+        .logger(logger_builder.additive(false).build("app", log_level))
+        .build_lossy(root_builder.build(log_level));
+
+    log4rs::init_config(config)?;
+
+    Ok(())
+}
+
+/// 删除log文件
+pub fn delete_log() -> Result<()> {
+    let log_dir = dirs::app_logs_dir()?;
+    if !log_dir.exists() {
+        return Ok(());
+    }
+
+    let auto_log_clean = {
+        let verge = Config::verge();
+        let verge = verge.data();
+        verge.auto_log_clean.clone().unwrap_or(0)
+    };
+
+    let day = match auto_log_clean {
+        1 => 7,
+        2 => 30,
+        3 => 90,
+        _ => return Ok(()),
+    };
+
+    log::debug!(target: "app", "try to delete log files, day: {day}");
+
+    // %Y-%m-%d to NaiveDateTime
+    let parse_time_str = |s: &str| {
+        let sa: Vec<&str> = s.split('-').collect();
+        if sa.len() != 4 {
+            return Err(anyhow::anyhow!("invalid time str"));
+        }
+
+        let year = i32::from_str(sa[0])?;
+        let month = u32::from_str(sa[1])?;
+        let day = u32::from_str(sa[2])?;
+        let time = chrono::NaiveDate::from_ymd_opt(year, month, day)
+            .ok_or(anyhow::anyhow!("invalid time str"))?
+            .and_hms_opt(0, 0, 0)
+            .ok_or(anyhow::anyhow!("invalid time str"))?;
+        Ok(time)
+    };
+
+    let process_file = |file: DirEntry| -> Result<()> {
+        let file_name = file.file_name();
+        let file_name = file_name.to_str().unwrap_or_default();
+
+        if file_name.ends_with(".log") {
+            let now = Local::now();
+            let created_time = parse_time_str(&file_name[0..file_name.len() - 4])?;
+            let file_time = DateTime::<Local>::from_local(created_time, now.offset().clone());
+
+            let duration = now.signed_duration_since(file_time);
+            if duration.num_days() > day {
+                let file_path = file.path();
+                let _ = fs::remove_file(file_path);
+                log::info!(target: "app", "delete log file: {file_name}");
+            }
+        }
+        Ok(())
+    };
+
+    for file in fs::read_dir(&log_dir)? {
+        if let Ok(file) = file {
+            let _ = process_file(file);
+        }
+    }
+    Ok(())
+}
+
+/// Initialize all the config files
+/// before tauri setup
+pub fn init_config() -> Result<()> {
+    #[cfg(target_os = "windows")]
+    unsafe {
+        let _ = dirs::init_portable_flag();
+    }
+
+    let _ = init_log();
+    let _ = delete_log();
+
+    crate::log_err!(dirs::app_home_dir().map(|app_dir| {
+        if !app_dir.exists() {
+            let _ = fs::create_dir_all(&app_dir);
+        }
+    }));
+
+    crate::log_err!(dirs::app_profiles_dir().map(|profiles_dir| {
+        if !profiles_dir.exists() {
+            let _ = fs::create_dir_all(&profiles_dir);
+        }
+    }));
+
+    crate::log_err!(dirs::clash_path().map(|path| {
+        if !path.exists() {
+            help::save_yaml(&path, &IClashTemp::template().0, Some("# Clash Verge"))?;
+        }
+        <Result<()>>::Ok(())
+    }));
+
+    crate::log_err!(dirs::verge_path().map(|path| {
+        if !path.exists() {
+            help::save_yaml(&path, &IVerge::template(), Some("# Clash Verge"))?;
+        }
+        <Result<()>>::Ok(())
+    }));
+
+    crate::log_err!(dirs::profiles_path().map(|path| {
+        if !path.exists() {
+            help::save_yaml(&path, &IProfiles::template(), Some("# Clash Verge"))?;
+        }
+        <Result<()>>::Ok(())
+    }));
+
+    Ok(())
+}
+
+/// initialize app resources
+/// after tauri setup
+pub fn init_resources(package_info: &PackageInfo) -> Result<()> {
+    let app_dir = dirs::app_home_dir()?;
+    let res_dir = dirs::app_resources_dir(package_info)?;
+
+    if !app_dir.exists() {
+        let _ = fs::create_dir_all(&app_dir);
+    }
+    if !res_dir.exists() {
+        let _ = fs::create_dir_all(&res_dir);
+    }
+
+    #[cfg(target_os = "windows")]
+    let file_list = ["Country.mmdb", "geoip.dat", "geosite.dat", "wintun.dll"];
+    #[cfg(not(target_os = "windows"))]
+    let file_list = ["Country.mmdb", "geoip.dat", "geosite.dat"];
+
+    // copy the resource file
+    // if the source file is newer than the destination file, copy it over
+    for file in file_list.iter() {
+        let src_path = res_dir.join(file);
+        let dest_path = app_dir.join(file);
+
+        let handle_copy = || {
+            match fs::copy(&src_path, &dest_path) {
+                Ok(_) => log::debug!(target: "app", "resources copied '{file}'"),
+                Err(err) => {
+                    log::error!(target: "app", "failed to copy resources '{file}', {err}")
+                }
+            };
+        };
+
+        if src_path.exists() && !dest_path.exists() {
+            handle_copy();
+            continue;
+        }
+
+        let src_modified = fs::metadata(&src_path).and_then(|m| m.modified());
+        let dest_modified = fs::metadata(&dest_path).and_then(|m| m.modified());
+
+        match (src_modified, dest_modified) {
+            (Ok(src_modified), Ok(dest_modified)) => {
+                if src_modified > dest_modified {
+                    handle_copy();
+                } else {
+                    log::debug!(target: "app", "skipping resource copy '{file}'");
+                }
+            }
+            _ => {
+                log::debug!(target: "app", "failed to get modified '{file}'");
+                handle_copy();
+            }
+        };
+    }
+
+    Ok(())
 }

src-tauri/src/utils/mod.rs

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

src-tauri/src/utils/resolve.rs

@@ -1,110 +1,179 @@
-use crate::{
-  core::{tray, Core},
-  data::Data,
-  utils::init,
-  utils::server,
-};
+use crate::{config::Config, core::*, utils::init, utils::server};
+use crate::{log_err, trace_err};
+use anyhow::Result;
 use tauri::{App, AppHandle, Manager};
 
 /// handle something when start app
-pub fn resolve_setup(app: &App) {
-  let _ = app
-    .tray_handle()
-    .set_menu(tray::Tray::tray_menu(&app.app_handle()));
+pub fn resolve_setup(app: &mut App) {
+    #[cfg(target_os = "macos")]
+    app.set_activation_policy(tauri::ActivationPolicy::Accessory);
 
-  init::init_resources(app.package_info());
+    handle::Handle::global().init(app.app_handle());
 
-  let silent_start = {
-    let global = Data::global();
-    let verge = global.verge.lock();
-    let singleton = verge.app_singleton_port.clone();
+    log_err!(init::init_resources(app.package_info()));
+
+    // 启动核心
+    log::trace!("init config");
+    log_err!(Config::init_config());
+
+    log::trace!("launch core");
+    log_err!(CoreManager::global().init());
 
     // setup a simple http server for singleton
-    server::embed_server(&app.app_handle(), singleton);
+    log::trace!("launch embed server");
+    server::embed_server(app.app_handle());
 
-    verge.enable_silent_start.clone().unwrap_or(false)
-  };
+    log::trace!("init system tray");
+    log_err!(tray::Tray::update_systray(&app.app_handle()));
 
-  // core should be initialized after init_app fix #122
-  let core = Core::global();
-  core.init(app.app_handle());
+    let silent_start = { Config::verge().data().enable_silent_start.clone() };
+    if !silent_start.unwrap_or(false) {
+        create_window(&app.app_handle());
+    }
 
-  if !silent_start {
-    create_window(&app.app_handle());
-  }
+    log_err!(sysopt::Sysopt::global().init_launch());
+    log_err!(sysopt::Sysopt::global().init_sysproxy());
+
+    log_err!(handle::Handle::update_systray_part());
+    log_err!(hotkey::Hotkey::global().init(app.app_handle()));
+    log_err!(timer::Timer::global().init());
 }
 
 /// reset system proxy
 pub fn resolve_reset() {
-  let core = Core::global();
-  let mut sysopt = core.sysopt.lock();
-  crate::log_if_err!(sysopt.reset_sysproxy());
-  drop(sysopt);
-
-  let mut service = core.service.lock();
-  crate::log_if_err!(service.stop());
+    log_err!(sysopt::Sysopt::global().reset_sysproxy());
+    log_err!(CoreManager::global().stop_core());
 }
 
 /// 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}"),
+    if let Some(window) = app_handle.get_window("main") {
+        trace_err!(window.unminimize(), "set win unminimize");
+        trace_err!(window.show(), "set win visible");
+        trace_err!(window.set_focus(), "set win focus");
+        return;
     }
-  }
 
-  #[cfg(target_os = "macos")]
-  crate::log_if_err!(builder.decorations(true).inner_size(800.0, 642.0).build());
+    let mut builder = tauri::window::WindowBuilder::new(
+        app_handle,
+        "main".to_string(),
+        tauri::WindowUrl::App("index.html".into()),
+    )
+    .title("Clash Verge")
+    .fullscreen(false)
+    .min_inner_size(600.0, 520.0);
 
-  #[cfg(target_os = "linux")]
-  crate::log_if_err!(builder
-    .decorations(false)
-    .transparent(true)
-    .inner_size(800.0, 636.0)
-    .build());
+    match Config::verge().latest().window_size_position.clone() {
+        Some(size_pos) if size_pos.len() == 4 => {
+            let size = (size_pos[0], size_pos[1]);
+            let pos = (size_pos[2], size_pos[3]);
+            let w = size.0.clamp(600.0, f64::INFINITY);
+            let h = size.1.clamp(520.0, f64::INFINITY);
+            builder = builder.inner_size(w, h).position(pos.0, pos.1);
+        }
+        _ => {
+            #[cfg(target_os = "windows")]
+            {
+                builder = builder.inner_size(800.0, 636.0).center();
+            }
+
+            #[cfg(target_os = "macos")]
+            {
+                builder = builder.inner_size(800.0, 642.0).center();
+            }
+
+            #[cfg(target_os = "linux")]
+            {
+                builder = builder.inner_size(800.0, 642.0).center();
+            }
+        }
+    };
+
+    #[cfg(target_os = "windows")]
+    {
+        use std::time::Duration;
+        use tokio::time::sleep;
+        use window_shadows::set_shadow;
+
+        match builder
+            .decorations(false)
+            .transparent(true)
+            .visible(false)
+            .build()
+        {
+            Ok(win) => {
+                log::trace!("try to calculate the monitor size");
+                let center = (|| -> Result<bool> {
+                    let mut center = false;
+                    let monitor = win.current_monitor()?.ok_or(anyhow::anyhow!(""))?;
+                    let size = monitor.size();
+                    let pos = win.outer_position()?;
+
+                    if pos.x < -400
+                        || pos.x > (size.width - 200).try_into()?
+                        || pos.y < -200
+                        || pos.y > (size.height - 200).try_into()?
+                    {
+                        center = true;
+                    }
+                    Ok(center)
+                })();
+
+                if center.unwrap_or(true) {
+                    trace_err!(win.center(), "set win center");
+                }
+
+                log::trace!("try to create window");
+                let app_handle = app_handle.clone();
+
+                // 加点延迟避免界面闪一下
+                tauri::async_runtime::spawn(async move {
+                    sleep(Duration::from_millis(888)).await;
+
+                    if let Some(window) = app_handle.get_window("main") {
+                        trace_err!(set_shadow(&window, true), "set win shadow");
+                        trace_err!(window.show(), "set win visible");
+                        trace_err!(window.unminimize(), "set win unminimize");
+                        trace_err!(window.set_focus(), "set win focus");
+                    } else {
+                        log::error!(target: "app", "failed to create window, get_window is None")
+                    }
+                });
+            }
+            Err(err) => log::error!(target: "app", "failed to create window, {err}"),
+        }
+    }
+
+    #[cfg(target_os = "macos")]
+    crate::log_err!(builder
+        .decorations(true)
+        .hidden_title(true)
+        .title_bar_style(tauri::TitleBarStyle::Overlay)
+        .build());
+
+    #[cfg(target_os = "linux")]
+    crate::log_err!(builder.decorations(true).transparent(false).build());
+}
+
+/// save window size and position
+pub fn save_window_size_position(app_handle: &AppHandle, save_to_file: bool) -> Result<()> {
+    let win = app_handle
+        .get_window("main")
+        .ok_or(anyhow::anyhow!("failed to get window"))?;
+
+    let scale = win.scale_factor()?;
+    let size = win.inner_size()?;
+    let size = size.to_logical::<f64>(scale);
+    let pos = win.outer_position()?;
+    let pos = pos.to_logical::<f64>(scale);
+
+    let verge = Config::verge();
+    let mut verge = verge.latest();
+    verge.window_size_position = Some(vec![size.width, size.height, pos.x, pos.y]);
+
+    if save_to_file {
+        verge.save_file()?;
+    }
+
+    Ok(())
 }

src-tauri/src/utils/server.rs

@@ -1,44 +1,44 @@
 extern crate warp;
 
 use super::resolve;
-use crate::data::Verge;
+use crate::config::IVerge;
+use anyhow::{bail, Result};
 use port_scanner::local_port_available;
 use tauri::AppHandle;
 use warp::Filter;
 
-#[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<(), ()> {
-  let verge = Verge::new();
-  let port = verge.app_singleton_port.unwrap_or(SERVER_PORT);
+pub fn check_singleton() -> Result<()> {
+    let port = IVerge::get_singleton_port();
 
-  if !local_port_available(port) {
-    tauri::async_runtime::block_on(async {
-      let url = format!("http://127.0.0.1:{}/commands/visible", port);
-      reqwest::get(url).await.unwrap();
-      Err(())
-    })
-  } else {
-    Ok(())
-  }
+    if !local_port_available(port) {
+        tauri::async_runtime::block_on(async {
+            let url = format!("http://127.0.0.1:{port}/commands/visible");
+            let resp = reqwest::get(url).await?.text().await?;
+
+            if &resp == "ok" {
+                bail!("app exists");
+            }
+
+            log::error!("failed to setup singleton listen server");
+            Ok(())
+        })
+    } else {
+        Ok(())
+    }
 }
 
 /// The embed server only be used to implement singleton process
 /// maybe it can be used as pac server later
-pub fn embed_server(app_handle: &AppHandle, port: Option<u16>) {
-  let app_handle = app_handle.clone();
-  let port = port.unwrap_or(SERVER_PORT);
+pub fn embed_server(app_handle: AppHandle) {
+    let port = IVerge::get_singleton_port();
 
-  tauri::async_runtime::spawn(async move {
-    let commands = warp::path!("commands" / "visible").map(move || {
-      resolve::create_window(&app_handle);
-      return format!("ok");
+    tauri::async_runtime::spawn(async move {
+        let commands = warp::path!("commands" / "visible").map(move || {
+            resolve::create_window(&app_handle);
+            format!("ok")
+        });
+
+        warp::serve(commands).bind(([127, 0, 0, 1], port)).await;
     });
-
-    warp::serve(commands).bind(([127, 0, 0, 1], port)).await;
-  });
 }

src-tauri/src/utils/tmpl.rs

@@ -1,36 +1,5 @@
 ///! 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
 
@@ -60,9 +29,7 @@ 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

@@ -1,69 +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());
-}
+#![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": "1.1.2"
+    "version": "1.3.8"
   },
   "build": {
     "distDir": "../dist",
@@ -25,19 +25,14 @@
         "icons/icon-new.icns",
         "icons/icon.ico"
       ],
-      "resources": [
-        "resources"
-      ],
-      "externalBin": [
-        "sidecar/clash",
-        "sidecar/clash-meta"
-      ],
+      "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": []
+        "depends": ["openssl"]
       },
       "macOS": {
         "frameworks": [],
@@ -51,18 +46,15 @@
         "digestAlgorithm": "sha256",
         "timestampUrl": "",
         "wix": {
-          "language": [
-            "zh-CN",
-            "en-US"
-          ]
+          "language": ["zh-CN", "en-US", "ru-RU"]
         }
       }
     },
     "updater": {
       "active": true,
       "endpoints": [
-        "https://github.com/zzzgydi/clash-verge/releases/download/updater/update.json",
-        "https://hub.fastgit.xyz/zzzgydi/clash-verge/releases/download/updater/update-proxy.json"
+        "https://ghproxy.com/https://github.com/zzzgydi/clash-verge/releases/download/updater/update-proxy.json",
+        "https://github.com/zzzgydi/clash-verge/releases/download/updater/update.json"
       ],
       "dialog": false,
       "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IDExNUFBNTBBN0FDNEFBRTUKUldUbHFzUjZDcVZhRVRJM25NS3NkSFlFVElxUkNZMzZ6bHUwRVJjb2F3alJXVzRaeDdSaTA2YWYK"
@@ -86,4 +78,4 @@
       "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,7 +4,11 @@ body {
     "Ubuntu", "Cantarell", "Fira Sans", "Droid Sans", "Helvetica Neue",
     sans-serif;
   -webkit-font-smoothing: antialiased;
+
   user-select: none;
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
 }
 
 :root {
@@ -37,3 +41,10 @@ body {
     background-color: rgba(18, 18, 18, 1);
   }
 }
+
+.user-none {
+  user-select: none;
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+}

src/assets/styles/layout.scss

@@ -14,6 +14,9 @@
     flex-direction: column;
     box-sizing: border-box;
     user-select: none;
+    -webkit-user-select: none;
+    -moz-user-select: none;
+    -ms-user-select: none;
     overflow: hidden;
 
     $maxLogo: 100px;
@@ -101,3 +104,14 @@
     }
   }
 }
+
+.macos {
+  &.layout {
+    .layout__left {
+      padding-top: 24px;
+    }
+    .layout__right .the-content {
+      top: 20px;
+    }
+  }
+}

src/components/base/base-dialog.tsx

@@ -0,0 +1,67 @@
+import { ReactNode } from "react";
+import {
+  Button,
+  Dialog,
+  DialogActions,
+  DialogContent,
+  DialogTitle,
+  type SxProps,
+  type Theme,
+} from "@mui/material";
+
+interface Props {
+  title: ReactNode;
+  open: boolean;
+  okBtn?: ReactNode;
+  cancelBtn?: ReactNode;
+  disableOk?: boolean;
+  disableCancel?: boolean;
+  disableFooter?: boolean;
+  contentSx?: SxProps<Theme>;
+  children?: ReactNode;
+  onOk?: () => void;
+  onCancel?: () => void;
+  onClose?: () => void;
+}
+
+export interface DialogRef {
+  open: () => void;
+  close: () => void;
+}
+
+export const BaseDialog: React.FC<Props> = (props) => {
+  const {
+    open,
+    title,
+    children,
+    okBtn,
+    cancelBtn,
+    contentSx,
+    disableCancel,
+    disableOk,
+    disableFooter,
+  } = props;
+
+  return (
+    <Dialog open={open} onClose={props.onClose}>
+      <DialogTitle>{title}</DialogTitle>
+
+      <DialogContent sx={contentSx}>{children}</DialogContent>
+
+      {!disableFooter && (
+        <DialogActions>
+          {!disableCancel && (
+            <Button variant="outlined" onClick={props.onCancel}>
+              {cancelBtn}
+            </Button>
+          )}
+          {!disableOk && (
+            <Button variant="contained" onClick={props.onOk}>
+              {okBtn}
+            </Button>
+          )}
+        </DialogActions>
+      )}
+    </Dialog>
+  );
+};

src/components/base/base-empty.tsx

@@ -1,12 +1,12 @@
 import { alpha, Box, Typography } from "@mui/material";
-import { BlurOnRounded } from "@mui/icons-material";
+import { InboxRounded } from "@mui/icons-material";
 
 interface Props {
   text?: React.ReactNode;
   extra?: React.ReactNode;
 }
 
-const BaseEmpty = (props: Props) => {
+export const BaseEmpty = (props: Props) => {
   const { text = "Empty", extra } = props;
 
   return (
@@ -21,11 +21,9 @@ const BaseEmpty = (props: Props) => {
         color: alpha(palette.text.secondary, 0.75),
       })}
     >
-      <BlurOnRounded sx={{ fontSize: "4em" }} />
+      <InboxRounded sx={{ fontSize: "4em" }} />
       <Typography sx={{ fontSize: "1.25em" }}>{text}</Typography>
       {extra}
     </Box>
   );
 };
-
-export default BaseEmpty;

src/components/base/base-error-boundary.tsx

@@ -0,0 +1,29 @@
+import { ReactNode } from "react";
+import { ErrorBoundary, FallbackProps } from "react-error-boundary";
+
+function ErrorFallback({ error }: FallbackProps) {
+  return (
+    <div role="alert" style={{ padding: 16 }}>
+      <h4>Something went wrong:(</h4>
+
+      <pre>{error.message}</pre>
+
+      <details title="Error Stack">
+        <summary>Error Stack</summary>
+        <pre>{error.stack}</pre>
+      </details>
+    </div>
+  );
+}
+
+interface Props {
+  children?: ReactNode;
+}
+
+export const BaseErrorBoundary = (props: Props) => {
+  return (
+    <ErrorBoundary FallbackComponent={ErrorFallback}>
+      {props.children}
+    </ErrorBoundary>
+  );
+};

src/components/base/base-loading.tsx

@@ -37,7 +37,7 @@ const LoadingItem = styled("div")(({ theme }) => ({
   background: theme.palette.text.secondary,
 }));
 
-const BaseLoading = () => {
+export const BaseLoading = () => {
   return (
     <Loading>
       <LoadingItem />
@@ -46,5 +46,3 @@ const BaseLoading = () => {
     </Loading>
   );
 };
-
-export default BaseLoading;

src/components/base/base-notice.tsx

@@ -1,4 +1,4 @@
-import ReactDOM from "react-dom";
+import { createRoot } from "react-dom/client";
 import { ReactNode, useState } from "react";
 import { Box, IconButton, Slide, Snackbar, Typography } from "@mui/material";
 import { Close, CheckCircleRounded, ErrorRounded } from "@mui/icons-material";
@@ -69,7 +69,7 @@ interface NoticeInstance {
 let parent: HTMLDivElement = null!;
 
 // @ts-ignore
-const Notice: NoticeInstance = (props) => {
+export const Notice: NoticeInstance = (props) => {
   if (!parent) {
     parent = document.createElement("div");
     document.body.appendChild(parent);
@@ -77,13 +77,14 @@ const Notice: NoticeInstance = (props) => {
 
   const container = document.createElement("div");
   parent.appendChild(container);
+  const root = createRoot(container);
 
   const onUnmount = () => {
-    const result = ReactDOM.unmountComponentAtNode(container);
-    if (result && parent) setTimeout(() => parent.removeChild(container), 500);
+    root.unmount();
+    if (parent) setTimeout(() => parent.removeChild(container), 500);
   };
 
-  ReactDOM.render(<NoticeInner {...props} onClose={onUnmount} />, container);
+  root.render(<NoticeInner {...props} onClose={onUnmount} />);
 };
 
 (["info", "error", "success"] as const).forEach((type) => {
@@ -91,5 +92,3 @@ const Notice: NoticeInstance = (props) => {
     setTimeout(() => Notice({ type, message, duration }), 0);
   };
 });
-
-export default Notice;

src/components/base/base-page.tsx

@@ -1,32 +1,34 @@
+import React, { ReactNode } from "react";
 import { Typography } from "@mui/material";
-import React from "react";
+import { BaseErrorBoundary } from "./base-error-boundary";
 
 interface Props {
   title?: React.ReactNode; // the page title
   header?: React.ReactNode; // something behind title
   contentStyle?: React.CSSProperties;
+  children?: ReactNode;
 }
 
-const BasePage: React.FC<Props> = (props) => {
+export const BasePage: React.FC<Props> = (props) => {
   const { title, header, contentStyle, children } = props;
 
   return (
-    <div className="base-page" data-windrag>
-      <header data-windrag style={{ userSelect: "none" }}>
-        <Typography variant="h4" component="h1" data-windrag>
-          {title}
-        </Typography>
+    <BaseErrorBoundary>
+      <div className="base-page" data-windrag>
+        <header data-windrag style={{ userSelect: "none" }}>
+          <Typography variant="h4" component="h1" data-windrag>
+            {title}
+          </Typography>
 
-        {header}
-      </header>
+          {header}
+        </header>
 
-      <section>
-        <div className="base-content" style={contentStyle} data-windrag>
-          {children}
-        </div>
-      </section>
-    </div>
+        <section>
+          <div className="base-content" style={contentStyle} data-windrag>
+            {children}
+          </div>
+        </section>
+      </div>
+    </BaseErrorBoundary>
   );
 };
-
-export default BasePage;

src/components/base/index.ts

@@ -0,0 +1,6 @@
+export { BaseDialog, type DialogRef } from "./base-dialog";
+export { BasePage } from "./base-page";
+export { BaseEmpty } from "./base-empty";
+export { BaseLoading } from "./base-loading";
+export { BaseErrorBoundary } from "./base-error-boundary";
+export { Notice } from "./base-notice";

src/components/connection/connection-detail.tsx

@@ -0,0 +1,104 @@
+import dayjs from "dayjs";
+import { forwardRef, useImperativeHandle, useState } from "react";
+import { useLockFn } from "ahooks";
+import { Box, Button, Snackbar } from "@mui/material";
+import { deleteConnection } from "@/services/api";
+import { truncateStr } from "@/utils/truncate-str";
+import parseTraffic from "@/utils/parse-traffic";
+
+export interface ConnectionDetailRef {
+  open: (detail: IConnectionsItem) => void;
+}
+
+export const ConnectionDetail = forwardRef<ConnectionDetailRef>(
+  (props, ref) => {
+    const [open, setOpen] = useState(false);
+    const [detail, setDetail] = useState<IConnectionsItem>(null!);
+
+    useImperativeHandle(ref, () => ({
+      open: (detail: IConnectionsItem) => {
+        if (open) return;
+        setOpen(true);
+        setDetail(detail);
+      },
+    }));
+
+    const onClose = () => setOpen(false);
+
+    return (
+      <Snackbar
+        anchorOrigin={{ vertical: "bottom", horizontal: "right" }}
+        open={open}
+        onClose={onClose}
+        message={
+          detail ? (
+            <InnerConnectionDetail data={detail} onClose={onClose} />
+          ) : null
+        }
+      />
+    );
+  }
+);
+
+interface InnerProps {
+  data: IConnectionsItem;
+  onClose?: () => void;
+}
+
+const InnerConnectionDetail = ({ data, onClose }: InnerProps) => {
+  const { metadata, rulePayload } = data;
+  const chains = [...data.chains].reverse().join(" / ");
+  const rule = rulePayload ? `${data.rule}(${rulePayload})` : data.rule;
+  const host = metadata.host
+    ? `${metadata.host}:${metadata.destinationPort}`
+    : `${metadata.destinationIP}:${metadata.destinationPort}`;
+
+  const information = [
+    { label: "Host", value: host },
+    { label: "Download", value: parseTraffic(data.download).join(" ") },
+    { label: "Upload", value: parseTraffic(data.upload).join(" ") },
+    {
+      label: "DL Speed",
+      value: parseTraffic(data.curDownload ?? -1).join(" ") + "/s",
+    },
+    {
+      label: "UL Speed",
+      value: parseTraffic(data.curUpload ?? -1).join(" ") + "/s",
+    },
+    { label: "Chains", value: chains },
+    { label: "Rule", value: rule },
+    {
+      label: "Process",
+      value: truncateStr(metadata.process || metadata.processPath),
+    },
+    { label: "Time", value: dayjs(data.start).fromNow() },
+    { label: "Source", value: `${metadata.sourceIP}:${metadata.sourcePort}` },
+    { label: "Destination IP", value: metadata.destinationIP },
+    { label: "Type", value: `${metadata.type}(${metadata.network})` },
+  ];
+
+  const onDelete = useLockFn(async () => deleteConnection(data.id));
+
+  return (
+    <Box sx={{ userSelect: "text" }}>
+      {information.map((each) => (
+        <div key={each.label}>
+          <b>{each.label}</b>: <span>{each.value}</span>
+        </div>
+      ))}
+
+      <Box sx={{ textAlign: "right" }}>
+        <Button
+          variant="contained"
+          title="Close Connection"
+          onClick={() => {
+            onDelete();
+            onClose?.();
+          }}
+        >
+          Close
+        </Button>
+      </Box>
+    </Box>
+  );
+};

src/components/connection/connection-item.tsx

@@ -23,11 +23,12 @@ const Tag = styled("span")(({ theme }) => ({
 }));
 
 interface Props {
-  value: ApiType.ConnectionsItem;
+  value: IConnectionsItem;
+  onShowDetail?: () => void;
 }
 
-const ConnectionItem = (props: Props) => {
-  const { value } = props;
+export const ConnectionItem = (props: Props) => {
+  const { value, onShowDetail } = props;
 
   const { id, metadata, chains, start, curUpload, curDownload } = value;
 
@@ -44,8 +45,9 @@ const ConnectionItem = (props: Props) => {
       }
     >
       <ListItemText
-        sx={{ userSelect: "text" }}
+        sx={{ userSelect: "text", cursor: "pointer" }}
         primary={metadata.host || metadata.destinationIP}
+        onClick={onShowDetail}
         secondary={
           <Box sx={{ display: "flex", flexWrap: "wrap" }}>
             <Tag sx={{ textTransform: "uppercase", color: "success" }}>
@@ -56,7 +58,7 @@ const ConnectionItem = (props: Props) => {
 
             {!!metadata.process && <Tag>{metadata.process}</Tag>}
 
-            {chains.length > 0 && <Tag>{chains[value.chains.length - 1]}</Tag>}
+            {chains?.length > 0 && <Tag>{chains[value.chains.length - 1]}</Tag>}
 
             <Tag>{dayjs(start).fromNow()}</Tag>
 
@@ -71,5 +73,3 @@ const ConnectionItem = (props: Props) => {
     </ListItem>
   );
 };
-
-export default ConnectionItem;

src/components/connection/connection-table.tsx

@@ -1,32 +1,29 @@
 import dayjs from "dayjs";
-import { useMemo } from "react";
+import { useMemo, useState } from "react";
 import { DataGrid, GridColDef } from "@mui/x-data-grid";
+import { truncateStr } from "@/utils/truncate-str";
 import parseTraffic from "@/utils/parse-traffic";
 
 interface Props {
-  connections: ApiType.ConnectionsItem[];
+  connections: IConnectionsItem[];
+  onShowDetail: (data: IConnectionsItem) => void;
 }
 
-const ConnectionTable = (props: Props) => {
-  const { connections } = props;
+export const ConnectionTable = (props: Props) => {
+  const { connections, onShowDetail } = props;
+
+  const [columnVisible, setColumnVisible] = useState<
+    Partial<Record<keyof IConnectionsItem, boolean>>
+  >({});
 
   const columns: GridColDef[] = [
-    {
-      field: "host",
-      headerName: "Host",
-      flex: 200,
-      minWidth: 200,
-      resizable: false,
-      disableColumnMenu: true,
-    },
+    { field: "host", headerName: "Host", flex: 220, minWidth: 220 },
     {
       field: "download",
       headerName: "Download",
       width: 88,
       align: "right",
       headerAlign: "right",
-      disableColumnMenu: true,
-      valueFormatter: (params: any) => parseTraffic(params.value).join(" "),
     },
     {
       field: "upload",
@@ -34,18 +31,13 @@ const ConnectionTable = (props: Props) => {
       width: 88,
       align: "right",
       headerAlign: "right",
-      disableColumnMenu: true,
-      valueFormatter: (params: any) => parseTraffic(params.value).join(" "),
     },
     {
       field: "dlSpeed",
       headerName: "DL Speed",
-      align: "right",
       width: 88,
+      align: "right",
       headerAlign: "right",
-      disableColumnMenu: true,
-      valueFormatter: (params: any) =>
-        parseTraffic(params.value).join(" ") + "/s",
     },
     {
       field: "ulSpeed",
@@ -53,55 +45,26 @@ const ConnectionTable = (props: Props) => {
       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: "chains", headerName: "Chains", flex: 360, minWidth: 360 },
+    { field: "rule", headerName: "Rule", flex: 300, minWidth: 250 },
+    { field: "process", headerName: "Process", flex: 480, minWidth: 480 },
     {
       field: "time",
       headerName: "Time",
-      width: 120,
+      flex: 120,
+      minWidth: 100,
       align: "right",
       headerAlign: "right",
-      disableColumnMenu: true,
-      valueFormatter: (params) => dayjs(params.value).fromNow(),
-    },
-    {
-      field: "source",
-      headerName: "Source",
-      width: 150,
-      disableColumnMenu: true,
     },
+    { field: "source", headerName: "Source", flex: 200, minWidth: 130 },
     {
       field: "destinationIP",
       headerName: "Destination IP",
-      width: 125,
-      disableColumnMenu: true,
-    },
-    {
-      field: "type",
-      headerName: "Type",
-      width: 160,
-      disableColumnMenu: true,
+      flex: 200,
+      minWidth: 130,
     },
+    { field: "type", headerName: "Type", flex: 160, minWidth: 100 },
   ];
 
   const connRows = useMemo(() => {
@@ -115,30 +78,33 @@ const ConnectionTable = (props: Props) => {
         host: metadata.host
           ? `${metadata.host}:${metadata.destinationPort}`
           : `${metadata.destinationIP}:${metadata.destinationPort}`,
-        download: each.download,
-        upload: each.upload,
-        dlSpeed: each.curDownload,
-        ulSpeed: each.curUpload,
+        download: parseTraffic(each.download).join(" "),
+        upload: parseTraffic(each.upload).join(" "),
+        dlSpeed: parseTraffic(each.curDownload).join(" ") + "/s",
+        ulSpeed: parseTraffic(each.curUpload).join(" ") + "/s",
         chains,
         rule,
-        process: metadata.process || metadata.processPath,
-        time: each.start,
+        process: truncateStr(metadata.process || metadata.processPath),
+        time: dayjs(each.start).fromNow(),
         source: `${metadata.sourceIP}:${metadata.sourcePort}`,
         destinationIP: metadata.destinationIP,
         type: `${metadata.type}(${metadata.network})`,
+
+        connectionData: each,
       };
     });
   }, [connections]);
 
   return (
     <DataGrid
+      hideFooter
       rows={connRows}
       columns={columns}
+      onRowClick={(e) => onShowDetail(e.row.connectionData)}
       density="compact"
       sx={{ border: "none", "div:focus": { outline: "none !important" } }}
-      hideFooter
+      columnVisibilityModel={columnVisible}
+      onColumnVisibilityModelChange={(e) => setColumnVisible(e)}
     />
   );
 };
-
-export default ConnectionTable;

src/components/layout/layout-control.tsx

@@ -6,7 +6,7 @@ import {
   HorizontalRuleRounded,
 } from "@mui/icons-material";
 
-const LayoutControl = () => {
+export const LayoutControl = () => {
   const minWidth = 40;
 
   return (
@@ -37,5 +37,3 @@ const LayoutControl = () => {
     </>
   );
 };
-
-export default LayoutControl;

src/components/layout/layout-item.tsx

@@ -2,7 +2,7 @@ import { alpha, ListItem, ListItemButton, ListItemText } from "@mui/material";
 import { useMatch, useResolvedPath, useNavigate } from "react-router-dom";
 import type { LinkProps } from "react-router-dom";
 
-const LayoutItem = (props: LinkProps) => {
+export const LayoutItem = (props: LinkProps) => {
   const { to, children } = props;
 
   const resolved = useResolvedPath(to);
@@ -40,5 +40,3 @@ const LayoutItem = (props: LinkProps) => {
     </ListItem>
   );
 };
-
-export default LayoutItem;

src/components/layout/layout-traffic.tsx

@@ -1,74 +1,90 @@
-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 { 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 {
+  ArrowDownward,
+  ArrowUpward,
+  MemoryOutlined,
+} from "@mui/icons-material";
+import { useClashInfo } from "@/hooks/use-clash";
+import { useVerge } from "@/hooks/use-verge";
+import { TrafficGraph, type TrafficRef } from "./traffic-graph";
+import { useLogSetup } from "./use-log-setup";
+import { useVisibility } from "@/hooks/use-visibility";
+import { useWebsocket } from "@/hooks/use-websocket";
 import parseTraffic from "@/utils/parse-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>();
+export const LayoutTraffic = () => {
+  const { clashInfo } = useClashInfo();
+  const { verge } = useVerge();
 
   // whether hide traffic graph
-  const { data } = useSWR("getVergeConfig", getVergeConfig);
-  const trafficGraph = data?.traffic_graph ?? true;
+  const trafficGraph = verge?.traffic_graph ?? true;
+
+  const trafficRef = useRef<TrafficRef>(null);
+  const [traffic, setTraffic] = useState({ up: 0, down: 0 });
+  const [memory, setMemory] = useState({ inuse: 0 });
+  const pageVisible = useVisibility();
 
   // setup log ws during layout
   useLogSetup();
 
+  const { connect, disconnect } = useWebsocket((event) => {
+    const data = JSON.parse(event.data) as ITrafficItem;
+    trafficRef.current?.appendData(data);
+    setTraffic(data);
+  });
+
   useEffect(() => {
-    // should reconnect the traffic ws
-    const unlisten = listen("verge://refresh-clash-config", () =>
-      setRefresh({})
-    );
+    if (!clashInfo || !pageVisible) return;
+
+    const { server = "", secret = "" } = clashInfo;
+    connect(`ws://${server}/traffic?token=${encodeURIComponent(secret)}`);
 
     return () => {
-      unlisten.then((fn) => fn());
+      disconnect();
     };
-  }, []);
+  }, [clashInfo, pageVisible]);
+
+  /* --------- meta memory information --------- */
+  const isMetaCore = verge?.clash_core === "clash-meta";
+  const displayMemory = isMetaCore && (verge?.enable_memory_usage ?? true);
+
+  const memoryWs = useWebsocket(
+    (event) => {
+      setMemory(JSON.parse(event.data));
+    },
+    { onError: () => setMemory({ inuse: 0 }) }
+  );
 
   useEffect(() => {
-    let ws: WebSocket | null = null;
-
-    getInformation().then((result) => {
-      const { server = "", secret = "" } = result;
-      ws = new WebSocket(`ws://${server}/traffic?token=${secret}`);
-
-      ws.addEventListener("message", (event) => {
-        const data = JSON.parse(event.data) as ApiType.TrafficItem;
-        trafficRef.current?.appendData(data);
-        setTraffic(data);
-      });
-    });
-
-    return () => ws?.close();
-  }, [portValue, refresh]);
+    if (!clashInfo || !pageVisible || !displayMemory) return;
+    const { server = "", secret = "" } = clashInfo;
+    memoryWs.connect(
+      `ws://${server}/memory?token=${encodeURIComponent(secret)}`
+    );
+    return () => memoryWs.disconnect();
+  }, [clashInfo, pageVisible, displayMemory]);
 
   const [up, upUnit] = parseTraffic(traffic.up);
   const [down, downUnit] = parseTraffic(traffic.down);
+  const [inuse, inuseUnit] = parseTraffic(memory.inuse);
 
+  const iconStyle: any = {
+    sx: { mr: "8px", fontSize: 16 },
+  };
   const valStyle: any = {
     component: "span",
     color: "primary",
     textAlign: "center",
-    sx: { flex: "1 1 54px" },
+    sx: { flex: "1 1 56px", userSelect: "none" },
   };
   const unitStyle: any = {
     component: "span",
     color: "grey.500",
     fontSize: "12px",
     textAlign: "right",
-    sx: { flex: "0 1 28px", userSelect: "none" },
+    sx: { flex: "0 1 27px", userSelect: "none" },
   };
 
   return (
@@ -77,31 +93,44 @@ const LayoutTraffic = () => {
       position="relative"
       onClick={trafficRef.current?.toggleStyle}
     >
-      {trafficGraph && (
+      {trafficGraph && pageVisible && (
         <div style={{ width: "100%", height: 60, marginBottom: 6 }}>
-          <TrafficGraph instance={trafficRef} />
+          <TrafficGraph ref={trafficRef} />
         </div>
       )}
 
-      <Box mb={1.5} display="flex" alignItems="center" whiteSpace="nowrap">
-        <ArrowUpward
-          fontSize="small"
-          color={+up > 0 ? "primary" : "disabled"}
-        />
-        <Typography {...valStyle}>{up}</Typography>
-        <Typography {...unitStyle}>{upUnit}/s</Typography>
-      </Box>
+      <Box display="flex" flexDirection="column" gap={0.75}>
+        <Box display="flex" alignItems="center" whiteSpace="nowrap">
+          <ArrowUpward
+            {...iconStyle}
+            color={+up > 0 ? "primary" : "disabled"}
+          />
+          <Typography {...valStyle}>{up}</Typography>
+          <Typography {...unitStyle}>{upUnit}/s</Typography>
+        </Box>
 
-      <Box display="flex" alignItems="center" whiteSpace="nowrap">
-        <ArrowDownward
-          fontSize="small"
-          color={+down > 0 ? "primary" : "disabled"}
-        />
-        <Typography {...valStyle}>{down}</Typography>
-        <Typography {...unitStyle}>{downUnit}/s</Typography>
+        <Box display="flex" alignItems="center" whiteSpace="nowrap">
+          <ArrowDownward
+            {...iconStyle}
+            color={+down > 0 ? "primary" : "disabled"}
+          />
+          <Typography {...valStyle}>{down}</Typography>
+          <Typography {...unitStyle}>{downUnit}/s</Typography>
+        </Box>
+
+        {displayMemory && (
+          <Box
+            display="flex"
+            alignItems="center"
+            whiteSpace="nowrap"
+            title="Memory Usage"
+          >
+            <MemoryOutlined {...iconStyle} color="disabled" />
+            <Typography {...valStyle}>{inuse}</Typography>
+            <Typography {...unitStyle}>{inuseUnit}</Typography>
+          </Box>
+        )}
       </Box>
     </Box>
   );
 };
-
-export default LayoutTraffic;

src/components/layout/traffic-graph.tsx

@@ -1,4 +1,4 @@
-import { useEffect, useRef } from "react";
+import { forwardRef, useEffect, useImperativeHandle, useRef } from "react";
 import { useTheme } from "@mui/material";
 
 const maxPoint = 30;
@@ -16,34 +16,40 @@ 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;
-  }>;
+export interface TrafficRef {
+  appendData: (data: TrafficData) => void;
+  toggleStyle: () => void;
 }
 
 /**
  * draw the traffic graph
  */
-const TrafficGraph = (props: Props) => {
-  const { instance } = props;
-
+export const TrafficGraph = forwardRef<TrafficRef>((props, ref) => {
   const countRef = useRef(0);
   const styleRef = useRef(true);
   const listRef = useRef<TrafficData[]>(defaultList);
   const canvasRef = useRef<HTMLCanvasElement>(null!);
 
+  const cacheRef = useRef<TrafficData | null>(null);
+
   const { palette } = useTheme();
 
+  useImperativeHandle(ref, () => ({
+    appendData: (data: TrafficData) => {
+      cacheRef.current = data;
+    },
+    toggleStyle: () => {
+      styleRef.current = !styleRef.current;
+    },
+  }));
+
   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 data = cacheRef.current ? cacheRef.current : zero;
+      cacheRef.current = null;
 
       const list = listRef.current;
       if (list.length > maxPoint + 2) list.shift();
@@ -53,19 +59,9 @@ const TrafficGraph = (props: Props) => {
       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);
     };
   }, []);
@@ -196,6 +192,4 @@ const TrafficGraph = (props: Props) => {
   }, [palette]);
 
   return <canvas ref={canvasRef} style={{ width: "100%", height: "100%" }} />;
-};
-
-export default TrafficGraph;
+});

src/components/layout/update-button.tsx

@@ -1,17 +1,19 @@
 import useSWR from "swr";
-import { useState } from "react";
+import { useRef } from "react";
 import { Button } from "@mui/material";
 import { checkUpdate } from "@tauri-apps/api/updater";
-import UpdateDialog from "./update-dialog";
+import { UpdateViewer } from "../setting/mods/update-viewer";
+import { DialogRef } from "../base";
 
 interface Props {
   className?: string;
 }
 
-const UpdateButton = (props: Props) => {
+export const UpdateButton = (props: Props) => {
   const { className } = props;
 
-  const [dialogOpen, setDialogOpen] = useState(false);
+  const viewerRef = useRef<DialogRef>(null);
+
   const { data: updateInfo } = useSWR("checkUpdate", checkUpdate, {
     errorRetryCount: 2,
     revalidateIfStale: false,
@@ -22,21 +24,17 @@ const UpdateButton = (props: Props) => {
 
   return (
     <>
+      <UpdateViewer ref={viewerRef} />
+
       <Button
         color="error"
         variant="contained"
         size="small"
         className={className}
-        onClick={() => setDialogOpen(true)}
+        onClick={() => viewerRef.current?.open()}
       >
         New
       </Button>
-
-      {dialogOpen && (
-        <UpdateDialog open={dialogOpen} onClose={() => setDialogOpen(false)} />
-      )}
     </>
   );
 };
-
-export default UpdateButton;

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

@@ -1,18 +1,17 @@
-import useSWR from "swr";
 import { useEffect, useMemo } from "react";
 import { useRecoilState } from "recoil";
-import { createTheme } from "@mui/material";
+import { createTheme, Theme } 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";
+import { useVerge } from "@/hooks/use-verge";
 
 /**
- * custome theme
+ * custom theme
  */
-export default function useCustomTheme() {
-  const { data } = useSWR("getVergeConfig", getVergeConfig);
-  const { theme_mode, theme_setting } = data ?? {};
+export const useCustomTheme = () => {
+  const { verge } = useVerge();
+  const { theme_mode, theme_setting } = verge ?? {};
   const [mode, setMode] = useRecoilState(atomThemeMode);
 
   useEffect(() => {
@@ -37,30 +36,52 @@ export default function useCustomTheme() {
     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,
+    let theme: Theme;
+
+    try {
+      theme = createTheme({
+        breakpoints: {
+          values: { xs: 0, sm: 650, md: 900, lg: 1200, xl: 1536 },
         },
-      },
-      typography: {
-        // todo
-        fontFamily: setting.font_family
-          ? `${setting.font_family}, ${dt.font_family}`
-          : dt.font_family,
-      },
-    });
+        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,
+        },
+      });
+    } catch {
+      // fix #294
+      theme = createTheme({
+        breakpoints: {
+          values: { xs: 0, sm: 650, md: 900, lg: 1200, xl: 1536 },
+        },
+        palette: {
+          mode,
+          primary: { main: dt.primary_color },
+          secondary: { main: dt.secondary_color },
+          info: { main: dt.info_color },
+          error: { main: dt.error_color },
+          warning: { main: dt.warning_color },
+          success: { main: dt.success_color },
+          text: { primary: dt.primary_text, secondary: dt.secondary_text },
+        },
+        typography: { fontFamily: dt.font_family },
+      });
+    }
 
     // css
     const selectColor = mode === "light" ? "#f5f5f5" : "#d5d5d5";
@@ -100,4 +121,4 @@ export default function useCustomTheme() {
   }, [mode, theme_setting]);
 
   return { theme };
-}
+};

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

@@ -1,48 +1,39 @@
 import dayjs from "dayjs";
-import { useEffect, useState } from "react";
+import { useEffect } 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 { useClashInfo } from "@/hooks/use-clash";
 import { atomEnableLog, atomLogData } from "@/services/states";
+import { useWebsocket } from "@/hooks/use-websocket";
 
 const MAX_LOG_NUM = 1000;
 
 // setup the log websocket
-export default function useLogSetup() {
-  const [refresh, setRefresh] = useState({});
+export const useLogSetup = () => {
+  const { clashInfo } = useClashInfo();
 
   const enableLog = useRecoilValue(atomEnableLog);
   const setLogData = useSetRecoilState(atomLogData);
 
+  const { connect, disconnect } = useWebsocket((event) => {
+    const data = JSON.parse(event.data) as ILogItem;
+    const time = dayjs().format("MM-DD HH:mm:ss");
+    setLogData((l) => {
+      if (l.length >= MAX_LOG_NUM) l.shift();
+      return [...l, { ...data, time }];
+    });
+  });
+
   useEffect(() => {
-    if (!enableLog) return;
+    if (!enableLog || !clashInfo) 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({})
-    );
+    const { server = "", secret = "" } = clashInfo;
+    connect(`ws://${server}/logs?token=${encodeURIComponent(secret)}`);
 
     return () => {
-      ws.then((ws) => ws?.close());
-      unlisten.then((fn) => fn());
+      disconnect();
     };
-  }, [refresh, enableLog]);
-}
+  }, [clashInfo, enableLog]);
+};

src/components/log/log-item.tsx

@@ -1,26 +1,40 @@
 import { styled, Box } from "@mui/material";
 
-const Item = styled(Box)(({ theme }) => ({
+const Item = styled(Box)(({ theme: { palette, typography } }) => ({
   padding: "8px 0",
   margin: "0 12px",
   lineHeight: 1.35,
-  borderBottom: `1px solid ${theme.palette.divider}`,
+  borderBottom: `1px solid ${palette.divider}`,
   fontSize: "0.875rem",
+  fontFamily: typography.fontFamily,
   userSelect: "text",
-  "& .time": {},
+  "& .time": {
+    color: palette.text.secondary,
+  },
   "& .type": {
     display: "inline-block",
-    padding: "0 6px",
+    marginLeft: 8,
     textAlign: "center",
     borderRadius: 2,
     textTransform: "uppercase",
     fontWeight: "600",
   },
-  "& .data": {},
+  '& .type[data-type="error"], & .type[data-type="err"]': {
+    color: palette.error.main,
+  },
+  '& .type[data-type="warning"], & .type[data-type="warn"]': {
+    color: palette.warning.main,
+  },
+  '& .type[data-type="info"], & .type[data-type="inf"]': {
+    color: palette.info.main,
+  },
+  "& .data": {
+    color: palette.text.primary,
+  },
 }));
 
 interface Props {
-  value: ApiType.LogItem;
+  value: ILogItem;
 }
 
 const LogItem = (props: Props) => {
@@ -28,9 +42,15 @@ const LogItem = (props: Props) => {
 
   return (
     <Item>
-      <span className="time">{value.time}</span>
-      <span className="type">{value.type}</span>
-      <span className="data">{value.payload}</span>
+      <div>
+        <span className="time">{value.time}</span>
+        <span className="type" data-type={value.type.toLowerCase()}>
+          {value.type}
+        </span>
+      </div>
+      <div>
+        <span className="data">{value.payload}</span>
+      </div>
     </Item>
   );
 };

src/components/profile/editor-viewer.tsx

@@ -11,7 +11,7 @@ import {
 } from "@mui/material";
 import { atomThemeMode } from "@/services/states";
 import { readProfileFile, saveProfileFile } from "@/services/cmds";
-import Notice from "../base/base-notice";
+import { Notice } from "@/components/base";
 
 import "monaco-editor/esm/vs/basic-languages/javascript/javascript.contribution.js";
 import "monaco-editor/esm/vs/basic-languages/yaml/yaml.contribution.js";
@@ -26,7 +26,7 @@ interface Props {
   onChange?: () => void;
 }
 
-const FileEditor = (props: Props) => {
+export const EditorViewer = (props: Props) => {
   const { uid, open, mode, onClose, onChange } = props;
 
   const { t } = useTranslation();
@@ -77,7 +77,7 @@ const FileEditor = (props: Props) => {
     <Dialog open={open} onClose={onClose}>
       <DialogTitle>{t("Edit File")}</DialogTitle>
 
-      <DialogContent sx={{ width: 520, pb: 1 }}>
+      <DialogContent sx={{ width: 520, pb: 1, userSelect: "text" }}>
         <div style={{ width: "100%", height: "420px" }} ref={editorRef} />
       </DialogContent>
 
@@ -92,5 +92,3 @@ const FileEditor = (props: Props) => {
     </Dialog>
   );
 };
-
-export default FileEditor;

src/components/profile/enhanced.tsx

@@ -1,129 +0,0 @@
-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-input.tsx

@@ -7,7 +7,7 @@ interface Props {
   onChange: (value: string) => void;
 }
 
-const FileInput = (props: Props) => {
+export const FileInput = (props: Props) => {
   const { onChange } = props;
 
   const { t } = useTranslation();
@@ -59,5 +59,3 @@ const FileInput = (props: Props) => {
     </Box>
   );
 };
-
-export default FileInput;

src/components/profile/info-editor.tsx

@@ -1,213 +0,0 @@
-import { mutate } from "swr";
-import { useEffect, useState } from "react";
-import { useLockFn, useSetState } from "ahooks";
-import { useTranslation } from "react-i18next";
-import {
-  Button,
-  Collapse,
-  Dialog,
-  DialogActions,
-  DialogContent,
-  DialogTitle,
-  FormControlLabel,
-  IconButton,
-  Switch,
-  TextField,
-} from "@mui/material";
-import { Settings } from "@mui/icons-material";
-import { patchProfile } from "@/services/cmds";
-import { version } from "@root/package.json";
-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) {
-      const { option } = itemData;
-      setForm({ ...itemData });
-      setOption(option ?? {});
-      setShowOpt(
-        itemData.type === "remote" &&
-          (!!option?.user_agent ||
-            !!option?.update_interval ||
-            !!option?.self_proxy ||
-            !!option?.with_proxy)
-      );
-    }
-  }, [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()}
-          />
-        )}
-
-        {(type === "remote" || 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()}
-          />
-        )}
-
-        <Collapse
-          in={type === "remote" && showOpt}
-          timeout="auto"
-          unmountOnExit
-        >
-          <TextField
-            {...textFieldProps}
-            label="User Agent"
-            value={option.user_agent}
-            placeholder={`clash-verge/v${version}`}
-            onChange={(e) => setOption({ user_agent: e.target.value })}
-            onKeyDown={(e) => e.key === "Enter" && onUpdate()}
-          />
-
-          <FormControlLabel
-            label={t("Use System Proxy")}
-            labelPlacement="start"
-            sx={{ ml: 0, my: 1 }}
-            control={
-              <Switch
-                color="primary"
-                checked={option.with_proxy ?? false}
-                onChange={(_e, c) =>
-                  setOption((o) => ({
-                    self_proxy: c ? false : o.self_proxy ?? false,
-                    with_proxy: c,
-                  }))
-                }
-              />
-            }
-          />
-
-          <FormControlLabel
-            label={t("Use Clash Proxy")}
-            labelPlacement="start"
-            sx={{ ml: 0, my: 1 }}
-            control={
-              <Switch
-                color="primary"
-                checked={option.self_proxy ?? false}
-                onChange={(_e, c) =>
-                  setOption((o) => ({
-                    with_proxy: c ? false : o.with_proxy ?? false,
-                    self_proxy: c,
-                  }))
-                }
-              />
-            }
-          />
-        </Collapse>
-      </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;

src/components/profile/log-viewer.tsx

@@ -1,3 +1,4 @@
+import { Fragment } from "react";
 import { useTranslation } from "react-i18next";
 import {
   Button,
@@ -9,8 +10,7 @@ import {
   Divider,
   Typography,
 } from "@mui/material";
-import BaseEmpty from "../base/base-empty";
-import { Fragment } from "react";
+import { BaseEmpty } from "@/components/base";
 
 interface Props {
   open: boolean;
@@ -18,7 +18,7 @@ interface Props {
   onClose: () => void;
 }
 
-const LogViewer = (props: Props) => {
+export const LogViewer = (props: Props) => {
   const { open, logInfo, onClose } = props;
 
   const { t } = useTranslation();
@@ -67,5 +67,3 @@ const LogViewer = (props: Props) => {
     </Dialog>
   );
 };
-
-export default LogViewer;

src/components/profile/profile-box.tsx

@@ -1,43 +1,44 @@
 import { alpha, Box, styled } from "@mui/material";
 
-const ProfileBox = styled(Box)(({ theme, "aria-selected": selected }) => {
-  const { mode, primary, text, grey, background } = theme.palette;
-  const key = `${mode}-${!!selected}`;
+export const ProfileBox = styled(Box)(
+  ({ theme, "aria-selected": selected }) => {
+    const { mode, primary, text, grey, background } = theme.palette;
+    const key = `${mode}-${!!selected}`;
 
-  const backgroundColor = {
-    "light-true": alpha(primary.main, 0.2),
-    "light-false": alpha(background.paper, 0.75),
-    "dark-true": alpha(primary.main, 0.45),
-    "dark-false": alpha(grey[700], 0.45),
-  }[key]!;
+    const backgroundColor = {
+      "light-true": alpha(primary.main, 0.2),
+      "light-false": alpha(background.paper, 0.75),
+      "dark-true": alpha(primary.main, 0.45),
+      "dark-false": alpha(grey[700], 0.45),
+    }[key]!;
 
-  const color = {
-    "light-true": text.secondary,
-    "light-false": text.secondary,
-    "dark-true": alpha(text.secondary, 0.85),
-    "dark-false": alpha(text.secondary, 0.65),
-  }[key]!;
+    const color = {
+      "light-true": text.secondary,
+      "light-false": text.secondary,
+      "dark-true": alpha(text.secondary, 0.85),
+      "dark-false": alpha(text.secondary, 0.65),
+    }[key]!;
 
-  const h2color = {
-    "light-true": primary.main,
-    "light-false": text.primary,
-    "dark-true": primary.light,
-    "dark-false": text.primary,
-  }[key]!;
+    const h2color = {
+      "light-true": primary.main,
+      "light-false": text.primary,
+      "dark-true": primary.light,
+      "dark-false": text.primary,
+    }[key]!;
 
-  return {
-    width: "100%",
-    display: "block",
-    cursor: "pointer",
-    textAlign: "left",
-    borderRadius: theme.shape.borderRadius,
-    boxShadow: theme.shadows[2],
-    padding: "8px 16px",
-    boxSizing: "border-box",
-    backgroundColor,
-    color,
-    "& h2": { color: h2color },
-  };
-});
-
-export default ProfileBox;
+    return {
+      position: "relative",
+      width: "100%",
+      display: "block",
+      cursor: "pointer",
+      textAlign: "left",
+      borderRadius: theme.shape.borderRadius,
+      boxShadow: theme.shadows[2],
+      padding: "8px 16px",
+      boxSizing: "border-box",
+      backgroundColor,
+      color,
+      "& h2": { color: h2color },
+    };
+  }
+);

src/components/profile/profile-item.tsx

@@ -12,15 +12,15 @@ import {
   keyframes,
   MenuItem,
   Menu,
+  CircularProgress,
 } from "@mui/material";
 import { RefreshRounded } from "@mui/icons-material";
 import { atomLoadingCache } from "@/services/states";
 import { updateProfile, deleteProfile, viewProfile } from "@/services/cmds";
+import { Notice } from "@/components/base";
+import { EditorViewer } from "./editor-viewer";
+import { ProfileBox } from "./profile-box";
 import parseTraffic from "@/utils/parse-traffic";
-import ProfileBox from "./profile-box";
-import InfoEditor from "./info-editor";
-import FileEditor from "./file-editor";
-import Notice from "../base/base-notice";
 
 const round = keyframes`
   from { transform: rotate(0deg); }
@@ -29,12 +29,14 @@ const round = keyframes`
 
 interface Props {
   selected: boolean;
-  itemData: CmdType.ProfileItem;
+  activating: boolean;
+  itemData: IProfileItem;
   onSelect: (force: boolean) => void;
+  onEdit: () => void;
 }
 
-const ProfileItem = (props: Props) => {
-  const { selected, itemData, onSelect } = props;
+export const ProfileItem = (props: Props) => {
+  const { selected, activating, itemData, onSelect, onEdit } = props;
 
   const { t } = useTranslation();
   const [anchorEl, setAnchorEl] = useState<any>(null);
@@ -55,7 +57,7 @@ const ProfileItem = (props: Props) => {
 
   const loading = loadingCache[itemData.uid] ?? false;
 
-  // interval update from now field
+  // interval update fromNow field
   const [, setRefresh] = useState({});
   useEffect(() => {
     if (!hasUrl) return;
@@ -83,12 +85,11 @@ const ProfileItem = (props: Props) => {
     };
   }, [hasUrl, updated]);
 
-  const [editOpen, setEditOpen] = useState(false);
   const [fileOpen, setFileOpen] = useState(false);
 
   const onEditInfo = () => {
     setAnchorEl(null);
-    setEditOpen(true);
+    onEdit();
   };
 
   const onEditFile = () => {
@@ -117,7 +118,7 @@ const ProfileItem = (props: Props) => {
     setAnchorEl(null);
     setLoadingCache((cache) => ({ ...cache, [itemData.uid]: true }));
 
-    const option: Partial<CmdType.ProfileOption> = {};
+    const option: Partial<IProfileOption> = {};
 
     if (type === 0) {
       option.with_proxy = false;
@@ -193,6 +194,25 @@ const ProfileItem = (props: Props) => {
           event.preventDefault();
         }}
       >
+        {activating && (
+          <Box
+            sx={{
+              position: "absolute",
+              display: "flex",
+              justifyContent: "center",
+              alignItems: "center",
+              top: 10,
+              left: 10,
+              right: 10,
+              bottom: 2,
+              zIndex: 10,
+              backdropFilter: "blur(2px)",
+            }}
+          >
+            <CircularProgress size={20} />
+          </Box>
+        )}
+
         <Box position="relative">
           <Typography
             width="calc(100% - 36px)"
@@ -280,6 +300,7 @@ const ProfileItem = (props: Props) => {
         anchorPosition={position}
         anchorReference="anchorPosition"
         transitionDuration={225}
+        MenuListProps={{ sx: { py: 0.5 } }}
         onContextMenu={(e) => {
           setAnchorEl(null);
           e.preventDefault();
@@ -289,20 +310,15 @@ const ProfileItem = (props: Props) => {
           <MenuItem
             key={item.label}
             onClick={item.handler}
-            sx={{ minWidth: 133 }}
+            sx={{ minWidth: 120 }}
+            dense
           >
             {t(item.label)}
           </MenuItem>
         ))}
       </Menu>
 
-      <InfoEditor
-        open={editOpen}
-        itemData={itemData}
-        onClose={() => setEditOpen(false)}
-      />
-
-      <FileEditor
+      <EditorViewer
         uid={uid}
         open={fileOpen}
         mode="yaml"
@@ -323,5 +339,3 @@ function parseExpire(expire?: number) {
   if (!expire) return "-";
   return dayjs(expire * 1000).format("YYYY-MM-DD");
 }
-
-export default ProfileItem;

src/components/profile/profile-more.tsx

@@ -13,15 +13,14 @@ import {
 } from "@mui/material";
 import { FeaturedPlayListRounded } from "@mui/icons-material";
 import { viewProfile } from "@/services/cmds";
-import InfoEditor from "./info-editor";
-import FileEditor from "./file-editor";
-import ProfileBox from "./profile-box";
-import LogViewer from "./log-viewer";
-import Notice from "../base/base-notice";
+import { Notice } from "@/components/base";
+import { EditorViewer } from "./editor-viewer";
+import { ProfileBox } from "./profile-box";
+import { LogViewer } from "./log-viewer";
 
 interface Props {
   selected: boolean;
-  itemData: CmdType.ProfileItem;
+  itemData: IProfileItem;
   enableNum: number;
   logInfo?: [string, string][];
   onEnable: () => void;
@@ -29,10 +28,11 @@ interface Props {
   onMoveTop: () => void;
   onMoveEnd: () => void;
   onDelete: () => void;
+  onEdit: () => void;
 }
 
 // profile enhanced item
-const ProfileMore = (props: Props) => {
+export const ProfileMore = (props: Props) => {
   const {
     selected,
     itemData,
@@ -43,19 +43,19 @@ const ProfileMore = (props: Props) => {
     onMoveTop,
     onMoveEnd,
     onDelete,
+    onEdit,
   } = props;
 
   const { uid, type } = itemData;
   const { t, i18n } = useTranslation();
   const [anchorEl, setAnchorEl] = useState<any>(null);
   const [position, setPosition] = useState({ left: 0, top: 0 });
-  const [editOpen, setEditOpen] = useState(false);
   const [fileOpen, setFileOpen] = useState(false);
   const [logOpen, setLogOpen] = useState(false);
 
   const onEditInfo = () => {
     setAnchorEl(null);
-    setEditOpen(true);
+    onEdit();
   };
 
   const onEditFile = () => {
@@ -199,6 +199,7 @@ const ProfileMore = (props: Props) => {
         anchorPosition={position}
         anchorReference="anchorPosition"
         transitionDuration={225}
+        MenuListProps={{ sx: { py: 0.5 } }}
         onContextMenu={(e) => {
           setAnchorEl(null);
           e.preventDefault();
@@ -210,20 +211,15 @@ const ProfileMore = (props: Props) => {
             <MenuItem
               key={item.label}
               onClick={item.handler}
-              sx={{ minWidth: 133 }}
+              sx={{ minWidth: 120 }}
+              dense
             >
               {t(item.label)}
             </MenuItem>
           ))}
       </Menu>
 
-      <InfoEditor
-        open={editOpen}
-        itemData={itemData}
-        onClose={() => setEditOpen(false)}
-      />
-
-      <FileEditor
+      <EditorViewer
         uid={uid}
         open={fileOpen}
         mode={type === "merge" ? "yaml" : "javascript"}
@@ -245,5 +241,3 @@ function parseExpire(expire?: number) {
   if (!expire) return "-";
   return dayjs(expire * 1000).format("YYYY-MM-DD");
 }
-
-export default ProfileMore;