Release - 2.1.2 真·臻

add: i18n text for settings page. (#2815 )
feat: better setting UI layout (#2814 )
2026-10-15 05:40:47 +08:00 · 2025-03-01 01:49:01 +08:00 · 2025-03-01 01:36:36 +08:00 · 2025-03-01 01:29:23 +08:00 · 2025-03-01 01:29:23 +08:00 · 2025-03-01 01:29:23 +08:00
183 changed files with 21732 additions and 8648 deletions
@@ -0,0 +1,5 @@
+[target.aarch64-unknown-linux-gnu]
+linker = "aarch64-linux-gnu-gcc"
+
+[target.armv7-unknown-linux-gnueabihf]
+linker = "arm-linux-gnueabihf-gcc"
@@ -24,7 +24,13 @@ body:
    id: description
    attributes:
      label: 问题描述 / Describe the bug
-      description: 详细清晰地描述你遇到的问题 / A clear and concise description of what the bug is
+      description: 详细清晰地描述你遇到的问题，并配合截图 / Describe the problem you encountered in detail and clearly, and provide screenshots
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: 软件版本 / Verge Version
+      description: 请提供Verge的具体版本，如果是alpha版本，请注明下载时间(精确到小时分钟) / Please provide the specific version of Verge. If it is an alpha version, please indicate the download time (accurate to hours and minutes)
    validations:
      required: true
  - type: textarea
@@ -51,6 +57,6 @@ body:
  - type: textarea
    attributes:
      label: 日志 / Log
-      description: 请提供完整或相关部分的Debug日志 / Please provide the complete or relevant part of the Debug log
+      description: 请提供完整或相关部分的Debug日志（请在“软件左侧菜单”->“设置”->“日志等级”调整到debug，Verge错误请把“杂项设置”->“app日志等级”调整到debug/trace，并重启Verge生效。日志文件在“软件左侧菜单”->“设置”->“日志目录”下） / Please provide a complete or relevant part of the Debug log (please adjust the "Log level" to debug in "Software left menu" -> "Settings" -> "Log level". If there is a Verge error, please adjust "Miscellaneous settings" -> "app log level" to trace, and restart Verge to take effect. The log file is under "Software left menu" -> "Settings" -> "Log directory")
    validations:
      required: true
@@ -1,4 +0,0 @@
-FROM rust:buster
-COPY entrypoint.sh /entrypoint.sh
-RUN chmod a+x /entrypoint.sh
-ENTRYPOINT ["/entrypoint.sh"] 
@@ -1,14 +0,0 @@
-name: "Build for Linux"
-branding:
-  icon: user-check
-  color: gray-dark
-inputs:
-  target:
-    required: true
-    description: "Rust Target"
-
-runs:
-  using: "docker"
-  image: "Dockerfile"
-  args:
-    - ${{ inputs.target }}
@@ -1,5 +0,0 @@
-pnpm install
-pnpm check $INPUT_TARGET
-sed -i "s/#openssl/openssl={version=\"0.10\",features=[\"vendored\"]}/g" src-tauri/Cargo.toml
-
-pnpm build --target $INPUT_TARGET
@@ -1,53 +0,0 @@
-#!/bin/bash
-
-wget https://nodejs.org/dist/v20.10.0/node-v20.10.0-linux-x64.tar.xz
-tar -Jxvf ./node-v20.10.0-linux-x64.tar.xz
-export PATH=$(pwd)/node-v20.10.0-linux-x64/bin:$PATH
-npm install pnpm -g
-
-rustup target add "$INPUT_TARGET"
-
-if [ "$INPUT_TARGET" = "x86_64-unknown-linux-gnu" ]; then
-    apt-get update
-    apt-get install -y libgtk-3-dev libwebkit2gtk-4.0-dev libayatana-appindicator3-dev librsvg2-dev patchelf
-elif [ "$INPUT_TARGET" = "i686-unknown-linux-gnu" ]; then
-    dpkg --add-architecture i386
-    apt-get update
-    apt-get install -y libstdc++6:i386 libgdk-pixbuf2.0-dev:i386 libatomic1:i386 gcc-multilib g++-multilib libwebkit2gtk-4.0-dev:i386 libssl-dev:i386 libgtk-3-dev:i386 librsvg2-dev:i386 patchelf:i386 libayatana-appindicator3-dev:i386
-    export PKG_CONFIG_PATH=/usr/lib/i386-linux-gnu/pkgconfig/:$PKG_CONFIG_PATH
-    export PKG_CONFIG_SYSROOT_DIR=/
-elif [ "$INPUT_TARGET" = "aarch64-unknown-linux-gnu" ]; then
-    dpkg --add-architecture arm64
-    apt-get update
-    apt-get install -y libncurses6:arm64 libtinfo6:arm64 linux-libc-dev:arm64 libncursesw6:arm64 libssl3:arm64 libcups2:arm64
-    apt-get install -y --no-install-recommends g++-aarch64-linux-gnu libc6-dev-arm64-cross libwebkit2gtk-4.0-dev:arm64 libgtk-3-dev:arm64 patchelf:arm64 librsvg2-dev:arm64 libayatana-appindicator3-dev:arm64
-    export CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER=aarch64-linux-gnu-gcc
-    export CC_aarch64_unknown_linux_gnu=aarch64-linux-gnu-gcc
-    export CXX_aarch64_unknown_linux_gnu=aarch64-linux-gnu-g++
-    export PKG_CONFIG_PATH=/usr/lib/aarch64-linux-gnu/pkgconfig
-    export PKG_CONFIG_ALLOW_CROSS=1
-elif [ "$INPUT_TARGET" = "armv7-unknown-linux-gnueabihf" ]; then
-    dpkg --add-architecture armhf
-    apt-get update
-    apt-get install -y libncurses6:armhf libtinfo6:armhf linux-libc-dev:armhf libncursesw6:armhf libssl3:armhf libcups2:armhf
-    apt-get install -y --no-install-recommends g++-arm-linux-gnueabihf libc6-dev-armhf-cross libwebkit2gtk-4.0-dev:armhf libgtk-3-dev:armhf patchelf:armhf librsvg2-dev:armhf libayatana-appindicator3-dev:armhf
-    export CARGO_TARGET_ARMV7_UNKNOWN_LINUX_GNUEABIHF_LINKER=arm-linux-gnueabihf-gcc
-    export CC_armv7_unknown_linux_gnueabihf=arm-linux-gnueabihf-gcc
-    export CXX_armv7_unknown_linux_gnueabihf=arm-linux-gnueabihf-g++
-    export PKG_CONFIG_PATH=/usr/lib/arm-linux-gnueabihf/pkgconfig
-    export PKG_CONFIG_ALLOW_CROSS=1
-elif [ "$INPUT_TARGET" = "riscv64gc-unknown-linux-gnu" ]; then
-    dpkg --add-architecture riscv64
-    apt-get update
-    apt-get install -y libncurses6:riscv64 libtinfo6:riscv64 linux-libc-dev:riscv64 libncursesw6:riscv64 libssl3:riscv64 libcups2:riscv64
-    apt-get install -y --no-install-recommends g++-riscv64-linux-gnu libc6-dev-riscv64-cross libwebkit2gtk-4.0-dev:riscv64 libgtk-3-dev:riscv64 patchelf:riscv64 librsvg2-dev:riscv64 libayatana-appindicator3-dev:riscv64
-    export CARGO_TARGET_RISCV64_UNKNOWN_LINUX_GNU_LINKER=riscv64-linux-gnu-gcc
-    export CC_riscv64_unknown_linux_gnu=riscv64-linux-gnu-gcc
-    export CXX_riscv64_unknown_linux_gnu=riscv64-linux-gnu-g++
-    export PKG_CONFIG_PATH=/usr/lib/riscv64-linux-gnu/pkgconfig
-    export PKG_CONFIG_ALLOW_CROSS=1
-else
-    echo "Unknown target: $INPUT_TARGET" && exit 1
-fi
-
-bash .github/build-for-linux/build.sh
@@ -2,9 +2,6 @@ name: Alpha Build

 on:
  workflow_dispatch:
-  push:
-    branches: [main]
-    tags-ignore: [updater, alpha]
 permissions: write-all
 env:
  CARGO_INCREMENTAL: 0
@@ -22,14 +19,14 @@ jobs:
        include:
          - os: windows-latest
            target: x86_64-pc-windows-msvc
-          - os: windows-latest
-            target: i686-pc-windows-msvc
          - os: windows-latest
            target: aarch64-pc-windows-msvc
          - os: macos-latest
            target: aarch64-apple-darwin
          - os: macos-latest
            target: x86_64-apple-darwin
+          - os: ubuntu-22.04
+            target: x86_64-unknown-linux-gnu

    runs-on: ${{ matrix.os }}
    steps:
@@ -37,7 +34,7 @@ jobs:
        uses: actions/checkout@v4

      - name: Install Rust Stable
-        uses: dtolnay/rust-toolchain@1.77.0
+        uses: dtolnay/rust-toolchain@stable

      - name: Add Rust Target
        run: rustup target add ${{ matrix.target }}
@@ -49,10 +46,16 @@ jobs:
          cache-all-crates: true
          cache-on-failure: true

+      - name: Install dependencies (ubuntu only)
+        if: matrix.os == 'ubuntu-22.04'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librsvg2-dev patchelf
+
      - name: Install Node
        uses: actions/setup-node@v4
        with:
-          node-version: "20"
+          node-version: "22"

      - uses: pnpm/action-setup@v4
        name: Install pnpm
@@ -64,13 +67,16 @@ jobs:
          pnpm i
          pnpm check ${{ matrix.target }}

+      - name: Alpha Version update
+        run: pnpm run fix-alpha-version
+
      - name: Tauri build
        uses: tauri-apps/tauri-action@v0
        env:
          NODE_OPTIONS: "--max_old_space_size=4096"
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
-          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
          APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_SIGNING_IDENTITY }}
@@ -92,37 +98,112 @@ jobs:
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

-  alpha-for-linux:
+  alpha-for-linux-arm:
    strategy:
      fail-fast: false
      matrix:
        include:
-          - os: ubuntu-latest
-            target: x86_64-unknown-linux-gnu
-          - os: ubuntu-latest
-            target: i686-unknown-linux-gnu
-          - os: ubuntu-latest
+          - os: ubuntu-22.04
            target: aarch64-unknown-linux-gnu
-          - os: ubuntu-latest
+            arch: arm64
+          - os: ubuntu-22.04
            target: armv7-unknown-linux-gnueabihf
+            arch: armhf
    runs-on: ${{ matrix.os }}
    steps:
      - name: Checkout Repository
        uses: actions/checkout@v4

+      - name: Install Rust Stable
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Add Rust Target
+        run: rustup target add ${{ matrix.target }}
+
+      - name: Rust Cache
+        uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: src-tauri
+          cache-all-crates: true
+
+      - name: Install Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          run_install: false
+
+      - name: Pnpm install and check
+        run: |
+          pnpm i
+          pnpm check ${{ matrix.target }}
+
+      - name: "Setup for linux"
+        run: |-
+          sudo ls -lR /etc/apt/
+
+          cat > /tmp/sources.list << EOF
+          deb [arch=amd64,i386] http://archive.ubuntu.com/ubuntu jammy main multiverse universe restricted
+          deb [arch=amd64,i386] http://archive.ubuntu.com/ubuntu jammy-security main multiverse universe restricted
+          deb [arch=amd64,i386] http://archive.ubuntu.com/ubuntu jammy-updates main multiverse universe restricted
+          deb [arch=amd64,i386] http://archive.ubuntu.com/ubuntu jammy-backports main multiverse universe restricted
+
+          deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy main multiverse universe restricted
+          deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy-security main multiverse universe restricted
+          deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy-updates main multiverse universe restricted
+          deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy-backports main multiverse universe restricted
+          EOF
+
+          sudo mv /etc/apt/sources.list /etc/apt/sources.list.default
+          sudo mv /tmp/sources.list /etc/apt/sources.list
+
+          sudo dpkg --add-architecture ${{ matrix.arch }}
+          sudo apt update
+
+          sudo apt install -y \
+            libwebkit2gtk-4.1-dev:${{ matrix.arch }} \
+            libayatana-appindicator3-dev:${{ matrix.arch }} \
+            libssl-dev:${{ matrix.arch }} \
+            patchelf:${{ matrix.arch }} \
+            librsvg2-dev:${{ matrix.arch }}
+
+      - name: "Install aarch64 tools"
+        if: matrix.target == 'aarch64-unknown-linux-gnu'
+        run: |
+          sudo apt install -y \
+            gcc-aarch64-linux-gnu \
+            g++-aarch64-linux-gnu
+
+      - name: "Install armv7 tools"
+        if: matrix.target == 'armv7-unknown-linux-gnueabihf'
+        run: |
+          sudo apt install -y \
+            gcc-arm-linux-gnueabihf \
+            g++-arm-linux-gnueabihf
+
      - name: Build for Linux
-        uses: ./.github/build-for-linux
+        run: |
+          export PKG_CONFIG_ALLOW_CROSS=1
+          if [ "${{ matrix.target }}" == "aarch64-unknown-linux-gnu" ]; then
+            export PKG_CONFIG_PATH=/usr/lib/aarch64-linux-gnu/pkgconfig/:$PKG_CONFIG_PATH
+            export PKG_CONFIG_SYSROOT_DIR=/usr/aarch64-linux-gnu/
+          elif [ "${{ matrix.target }}" == "armv7-unknown-linux-gnueabihf" ]; then
+            export PKG_CONFIG_PATH=/usr/lib/arm-linux-gnueabihf/pkgconfig/:$PKG_CONFIG_PATH
+            export PKG_CONFIG_SYSROOT_DIR=/usr/arm-linux-gnueabihf/
+          fi
+          pnpm build --target ${{ matrix.target }}
        env:
          NODE_OPTIONS: "--max_old_space_size=4096"
-          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
-          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
-        with:
-          target: ${{ matrix.target }}
+          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}

      - name: Get Version
        run: |
          sudo apt-get update
-          sudo apt-get install jq
+          sudo apt-get install jq 
          echo "VERSION=$(cat package.json | jq '.version' | tr -d '"')" >> $GITHUB_ENV
          echo "BUILDTIME=$(TZ=Asia/Shanghai date)" >> $GITHUB_ENV

@@ -146,9 +227,6 @@ jobs:
          - os: windows-latest
            target: x86_64-pc-windows-msvc
            arch: x64
-          - os: windows-latest
-            target: i686-pc-windows-msvc
-            arch: x86
          - os: windows-latest
            target: aarch64-pc-windows-msvc
            arch: arm64
@@ -170,7 +248,7 @@ jobs:
      - name: Install Node
        uses: actions/setup-node@v4
        with:
-          node-version: "20"
+          node-version: "22"

      - uses: pnpm/action-setup@v4
        name: Install pnpm
@@ -195,17 +273,31 @@ jobs:
        env:
          NODE_OPTIONS: "--max_old_space_size=4096"
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
-          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
        with:
          tauriScript: pnpm
          args: --target ${{ matrix.target }}

      - name: Rename
        run: |
-          Rename-Item '.\src-tauri\target\${{ matrix.target }}\release\bundle\nsis\Clash Verge_${{steps.build.outputs.appVersion}}_${{ matrix.arch }}-setup.exe' 'Clash Verge_${{steps.build.outputs.appVersion}}_${{ matrix.arch }}_fixed_webview2-setup.exe'
-          Rename-Item '.\src-tauri\target\${{ matrix.target }}\release\bundle\nsis\Clash Verge_${{steps.build.outputs.appVersion}}_${{ matrix.arch }}-setup.nsis.zip' 'Clash Verge_${{steps.build.outputs.appVersion}}_${{ matrix.arch }}_fixed_webview2-setup.nsis.zip'
-          Rename-Item '.\src-tauri\target\${{ matrix.target }}\release\bundle\nsis\Clash Verge_${{steps.build.outputs.appVersion}}_${{ matrix.arch }}-setup.nsis.zip.sig' 'Clash Verge_${{steps.build.outputs.appVersion}}_${{ matrix.arch }}_fixed_webview2-setup.nsis.zip.sig'
+          $files = Get-ChildItem ".\src-tauri\target\${{ matrix.target }}\release\bundle\nsis\*-setup.exe"
+          foreach ($file in $files) {
+            $newName = $file.Name -replace "-setup\.exe$", "_fixed_webview2-setup.exe"
+            Rename-Item $file.FullName $newName
+          }
+
+          $files = Get-ChildItem ".\src-tauri\target\${{ matrix.target }}\release\bundle\nsis\*.nsis.zip"
+          foreach ($file in $files) {
+            $newName = $file.Name -replace "-setup\.nsis\.zip$", "_fixed_webview2-setup.nsis.zip"
+            Rename-Item $file.FullName $newName
+          }
+
+          $files = Get-ChildItem ".\src-tauri\target\${{ matrix.target }}\release\bundle\nsis\*.nsis.zip.sig"
+          foreach ($file in $files) {
+            $newName = $file.Name -replace "-setup\.nsis\.zip\.sig$", "_fixed_webview2-setup.nsis.zip.sig"
+            Rename-Item $file.FullName $newName
+          }

      - name: Upload Release
        uses: softprops/action-gh-release@v2
@@ -225,7 +317,7 @@ jobs:
  update_tag:
    name: Update tag
    runs-on: ubuntu-latest
-    needs: [alpha, alpha-for-linux, alpha-for-fixed-webview2]
+    needs: [alpha, alpha-for-linux-arm, alpha-for-fixed-webview2]
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
@@ -235,44 +327,41 @@ jobs:
          echo "BUILDTIME=$(TZ=Asia/Shanghai date)" >> $GITHUB_ENV
        shell: bash

-      - name: Update Tag
-        uses: richardsimko/update-tag@v1
-        with:
-          tag_name: alpha
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      # - name: Update Tag
+      #   uses: richardsimko/update-tag@v1
+      #   with:
+      #     tag_name: alpha
+      # env:
+      #   GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

      - run: |
          cat > release.txt << 'EOF'
          ## 我应该下载哪个版本？

-          ### MacOS (提示文件损坏或开发者无法验证请查看下面FAQ)
+          ### MacOS
          - MacOS intel芯片: x64.dmg
          - MacOS apple M芯片: aarch64.dmg

          ### Linux
          - Linux 64位: amd64.deb/amd64.rpm
-          - Linux 32位: i386.deb/i386.rpm
-          - Linux arm64架构: arm64.deb/aarch64.rpm
+          - Linux arm64 architecture: arm64.deb/aarch64.rpm
          - Linux armv7架构: armhf.deb/armhfp.rpm

          ### Windows (Win7 用户请查看下面FAQ中的解决方案)
          #### 正常版本(推荐)
          - 64位: x64-setup.exe
-          - 32位: x86-setup.exe
          - arm64架构: arm64-setup.exe
-          #### 便携版(不推荐使用，无法自动更新)
-          - 64位: x64_portable.zip
-          - 32位: x86_portable.zip
-          - arm64架构: arm64_portable.zip
-          #### 内置Webview2版(体积较大，仅在企业版系统或Win7无法安装webview2时使用)
+          #### 便携版问题很多不再提供
+          #### 内置Webview2版(体积较大，仅在企业版系统或无法安装webview2时使用)
          - 64位: x64_fixed_webview2-setup.exe
-          - 32位: x86_fixed_webview2-setup.exe
          - arm64架构: arm64_fixed_webview2-setup.exe

          ### FAQ

-          - [FAQ](https://clash-verge-rev.github.io/faq/windows.html)
+          - [常见问题](https://clash-verge-rev.github.io/faq/windows.html)
+
+          ### 稳定机场VPN推荐
+          - [狗狗加速](https://verge.dginv.click/#/register?code=oaxsAGo6)

          Created at  ${{ env.BUILDTIME }}.
          EOF
@@ -0,0 +1,94 @@
+name: Development Test
+
+on:
+  workflow_dispatch:
+permissions: write-all
+env:
+  CARGO_INCREMENTAL: 0
+  RUST_BACKTRACE: short
+concurrency:
+  # only allow per workflow per commit (and not pr) to run at a time
+  group: "${{ github.workflow }} - ${{ github.head_ref || github.ref }}"
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+jobs:
+  dev:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-latest
+            target: x86_64-pc-windows-msvc
+            bundle: nsis
+          - os: macos-latest
+            target: aarch64-apple-darwin
+            bundle: dmg
+          - os: macos-latest
+            target: x86_64-apple-darwin
+            bundle: dmg
+
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      - name: Install Rust Stable
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Add Rust Target
+        run: rustup target add ${{ matrix.target }}
+
+      - name: Rust Cache
+        uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: src-tauri
+          cache-all-crates: true
+          cache-on-failure: true
+
+      - name: Install Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+
+      - uses: pnpm/action-setup@v4
+        name: Install pnpm
+        with:
+          run_install: false
+
+      - name: Pnpm install and check
+        run: |
+          pnpm i
+          pnpm check ${{ matrix.target }}
+
+      - name: Tauri build
+        uses: tauri-apps/tauri-action@v0
+        env:
+          NODE_OPTIONS: "--max_old_space_size=4096"
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
+          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
+          APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_SIGNING_IDENTITY }}
+          APPLE_ID: ${{ secrets.APPLE_ID }}
+          APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
+          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
+        with:
+          tauriScript: pnpm
+          args: --target ${{ matrix.target }} -b ${{ matrix.bundle }}
+
+      - name: Upload Artifacts
+        if: matrix.os == 'macos-latest'
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.target }}
+          path: src-tauri/target/${{ matrix.target }}/release/bundle/dmg/*.dmg
+          if-no-files-found: error
+
+      - name: Upload Artifacts
+        if: matrix.os == 'windows-latest'
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.target }}
+          path: src-tauri/target/${{ matrix.target }}/release/bundle/nsis/*.exe
+          if-no-files-found: error
@@ -15,14 +15,14 @@ jobs:
        include:
          - os: windows-latest
            target: x86_64-pc-windows-msvc
-          - os: windows-latest
-            target: i686-pc-windows-msvc
          - os: windows-latest
            target: aarch64-pc-windows-msvc
          - os: macos-latest
            target: aarch64-apple-darwin
          - os: macos-latest
            target: x86_64-apple-darwin
+          - os: ubuntu-22.04
+            target: x86_64-unknown-linux-gnu

    runs-on: ${{ matrix.os }}
    steps:
@@ -30,7 +30,7 @@ jobs:
        uses: actions/checkout@v4

      - name: Install Rust Stable
-        uses: dtolnay/rust-toolchain@1.77.0
+        uses: dtolnay/rust-toolchain@stable

      - name: Add Rust Target
        run: rustup target add ${{ matrix.target }}
@@ -41,10 +41,16 @@ jobs:
          workspaces: src-tauri
          cache-all-crates: true

+      - name: Install dependencies (ubuntu only)
+        if: matrix.os == 'ubuntu-22.04'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librsvg2-dev patchelf
+
      - name: Install Node
        uses: actions/setup-node@v4
        with:
-          node-version: "20"
+          node-version: "22"

      - uses: pnpm/action-setup@v4
        name: Install pnpm
@@ -61,8 +67,8 @@ jobs:
        env:
          NODE_OPTIONS: "--max_old_space_size=4096"
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
-          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
          APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_SIGNING_IDENTITY }}
@@ -82,38 +88,114 @@ jobs:
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

-  release-for-linux:
+  release-for-linux-arm:
    strategy:
      fail-fast: false
      matrix:
        include:
-          - os: ubuntu-latest
-            target: x86_64-unknown-linux-gnu
-          - os: ubuntu-latest
-            target: i686-unknown-linux-gnu
-          - os: ubuntu-latest
+          - os: ubuntu-22.04
            target: aarch64-unknown-linux-gnu
-          - os: ubuntu-latest
+            arch: arm64
+          - os: ubuntu-22.04
            target: armv7-unknown-linux-gnueabihf
+            arch: armhf
    runs-on: ${{ matrix.os }}
    steps:
      - name: Checkout Repository
        uses: actions/checkout@v4

+      - name: Install Rust Stable
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Add Rust Target
+        run: rustup target add ${{ matrix.target }}
+
+      - name: Rust Cache
+        uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: src-tauri
+          cache-all-crates: true
+
+      - name: Install Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          run_install: false
+
+      - name: Pnpm install and check
+        run: |
+          pnpm i
+          pnpm check ${{ matrix.target }}
+
+      - name: "Setup for linux"
+        run: |-
+          sudo ls -lR /etc/apt/
+
+          cat > /tmp/sources.list << EOF
+          deb [arch=amd64,i386] http://archive.ubuntu.com/ubuntu jammy main multiverse universe restricted
+          deb [arch=amd64,i386] http://archive.ubuntu.com/ubuntu jammy-security main multiverse universe restricted
+          deb [arch=amd64,i386] http://archive.ubuntu.com/ubuntu jammy-updates main multiverse universe restricted
+          deb [arch=amd64,i386] http://archive.ubuntu.com/ubuntu jammy-backports main multiverse universe restricted
+
+          deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy main multiverse universe restricted
+          deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy-security main multiverse universe restricted
+          deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy-updates main multiverse universe restricted
+          deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy-backports main multiverse universe restricted
+          EOF
+
+          sudo mv /etc/apt/sources.list /etc/apt/sources.list.default
+          sudo mv /tmp/sources.list /etc/apt/sources.list
+
+          sudo dpkg --add-architecture ${{ matrix.arch }}
+          sudo apt update
+
+          sudo apt install -y \
+            libwebkit2gtk-4.1-dev:${{ matrix.arch }} \
+            libayatana-appindicator3-dev:${{ matrix.arch }} \
+            libssl-dev:${{ matrix.arch }} \
+            patchelf:${{ matrix.arch }} \
+            librsvg2-dev:${{ matrix.arch }}
+
+      - name: "Install aarch64 tools"
+        if: matrix.target == 'aarch64-unknown-linux-gnu'
+        run: |
+          sudo apt install -y \
+            gcc-aarch64-linux-gnu \
+            g++-aarch64-linux-gnu
+
+      - name: "Install armv7 tools"
+        if: matrix.target == 'armv7-unknown-linux-gnueabihf'
+        run: |
+          sudo apt install -y \
+            gcc-arm-linux-gnueabihf \
+            g++-arm-linux-gnueabihf
+
      - name: Build for Linux
-        uses: ./.github/build-for-linux
+        run: |
+          export PKG_CONFIG_ALLOW_CROSS=1
+          if [ "${{ matrix.target }}" == "aarch64-unknown-linux-gnu" ]; then
+            export PKG_CONFIG_PATH=/usr/lib/aarch64-linux-gnu/pkgconfig/:$PKG_CONFIG_PATH
+            export PKG_CONFIG_SYSROOT_DIR=/usr/aarch64-linux-gnu/
+          elif [ "${{ matrix.target }}" == "armv7-unknown-linux-gnueabihf" ]; then
+            export PKG_CONFIG_PATH=/usr/lib/arm-linux-gnueabihf/pkgconfig/:$PKG_CONFIG_PATH
+            export PKG_CONFIG_SYSROOT_DIR=/usr/arm-linux-gnueabihf/
+          fi
+          pnpm build --target ${{ matrix.target }}
        env:
          NODE_OPTIONS: "--max_old_space_size=4096"
-          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
-          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
-        with:
-          target: ${{ matrix.target }}
+          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}

      - name: Get Version
        run: |
          sudo apt-get update
          sudo apt-get install jq
          echo "VERSION=$(cat package.json | jq '.version' | tr -d '"')" >> $GITHUB_ENV
+          echo "BUILDTIME=$(TZ=Asia/Shanghai date)" >> $GITHUB_ENV

      - name: Upload Release
        uses: softprops/action-gh-release@v2
@@ -156,7 +238,7 @@ jobs:
      - name: Install Node
        uses: actions/setup-node@v4
        with:
-          node-version: "20"
+          node-version: "22"

      - uses: pnpm/action-setup@v4
        name: Install pnpm
@@ -181,17 +263,31 @@ jobs:
        env:
          NODE_OPTIONS: "--max_old_space_size=4096"
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
-          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
        with:
          tauriScript: pnpm
          args: --target ${{ matrix.target }}

      - name: Rename
        run: |
-          Rename-Item '.\src-tauri\target\${{ matrix.target }}\release\bundle\nsis\Clash Verge_${{steps.build.outputs.appVersion}}_${{ matrix.arch }}-setup.exe' 'Clash Verge_${{steps.build.outputs.appVersion}}_${{ matrix.arch }}_fixed_webview2-setup.exe'
-          Rename-Item '.\src-tauri\target\${{ matrix.target }}\release\bundle\nsis\Clash Verge_${{steps.build.outputs.appVersion}}_${{ matrix.arch }}-setup.nsis.zip' 'Clash Verge_${{steps.build.outputs.appVersion}}_${{ matrix.arch }}_fixed_webview2-setup.nsis.zip'
-          Rename-Item '.\src-tauri\target\${{ matrix.target }}\release\bundle\nsis\Clash Verge_${{steps.build.outputs.appVersion}}_${{ matrix.arch }}-setup.nsis.zip.sig' 'Clash Verge_${{steps.build.outputs.appVersion}}_${{ matrix.arch }}_fixed_webview2-setup.nsis.zip.sig'
+          $files = Get-ChildItem ".\src-tauri\target\${{ matrix.target }}\release\bundle\nsis\*-setup.exe"
+          foreach ($file in $files) {
+            $newName = $file.Name -replace "-setup\.exe$", "_fixed_webview2-setup.exe"
+            Rename-Item $file.FullName $newName
+          }
+
+          $files = Get-ChildItem ".\src-tauri\target\${{ matrix.target }}\release\bundle\nsis\*.nsis.zip"
+          foreach ($file in $files) {
+            $newName = $file.Name -replace "-setup\.nsis\.zip$", "_fixed_webview2-setup.nsis.zip"
+            Rename-Item $file.FullName $newName
+          }
+
+          $files = Get-ChildItem ".\src-tauri\target\${{ matrix.target }}\release\bundle\nsis\*.nsis.zip.sig"
+          foreach ($file in $files) {
+            $newName = $file.Name -replace "-setup\.nsis\.zip\.sig$", "_fixed_webview2-setup.nsis.zip.sig"
+            Rename-Item $file.FullName $newName
+          }

      - name: Upload Release
        uses: softprops/action-gh-release@v2
@@ -209,7 +305,7 @@ jobs:

  release-update:
    runs-on: ubuntu-latest
-    needs: [release, release-for-linux]
+    needs: [release, release-for-linux-arm]
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
@@ -217,7 +313,7 @@ jobs:
      - name: Install Node
        uses: actions/setup-node@v4
        with:
-          node-version: "20"
+          node-version: "22"

      - uses: pnpm/action-setup@v4
        name: Install pnpm
@@ -242,7 +338,7 @@ jobs:
      - name: Install Node
        uses: actions/setup-node@v4
        with:
-          node-version: "20"
+          node-version: "22"

      - uses: pnpm/action-setup@v4
        name: Install pnpm
@@ -256,3 +352,25 @@ jobs:
        run: pnpm updater-fixed-webview2
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  submit-to-winget:
+    runs-on: ubuntu-latest
+    needs: [release-update]
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Get Version
+        run: |
+          sudo apt-get update
+          sudo apt-get install jq
+          echo "VERSION=$(cat package.json | jq '.version' | tr -d '"')" >> $GITHUB_ENV
+      - name: Submit to Winget
+        uses: vedantmgoyal9/winget-releaser@main
+        with:
+          identifier: ClashVergeRev.ClashVergeRev
+          version: ${{env.VERSION}}
+          release-tag: v${{env.VERSION}}
+          installers-regex: '_(arm64|x64|x86)-setup\.exe$'
+          token: ${{ secrets.WINGET_TOKEN  }}
@@ -12,7 +12,7 @@ jobs:
      - name: Install Node
        uses: actions/setup-node@v4
        with:
-          node-version: "20"
+          node-version: "22"

      - uses: pnpm/action-setup@v4
        name: Install pnpm
@@ -36,7 +36,7 @@ jobs:
      - name: Install Node
        uses: actions/setup-node@v4
        with:
-          node-version: "20"
+          node-version: "22"

      - uses: pnpm/action-setup@v4
        name: Install pnpm
@@ -7,4 +7,5 @@ dist-ssr
 update.json
 scripts/_env.sh
 .vscode
-.tool-versions
+.tool-versions
+.idea
@@ -1,4 +1 @@
-#!/bin/sh
-. "$(dirname "$0")/_/husky.sh"
-
 pnpm pretty-quick --staged
@@ -17,15 +17,28 @@ If you're a Windows user, you may need to perform some additional steps:
 - Make sure to add Rust and Node.js to your system's PATH. This is usually done during the installation process, but you can verify and manually add them if necessary.
 - The gnu `patch` tool should be installed

-### Install Node.js Packages
-
-After installing Rust and Node.js, install the necessary Node.js packages:
+When you setup `Rust` environment, Only use toolchain with `Windows MSVC` , to change settings follow command:

 ```shell
-pnpm i
+rustup target add x86_64-pc-windows-msvc
+rustup set default-host x86_64-pc-windows-msvc
 ```

-### Download the Clash Binary
+### Install Node.js Package
+
+After installing Rust and Node.js, install the necessary Node.js and Node Package Manager:
+
+```shell
+npm install pnpm -g
+```
+
+### Install Dependencies
+
+```shell
+pnpm install
+```
+
+### Download the Clash Mihomo Core Binary

 You have two options for downloading the clash binary:

@@ -49,12 +62,14 @@ pnpm dev:diff

 ### Build the Project

-If you want to build the project, use:
+To build this project:

 ```shell
-pnpm build
+pnpm run build
 ```

+The `Artifacts` will display in the `log` in the Terminal.
+
 ## Contributing Your Changes

 Once you have made your changes:
@@ -25,34 +25,40 @@ Supports Windows (x64/x86), Linux (x64/arm64) and macOS 10.15+ (intel/apple).

 ---

-### TG Group: [@clash_verge_rev](https://t.me/clash_verge_rev)
+### TG 频道: [@clash_verge_rev](https://t.me/clash_verge_re)

 ## Promotion

-[狗狗加速 —— 技术流机场 Doggygo VPN](https://狗狗加速.com)
+[狗狗加速 —— 技术流机场 Doggygo VPN](https://verge.dginv.click/#/register?code=oaxsAGo6)

 - 高性能海外机场，免费试用，优惠套餐，解锁流媒体，全球首家支持 Hysteria 协议。
- 使用 Clash Verge 专属邀请链接注册送 3 天，每天 1G 流量免费试用：https://verge.狗狗加速.com/#/register?code=oaxsAGo6
+- 使用 Clash Verge 专属邀请链接注册送 3 天，每天 1G 流量免费试用：[点此注册](https://verge.dginv.click/#/register?code=oaxsAGo6)
 - Clash Verge 专属 8 折优惠码: verge20 (仅有 500 份)
 - 优惠套餐每月仅需 15.8 元，160G 流量，年付 8 折
 - 海外团队，无跑路风险，高达 50% 返佣
 - 集群负载均衡设计，高速专线(兼容老客户端)，极低延迟，无视晚高峰，4K 秒开
 - 全球首家 Hysteria 协议机场，现已上线更快的 `Hysteria2` 协议(Clash Verge 客户端最佳搭配)
 - 解锁流媒体及 ChatGPT
- 官网：https://狗狗加速.com
+- 官网：[https://狗狗加速.com](https://verge.dginv.click/#/register?code=oaxsAGo6)

 ## Features

- Since the clash core has been removed. The project no longer maintains the clash core, but only the Clash Meta core.
- Profiles management and enhancement (by yaml and Javascript). [Doc](https://clash-verge-rev.github.io)
- Improved UI and supports custom theme color.
- Built-in support [Clash.Meta(mihomo)](https://github.com/MetaCubeX/mihomo) core.
- System proxy setting and guard.
+- 基于性能强劲的 Rust 和 Tauri 2 框架
+- 内置[Clash.Meta(mihomo)](https://github.com/MetaCubeX/mihomo)内核，并支持切换 `Alpha` 版本内核。
+- 简洁美观的用户界面，支持自定义主题颜色、代理组/托盘图标以及 `CSS Injection`。
+- 配置文件管理和增强（Merge 和 Script），配置文件语法提示。
+- 系统代理和守卫、`TUN(虚拟网卡)` 模式。
+- 可视化节点和规则编辑
+- WebDav 配置备份和同步

 ### FAQ

 Refer to [Doc FAQ Page](https://clash-verge-rev.github.io/faq/windows.html)

+### Donation
+
+[捐助Clash Verge Rev的开发](https://github.com/sponsors/clash-verge-rev)
+
 ## Development

 See [CONTRIBUTING.md](./CONTRIBUTING.md) for more details.
@@ -1,3 +1,325 @@
+## v2.1.2
+
+**发行代号：臻**
+
+代号释义： 千锤百炼臻至善，集性能跃升、功能拓展、交互焕新于一体，彰显持续打磨、全方位优化的迭代精神。
+
+感谢 Tychristine 对社区群组管理做出的重大贡献！
+
+2.1.2相对2.1.1(已下架不在提供)更新了：
+
+- 无法更新和签名验证失败的问题(该死的CDN缓存)
+- 设置菜单区分Verge基本设置和高级设置
+- 增加v2 Updater的更多功能和权限
+- 退出Verge后Tun代理状态仍保留的问题
+
+  2.1.1相对2.1.0(已下架不在提供)更新了：
+
+- 检测所需的Clash Verge Service版本（杀毒软件误报可能与此有关，因为检测和安装新版本Service需管理员权限）
+- MacOS下支持彩色托盘图标和更好速率显示（感谢Tunglies）
+- 文件类型判断不准导致脚本检测报错的问题
+- 打开Win下的阴影(Win10因底层兼容性问题，可能圆角和边框显示不太完美)
+- 边框去白边
+- 修复Linux下编译问题
+- 修复热键无法关闭面板的问题
+
+## v2.1.0 - 发行代号：臻
+
+### 功能新增
+
+- 新增窗口状态实时监控与自动保存功能
+- 增强核心配置变更时的验证与错误处理机制
+- 支持通过环境变量`CLASH_VERGE_REV_IP`自定义复制IP地址
+- 添加连接表列宽持久化设置与进程过滤功能
+- 新增代理组首字母导航与动态滚动定位功能
+- 实现连接追踪暂停/恢复功能
+- 支持从托盘菜单快速切换代理配置
+- 添加轻量级模式开关选项
+- 允许用户自定义TUN模式增强类型和FakeIP范围
+- 新增系统代理状态指示器
+- 增加Alpha版本自动重命名逻辑
+- 优化字母导航工具提示与防抖交互机制
+
+### 性能优化
+
+- 重构代理列表渲染逻辑，提升布局计算效率
+- 优化代理数据更新机制，采用乐观UI策略
+- 改进虚拟列表渲染性能（Virtuoso）
+- 提升主窗口Clash模式切换速度（感谢Tunglies）
+- 加速内核关闭流程并优化管理逻辑
+- 优化节点延迟刷新速率
+- 改进托盘网速显示更新逻辑
+- 提升配置验证错误信息的可读性
+- 重构服务架构，优化代码组织结构（感谢Tunglies）
+- 优化内核启动时的配置验证流程
+
+### 问题修复
+
+- 修复删除节点时关联组信息残留问题
+- 解决菜单切换异常与重复勾选问题
+- 修正连接页流量计算错误
+- 修复Windows圆角显示异常问题
+- 解决控制台废弃API警告
+- 修复全局热键空值导致的崩溃
+- 修复Alpha版本Windows打包重命名问题
+- 修复MacOS端口切换崩溃问题
+- 解决Linux持续集成更新器问题
+- 修复静默启动后热键失效问题
+- 修正TypeScript代理组类型定义
+- 修复Windows托盘图标空白问题
+- 优化远程目标地址显示（替换旧版IP展示）
+
+### 交互体验
+
+- 统一多平台托盘图标点击行为
+- 优化代理列表滚动流畅度
+- 改进日志搜索功能与数据管理
+- 重构热键管理逻辑，修复托盘冻结问题
+- 优化托盘网速显示样式
+- 增强字母导航工具提示的动态响应
+
+### 国际化
+
+- 新增配置检查多语言支持
+- 添加轻量级模式多语言文本
+- 完善多语言翻译内容
+
+### 维护更新
+
+- 将默认TUN协议栈改为gVisor
+- 更新Node.js运行版本
+- 移除自动生成更新器文件
+- 清理废弃代码与未使用组件
+- 禁用工作流自动Alpha标签更新
+- 更新依赖库版本
+- 添加MacOS格式转换函数专项测试
+- 优化开发模式日志输出
+
+### 安全增强
+
+- 强化应用启动时的配置验证机制
+- 改进脚本验证与异常处理流程
+- 修复编译警告（移除无用导入）
+
+## v2.0.3
+
+### Notice
+
+- !!使用出现异常的，打开设置-->配置目录 备份 后 删除所有文件 尝试是否正常!！
+- 历时3个月的紧密开发与严格测试稳定版2.0.0终于发布了：巨量改进与性能、稳定性提升，目前Clash Verge Rev已经有了比肩cfw的健壮性；而且更强大易用！
+- 由于更改了服务安装逻辑，每次更新安装需要输入系统密码卸载老版本服务和安装新版本服务，以后可以丝滑使用tun(虚拟网卡)模式
+
+### 2.0.3相对于2.0.2改进修复了：
+
+1. 修复VLess-URL识别网络类型错误 f400f90 #2126
+2. 新增系统代理绕过文本校验 c71e18e
+3. 修复脚本编辑器UI显示不正确 6197249 #2267
+4. 修复Shift热键无效 589324b #2278
+5. 新增nushell环境变量复制 d233a84
+6. 修复全局扩展脚本无法覆写DNS d22b37c #2235
+7. 切换到系统代理相对于稳定的版本 38745d4
+8. 修改fake-ip-range网段 0e3b631
+9. 修复窗口隐藏后WebSocket未断开连接，减小内存风险 b42d13f
+10. 改进系统代理绕过设置 c5c840d
+11. 修复i18n翻译文本缺失 b149084
+12. 修复双击托盘图标打开面板 f839d3b #2346
+13. 修复Windows10窗口白色边框 4f6ca40 #2425
+14. 修复Windows窗口状态恢复 4f6ca40
+15. 改进保存配置文件自动重启Mihomo内核 0669f7a
+16. 改进更新托盘图标性能 d9291d4
+17. 修复保存配置后代理列表未更新 542baf9 #2460
+18. 新增MacOS托盘显示实时速率，可在"界面设置"中关闭 1b2f1b6
+19. 新增托盘菜单显示已设置的快捷键 eeff4d4
+20. 新增重载配置文件错误响应"400"时显示更多错误信息 c5989d2 #2492
+21. 修复GUI代理状态与菜单显示不一致 13b63b5 #2502
+22. 新增默认语言跟随系统语言(无语言支持即为英语)，添加了阿拉伯语、印尼语、鞑靼语支持 9655f77 #2940
+
+### Features
+
+- Meta(mihomo)内核升级 1.19.1
+- 增加更多语言和托盘语言跟随
+- MacOS增加状态栏速率显示
+- 托盘显示快捷键
+- 重载配置文件错误响应"400"时显示更多错误信息
+- 改进保存配置文件自动重启Mihomo内核
+
+### Performance
+
+- 改进更新托盘图标性能
+- 窗口隐藏后WebSocket断开连接
+
+## v2.0.2
+
+### Notice
+
+- !!使用出现异常的，打开设置-->配置目录 备份 后 删除所有文件 尝试是否正常!！
+- 历时3个月的紧密开发与严格测试稳定版2.0.0终于发布了：巨量改进与性能、稳定性提升，目前Clash Verge Rev已经有了比肩cfw的健壮性；而且更强大易用！
+- 由于更改了服务安装逻辑，Mac/Linux 首次安装需要输入系统密码卸载和安装服务，以后可以丝滑使用 tun(虚拟网卡)模式
+- 因 Tauri 2.0 底层 bug，关闭窗口后保留webview进程，优点是再次打开面板更快，缺点是内存使用略有增加
+
+### 2.0.2相对于2.0.1改进了：
+
+- MacOS 下自定义图标可以支持彩色、单色切换
+- 修正了 Linux 下多个内核僵尸进程的问题
+- 修正了 DNS ipv6 强制覆盖的逻辑
+- 修改了 MacOS tun 模式下覆盖设置 dns 字段的问题
+- 修正了 MacOS tray 图标不会随代理模式更改的问题
+- 静默启动下重复运行会出现多个实例的bug
+- 安装的时候自动删除历史残留启动项
+- Tun模式默认是还用内核推荐的 mixed 堆栈
+- 改进了默认窗口大小（启动软件窗口不会那么小了）
+- 改进了 WebDAV 备份超时时间机制
+- 测试菜单添加滚动条
+- 改进和修正了 Tun 模式下对设置的覆盖逻辑
+- 修复了打开配置出错的问题
+- 修复了配置文件无法拖拽添加的问题
+- 改善了浅色模式的对比度
+
+### 2.0.1相对于2.0.0改进了：
+
+- 无法从 2.0rc和2.0.0 升级的问题（已经安装了2.0版本的需手动下载安装）
+- MacOS 系统下少有的无法安装服务，无法启动的问题，目前更健壮了
+- 当系统中没有 yaml 编辑器的情况下，打开文件程序崩溃的问题
+- Windows 应用内升级和覆盖安装不会删除老执行文件的问题
+- 修改优化了 mac 下 fakeip 段和 dns
+- 测试菜单 svg 图标格式检查
+- 应用内升级重复安装 vs runtime 的问题
+- 修复外部控制下密码有特殊字符认证出错的问题
+- 修复恢复 Webdav 备份设置后， Webdav 设置丢失的问题
+- 代理页面增加快速回到顶部的按钮
+
+### Breaking changes
+
+- 重大框架升级：使用 Tauri 2.0（巨量改进与性能提升）
+- 出现 bug 到 issues 中提出；以后不再接受1.x版本的bug反馈。
+- 强烈建议完全删除 1.x 老版本再安装此版本 !!使用出现异常的，打开设置-->配置目录 备份 后 删除所有文件 尝试是否正常!！
+
+### Features
+
+- Meta(mihomo)内核升级 1.18.10
+- Win 下的系统代理替换为 Shadowsocks/CFW/v2rayN 等成熟的 sysproxy.exe 方案，解决拨号/VPN 环境下无法设置系统代理的问题
+- 服务模式改进为启动软件时自动安装，TUN 模式可自由开启不再限制于服务模式
+- Mac 下可用 URL Scheme 导入订阅
+- 可使用 Ctrl(cmd)+Q 快捷键退出程序
+- 成功导入订阅的提示消息
+- 能自动选中新导入的订阅
+- 日志加入颜色区分
+- 改进多处文本表述
+- 加入图标 svg 格式检测
+- 增加更多 app 调试日志
+- 添加 MacOS 下白色桌面的 tray 黑色配色（但会代理系统代理、tun 模式图标失效的问题）
+- 增加 Webdav 备份功能
+- 添加统一延迟的设置开关
+- 添加 Windows 下自动检测并下载 vc runtime 的功能
+- 支持显示 mux 和 mptcp 的节点标识
+- 延迟测试连接更换 http 的 cp.cloudflare.com/generate_204 （关闭统一延迟的情况下延迟测试结果会有所增加）
+- 重构日志记录逻辑，可以收集和筛选所有日志类型了（之前无法记录debug的日志类型）
+
+### Performance
+
+- 优化及重构内核启动管理逻辑
+- 优化 TUN 启动逻辑
+- 重构和优化 app_handle
+- 重构系统代理绕过逻辑
+- 移除无用的 PID 创建逻辑
+- 优化系统 DNS 设置逻辑
+- 后端实现窗口控制
+- 重构 MacOS 下的 DNS 设置逻辑
+
+### Bugs Fixes
+
+- 修复已有多个订阅导入新订阅会跳选订阅的问题
+- 修复多个 Linux 下的 bug, Tun 模式在 Linux 下目前工作正常
+- 修复 Linux wayland 下任务栏图标缺失的问题
+- 修复 Linux KDE 桌面环境无法启动的问题
+- 移除多余退出变量和钩子
+- 修复 MacOS 下 tray 菜单重启 app 失效的问题
+- 修复某些特定配置文件载入失败的问题
+- 修复 MacOS 下 tun 模式 fakeip 不生效的问题
+- 修复 Linux 下 关闭 tun 模式文件报错的问题
+- 修复快捷键设置的相关 bug
+- 修复 Win 下点左键菜单闪现的问题（Mac 下的操作逻辑相反，默认情况下不管点左/右键均会打开菜单，闪现不属于 bug）
+
+### Known issues
+
+- Windows 下窗口大小无法记忆（等待上游修复）
+- Webdav 备份因为安全性和兼容性问题，暂不支持跨平台配置同步
+
+---
+
+## v1.7.7
+
+### Bugs Fixes
+
+- 修复导入订阅没有自动重载(不显示节点)的问题
+- 英语状态下修复 Windows 工具栏提示文本超过限制的问题
+
+---
+
+## v1.7.6
+
+### Notice
+
+- Clash Verge Rev 目前已进入稳定周期，日后更新将着重于 bug 修复与内核常规升级
+
+### Features
+
+- Meta(mihomo)内核升级 1.18.7
+- 界面细节调整
+- 优化服务模式安装逻辑
+- 移除无用的 console log
+- 能自动选择第一个订阅
+
+### Bugs Fixes
+
+- 修复服务模式安装问题
+- 修复 Mac 下的代理绕过 CIDR 写法过滤
+- 修复 32 位升级 URL
+- 修复不同分组 URL 测试地址配置无效的问题
+- 修复 Web UI 下的一处 hostname 参数
+
+---
+
+## v1.7.5
+
+### Features
+
+- 展示局域网 IP 地址信息
+- 在设置页面直接复制环境变量
+- 优化服务模式安装逻辑
+
+### Performance
+
+- 优化切换订阅速度
+- 优化更改端口速度
+
+### Bugs Fixes
+
+- 调整 MacOS 托盘图标大小
+- Trojan URI 解析错误
+- 卡片拖动显示层级错误
+- 代理绕过格式检查错误
+- MacOS 下编辑器最大化失败
+- MacOS 服务安装失败
+- 更改窗口大小导致闪退的问题
+
+---
+
+## v1.7.3
+
+### Features
+
+- 支持可视化编辑订阅代理组
+- 支持可视化编辑订阅节点
+- 支持可视化编辑订阅规则
+- 扩展脚本支持订阅名称参数 `function main(config, profileName)`
+
+### Bugs Fixes
+
+- 代理绕过格式检查错误
+
+---
+
 ## v1.7.2

 ### Break Changes
@@ -1,87 +1,99 @@
 {
  "name": "clash-verge",
-  "version": "1.7.2",
+  "version": "2.1.2",
  "license": "GPL-3.0-only",
  "scripts": {
-    "dev": "tauri dev",
-    "dev:diff": "tauri dev -f verge-dev",
-    "build": "tauri build",
+    "dev": "cross-env RUST_BACKTRACE=1 tauri dev",
+    "dev:diff": "cross-env RUST_BACKTRACE=1 tauri dev -f verge-dev",
+    "build": "cross-env NODE_OPTIONS='--max-old-space-size=4096' tauri build",
    "tauri": "tauri",
    "web:dev": "vite",
-    "web:build": "tsc && vite build",
+    "web:build": "tsc --noEmit && vite build",
    "web:serve": "vite preview",
    "check": "node scripts/check.mjs",
    "updater": "node scripts/updater.mjs",
    "updater-fixed-webview2": "node scripts/updater-fixed-webview2.mjs",
    "portable": "node scripts/portable.mjs",
    "portable-fixed-webview2": "node scripts/portable-fixed-webview2.mjs",
-    "prepare": "husky install"
+    "fix-alpha-version": "node scripts/alpha_version.mjs",
+    "prepare": "husky"
  },
  "dependencies": {
-    "@dnd-kit/core": "^6.1.0",
-    "@dnd-kit/sortable": "^8.0.0",
+    "@dnd-kit/core": "^6.3.1",
+    "@dnd-kit/sortable": "^10.0.0",
    "@dnd-kit/utilities": "^3.2.2",
-    "@emotion/react": "^11.11.4",
-    "@emotion/styled": "^11.11.5",
+    "@emotion/react": "^11.14.0",
+    "@emotion/styled": "^11.14.0",
    "@juggle/resize-observer": "^3.4.0",
-    "@mui/icons-material": "^5.15.21",
-    "@mui/lab": "5.0.0-alpha.149",
-    "@mui/material": "^5.15.21",
-    "@mui/x-data-grid": "^7.8.0",
-    "@tauri-apps/api": "^1.6.0",
+    "@mui/icons-material": "^6.4.2",
+    "@mui/lab": "6.0.0-beta.25",
+    "@mui/material": "^6.4.2",
+    "@mui/x-data-grid": "^7.25.0",
+    "@tauri-apps/api": "2.2.0",
+    "@tauri-apps/plugin-clipboard-manager": "^2.2.1",
+    "@tauri-apps/plugin-dialog": "^2.2.0",
+    "@tauri-apps/plugin-fs": "^2.2.0",
+    "@tauri-apps/plugin-global-shortcut": "^2.2.0",
+    "@tauri-apps/plugin-notification": "^2.2.1",
+    "@tauri-apps/plugin-process": "^2.2.0",
+    "@tauri-apps/plugin-shell": "2.2.0",
+    "@tauri-apps/plugin-updater": "2.3.0",
    "@types/json-schema": "^7.0.15",
-    "ahooks": "^3.8.0",
-    "axios": "^1.7.2",
-    "dayjs": "1.11.5",
-    "foxact": "^0.2.35",
-    "i18next": "^23.11.5",
+    "ahooks": "^3.8.4",
+    "axios": "^1.7.9",
+    "cli-color": "^2.0.4",
+    "dayjs": "1.11.13",
+    "foxact": "^0.2.43",
+    "glob": "^11.0.1",
+    "i18next": "^24.2.2",
+    "js-base64": "^3.7.7",
    "js-yaml": "^4.1.0",
    "lodash-es": "^4.17.21",
-    "meta-json-schema": "1.18.6",
-    "monaco-editor": "^0.49.0",
-    "monaco-yaml": "^5.2.0",
-    "nanoid": "^5.0.7",
+    "monaco-editor": "^0.52.2",
+    "monaco-yaml": "^5.2.3",
+    "nanoid": "^5.0.9",
+    "peggy": "^4.2.0",
    "react": "^18.3.1",
    "react-dom": "^18.3.1",
-    "react-error-boundary": "^3.1.4",
-    "react-hook-form": "^7.52.1",
+    "react-error-boundary": "^4.0.12",
+    "react-hook-form": "^7.54.2",
    "react-i18next": "^13.5.0",
    "react-markdown": "^9.0.1",
-    "react-monaco-editor": "^0.55.0",
-    "react-router-dom": "^6.24.0",
+    "react-monaco-editor": "^0.56.0",
+    "react-router-dom": "^6.22.3",
    "react-transition-group": "^4.4.5",
-    "react-virtuoso": "^4.7.11",
+    "react-virtuoso": "^4.6.3",
    "sockette": "^2.0.6",
-    "swr": "^2.2.5",
-    "tar": "^6.2.1",
-    "types-pac": "^1.0.2"
+    "swr": "^2.3.0",
+    "tar": "^7.4.3",
+    "types-pac": "^1.0.3",
+    "zustand": "^5.0.3"
  },
  "devDependencies": {
-    "@actions/github": "^5.1.1",
-    "@tauri-apps/cli": "^1.6.0",
-    "@types/fs-extra": "^9.0.13",
+    "@actions/github": "^6.0.0",
+    "@tauri-apps/cli": "2.2.7",
    "@types/js-cookie": "^3.0.6",
    "@types/js-yaml": "^4.0.9",
    "@types/lodash-es": "^4.17.12",
-    "@types/react": "^18.3.3",
-    "@types/react-dom": "^18.3.0",
-    "@types/react-transition-group": "^4.4.10",
-    "@vitejs/plugin-legacy": "^5.4.1",
-    "@vitejs/plugin-react": "^4.3.1",
-    "adm-zip": "^0.5.14",
+    "@types/react": "^18.3.18",
+    "@types/react-dom": "^18.3.5",
+    "@types/react-transition-group": "^4.4.12",
+    "@vitejs/plugin-legacy": "^6.0.0",
+    "@vitejs/plugin-react": "^4.2.1",
+    "adm-zip": "^0.5.16",
    "cross-env": "^7.0.3",
-    "fs-extra": "^11.2.0",
-    "https-proxy-agent": "^5.0.1",
-    "husky": "^7.0.4",
+    "https-proxy-agent": "^7.0.6",
+    "husky": "^9.1.7",
+    "meta-json-schema": "^1.19.1",
    "node-fetch": "^3.3.2",
-    "prettier": "^2.8.8",
-    "pretty-quick": "^3.3.1",
-    "sass": "^1.77.6",
-    "terser": "^5.31.1",
-    "typescript": "^5.5.3",
-    "vite": "^5.3.2",
+    "prettier": "^3.4.2",
+    "pretty-quick": "^4.0.0",
+    "sass": "^1.83.4",
+    "terser": "^5.37.0",
+    "typescript": "^5.7.3",
+    "vite": "^6.0.11",
    "vite-plugin-monaco-editor": "^1.1.0",
-    "vite-plugin-svgr": "^4.2.0"
+    "vite-plugin-svgr": "^4.3.0"
  },
  "prettier": {
    "tabWidth": 2,
@@ -89,5 +101,6 @@
    "singleQuote": false,
    "endOfLine": "lf"
  },
-  "packageManager": "pnpm@9.1.4"
+  "type": "module",
+  "packageManager": "pnpm@9.13.2"
 }
@@ -0,0 +1,54 @@
+import { exec } from "child_process";
+import { promisify } from "util";
+import fs from "fs/promises";
+import path from "path";
+
+/**
+ *  为Alpha版本重命名版本号
+ */
+const execPromise = promisify(exec);
+
+/**
+ * 标准输出HEAD hash
+ */
+async function getLatestCommitHash() {
+  try {
+    const { stdout } = await execPromise("git rev-parse HEAD");
+    const commitHash = stdout.trim();
+    // 格式化，只截取前7位字符
+    const formathash = commitHash.substring(0, 7);
+    console.log(`Found the latest commit hash code: ${commitHash}`);
+    return formathash;
+  } catch (error) {
+    console.error("pnpm run fix-alpha-version ERROR", error);
+  }
+}
+
+/**
+ * @param string 传入格式化后的hash
+ * 将新的版本号写入文件 package.json
+ */
+async function updatePackageVersion(newVersion) {
+  // 获取内容根目录
+  const _dirname = process.cwd();
+  const packageJsonPath = path.join(_dirname, "package.json");
+  try {
+    const data = await fs.readFile(packageJsonPath, "utf8");
+    const packageJson = JSON.parse(data);
+    const initversion = packageJson.version;
+    // 将匹配到的第一个 "alpha" => 具体的hash
+    const fixversion = initversion.replace("alpha", newVersion);
+    packageJson.version = fixversion;
+    // 写入版本号
+    await fs.writeFile(
+      packageJsonPath,
+      JSON.stringify(packageJson, null, 2),
+      "utf8",
+    );
+    console.log(`Alpha version update to: ${fixversion}`);
+  } catch (error) {
+    console.error("pnpm run fix-alpha-version ERROR", error);
+  }
+}
+const newVersion = await getLatestCommitHash();
+updatePackageVersion(newVersion);
@@ -1,11 +1,14 @@
-import fs from "fs-extra";
+import fs from "fs";
+import fsp from "fs/promises";
 import zlib from "zlib";
-import tar from "tar";
+import { extract } from "tar";
 import path from "path";
 import AdmZip from "adm-zip";
 import fetch from "node-fetch";
-import proxyAgent from "https-proxy-agent";
+import { HttpsProxyAgent } from "https-proxy-agent";
 import { execSync } from "child_process";
+import { log_info, log_debug, log_error, log_success } from "./utils.mjs";
+import { glob } from "glob";

 const cwd = process.cwd();
 const TEMP_DIR = path.join(cwd, "node_modules/.verge");
@@ -82,7 +85,7 @@ async function getLatestAlphaVersion() {
    process.env.https_proxy;

  if (httpProxy) {
-    options.agent = proxyAgent(httpProxy);
+    options.agent = new HttpsProxyAgent(httpProxy);
  }
  try {
    const response = await fetch(META_ALPHA_VERSION_URL, {
@@ -91,9 +94,9 @@ async function getLatestAlphaVersion() {
    });
    let v = await response.text();
    META_ALPHA_VERSION = v.trim(); // Trim to remove extra whitespaces
-    console.log(`Latest alpha version: ${META_ALPHA_VERSION}`);
+    log_info(`Latest alpha version: ${META_ALPHA_VERSION}`);
  } catch (error) {
-    console.error("Error fetching latest alpha version:", error.message);
+    log_error("Error fetching latest alpha version:", error.message);
    process.exit(1);
  }
 }
@@ -129,7 +132,7 @@ async function getLatestReleaseVersion() {
    process.env.https_proxy;

  if (httpProxy) {
-    options.agent = proxyAgent(httpProxy);
+    options.agent = new HttpsProxyAgent(httpProxy);
  }
  try {
    const response = await fetch(META_VERSION_URL, {
@@ -138,9 +141,9 @@ async function getLatestReleaseVersion() {
    });
    let v = await response.text();
    META_VERSION = v.trim(); // Trim to remove extra whitespaces
-    console.log(`Latest release version: ${META_VERSION}`);
+    log_info(`Latest release version: ${META_VERSION}`);
  } catch (error) {
-    console.error("Error fetching latest release version:", error.message);
+    log_error("Error fetching latest release version:", error.message);
    process.exit(1);
  }
 }
@@ -150,13 +153,13 @@ async function getLatestReleaseVersion() {
 */
 if (!META_MAP[`${platform}-${arch}`]) {
  throw new Error(
-    `clash meta alpha unsupported platform "${platform}-${arch}"`
+    `clash meta alpha unsupported platform "${platform}-${arch}"`,
  );
 }

 if (!META_ALPHA_MAP[`${platform}-${arch}`]) {
  throw new Error(
-    `clash meta alpha unsupported platform "${platform}-${arch}"`
+    `clash meta alpha unsupported platform "${platform}-${arch}"`,
  );
 }

@@ -205,44 +208,44 @@ async function resolveSidecar(binInfo) {
  const sidecarDir = path.join(cwd, "src-tauri", "sidecar");
  const sidecarPath = path.join(sidecarDir, targetFile);

-  await fs.mkdirp(sidecarDir);
-  if (!FORCE && (await fs.pathExists(sidecarPath))) return;
+  await fsp.mkdir(sidecarDir, { recursive: true });
+  if (!FORCE && fs.existsSync(sidecarPath)) return;

  const tempDir = path.join(TEMP_DIR, name);
  const tempZip = path.join(tempDir, zipFile);
  const tempExe = path.join(tempDir, exeFile);

-  await fs.mkdirp(tempDir);
+  await fsp.mkdir(tempDir, { recursive: true });
  try {
-    if (!(await fs.pathExists(tempZip))) {
+    if (!fs.existsSync(tempZip)) {
      await downloadFile(downloadURL, tempZip);
    }

    if (zipFile.endsWith(".zip")) {
      const zip = new AdmZip(tempZip);
      zip.getEntries().forEach((entry) => {
-        console.log(`[DEBUG]: "${name}" entry name`, entry.entryName);
+        log_debug(`"${name}" entry name`, entry.entryName);
      });
      zip.extractAllTo(tempDir, true);
-      await fs.rename(tempExe, sidecarPath);
-      console.log(`[INFO]: "${name}" unzip finished`);
+      await fsp.rename(tempExe, sidecarPath);
+      log_success(`unzip finished: "${name}"`);
    } else if (zipFile.endsWith(".tgz")) {
      // tgz
-      await fs.mkdirp(tempDir);
-      await tar.extract({
+      await fsp.mkdir(tempDir, { recursive: true });
+      await extract({
        cwd: tempDir,
        file: tempZip,
        //strip: 1, // 可能需要根据实际的 .tgz 文件结构调整
      });
-      const files = await fs.readdir(tempDir);
-      console.log(`[DEBUG]: "${name}" files in tempDir:`, files);
+      const files = await fsp.readdir(tempDir);
+      log_debug(`"${name}" files in tempDir:`, files);
      const extractedFile = files.find((file) => file.startsWith("虚空终端-"));
      if (extractedFile) {
        const extractedFilePath = path.join(tempDir, extractedFile);
-        await fs.rename(extractedFilePath, sidecarPath);
-        console.log(`[INFO]: "${name}" file renamed to "${sidecarPath}"`);
+        await fsp.rename(extractedFilePath, sidecarPath);
+        log_success(`"${name}" file renamed to "${sidecarPath}"`);
        execSync(`chmod 755 ${sidecarPath}`);
-        console.log(`[INFO]: "${name}" chmod binary finished`);
+        log_success(`chmod binary finished: "${name}"`);
      } else {
        throw new Error(`Expected file not found in ${tempDir}`);
      }
@@ -252,16 +255,15 @@ async function resolveSidecar(binInfo) {
      const writeStream = fs.createWriteStream(sidecarPath);
      await new Promise((resolve, reject) => {
        const onError = (error) => {
-          console.error(`[ERROR]: "${name}" gz failed:`, error.message);
+          log_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`);
+            log_success(`chmod binary finished: "${name}"`);
            resolve();
          })
          .on("error", onError);
@@ -269,35 +271,58 @@ async function resolveSidecar(binInfo) {
    }
  } catch (err) {
    // 需要删除文件
-    await fs.remove(sidecarPath);
+    await fsp.rm(sidecarPath, { recursive: true, force: true });
    throw err;
  } finally {
    // delete temp dir
-    await fs.remove(tempDir);
+    await fsp.rm(tempDir, { recursive: true, force: true });
  }
 }

+const resolveSetDnsScript = () =>
+  resolveResource({
+    file: "set_dns.sh",
+    localPath: path.join(cwd, "scripts/set_dns.sh"),
+  });
+const resolveUnSetDnsScript = () =>
+  resolveResource({
+    file: "unset_dns.sh",
+    localPath: path.join(cwd, "scripts/unset_dns.sh"),
+  });
+
 /**
 * download the file to the resources dir
 */
 async function resolveResource(binInfo) {
-  const { file, downloadURL } = binInfo;
+  const { file, downloadURL, localPath } = binInfo;

  const resDir = path.join(cwd, "src-tauri/resources");
  const targetPath = path.join(resDir, file);

-  if (!FORCE && (await fs.pathExists(targetPath))) return;
+  if (!FORCE && fs.existsSync(targetPath)) return;

-  await fs.mkdirp(resDir);
-  await downloadFile(downloadURL, targetPath);
+  if (downloadURL) {
+    await fsp.mkdir(resDir, { recursive: true });
+    await downloadFile(downloadURL, targetPath);
+  }

-  console.log(`[INFO]: ${file} finished`);
+  if (localPath) {
+    await fs.copyFile(localPath, targetPath, (err) => {
+      if (err) {
+        console.error("Error copying file:", err);
+      } else {
+        console.log("File was copied successfully");
+      }
+    });
+    log_debug(`copy file finished: "${localPath}"`);
+  }
+
+  log_success(`${file} finished`);
 }

 /**
 * download file and save to `path`
- */
-async function downloadFile(url, path) {
+ */ async function downloadFile(url, path) {
  const options = {};

  const httpProxy =
@@ -307,7 +332,7 @@ async function downloadFile(url, path) {
    process.env.https_proxy;

  if (httpProxy) {
-    options.agent = proxyAgent(httpProxy);
+    options.agent = new HttpsProxyAgent(httpProxy);
  }

  const response = await fetch(url, {
@@ -316,9 +341,9 @@ async function downloadFile(url, path) {
    headers: { "Content-Type": "application/octet-stream" },
  });
  const buffer = await response.arrayBuffer();
-  await fs.writeFile(path, new Uint8Array(buffer));
+  await fsp.writeFile(path, new Uint8Array(buffer));

-  console.log(`[INFO]: download finished "${url}"`);
+  log_success(`download finished: ${url}`);
 }

 // SimpleSC.dll
@@ -329,87 +354,111 @@ const resolvePlugin = async () => {
  const tempDir = path.join(TEMP_DIR, "SimpleSC");
  const tempZip = path.join(
    tempDir,
-    "NSIS_Simple_Service_Plugin_Unicode_1.30.zip"
+    "NSIS_Simple_Service_Plugin_Unicode_1.30.zip",
  );
  const tempDll = path.join(tempDir, "SimpleSC.dll");
  const pluginDir = path.join(process.env.APPDATA, "Local/NSIS");
  const pluginPath = path.join(pluginDir, "SimpleSC.dll");
-  await fs.mkdirp(pluginDir);
-  await fs.mkdirp(tempDir);
-  if (!FORCE && (await fs.pathExists(pluginPath))) return;
+  await fsp.mkdir(pluginDir, { recursive: true });
+  await fsp.mkdir(tempDir, { recursive: true });
+  if (!FORCE && fs.existsSync(pluginPath)) return;
  try {
-    if (!(await fs.pathExists(tempZip))) {
+    if (!fs.existsSync(tempZip)) {
      await downloadFile(url, tempZip);
    }
    const zip = new AdmZip(tempZip);
    zip.getEntries().forEach((entry) => {
-      console.log(`[DEBUG]: "SimpleSC" entry name`, entry.entryName);
+      log_debug(`"SimpleSC" entry name`, entry.entryName);
    });
    zip.extractAllTo(tempDir, true);
-    await fs.copyFile(tempDll, pluginPath);
-    console.log(`[INFO]: "SimpleSC" unzip finished`);
+    await fsp.cp(tempDll, pluginPath, { recursive: true, force: true });
+    log_success(`unzip finished: "SimpleSC"`);
  } finally {
-    await fs.remove(tempDir);
+    await fsp.rm(tempDir, { recursive: true, force: true });
  }
 };

 // service chmod
 const resolveServicePermission = async () => {
  const serviceExecutables = [
-    "clash-verge-service",
-    "install-service",
-    "uninstall-service",
+    "clash-verge-service*",
+    "install-service*",
+    "uninstall-service*",
  ];
  const resDir = path.join(cwd, "src-tauri/resources");
  for (let f of serviceExecutables) {
-    const targetPath = path.join(resDir, f);
-    if (await fs.pathExists(targetPath)) {
-      execSync(`chmod 755 ${targetPath}`);
-      console.log(`[INFO]: "${targetPath}" chmod finished`);
+    // 使用glob模块来处理通配符
+    const files = glob.sync(path.join(resDir, f));
+    for (let filePath of files) {
+      if (fs.existsSync(filePath)) {
+        execSync(`chmod 755 ${filePath}`);
+        log_success(`chmod finished: "${filePath}"`);
+      }
    }
  }
 };

+// 在 resolveResource 函数后添加新函数
+async function resolveLocales() {
+  const srcLocalesDir = path.join(cwd, "src/locales");
+  const targetLocalesDir = path.join(cwd, "src-tauri/resources/locales");
+
+  try {
+    // 确保目标目录存在
+    await fsp.mkdir(targetLocalesDir, { recursive: true });
+
+    // 读取所有语言文件
+    const files = await fsp.readdir(srcLocalesDir);
+
+    // 复制每个文件
+    for (const file of files) {
+      const srcPath = path.join(srcLocalesDir, file);
+      const targetPath = path.join(targetLocalesDir, file);
+
+      await fsp.copyFile(srcPath, targetPath);
+      log_success(`Copied locale file: ${file}`);
+    }
+
+    log_success("All locale files copied successfully");
+  } catch (err) {
+    log_error("Error copying locale files:", err.message);
+    throw err;
+  }
+}
+
 /**
 * main
 */
-
 const SERVICE_URL = `https://github.com/clash-verge-rev/clash-verge-service/releases/download/${SIDECAR_HOST}`;

 const resolveService = () => {
  let ext = platform === "win32" ? ".exe" : "";
+  let suffix = platform === "linux" ? "-" + SIDECAR_HOST : "";
  resolveResource({
-    file: "clash-verge-service" + ext,
+    file: "clash-verge-service" + suffix + ext,
    downloadURL: `${SERVICE_URL}/clash-verge-service${ext}`,
  });
 };

 const resolveInstall = () => {
  let ext = platform === "win32" ? ".exe" : "";
+  let suffix = platform === "linux" ? "-" + SIDECAR_HOST : "";
  resolveResource({
-    file: "install-service" + ext,
+    file: "install-service" + suffix + ext,
    downloadURL: `${SERVICE_URL}/install-service${ext}`,
  });
 };

 const resolveUninstall = () => {
  let ext = platform === "win32" ? ".exe" : "";
+  let suffix = platform === "linux" ? "-" + SIDECAR_HOST : "";
+
  resolveResource({
-    file: "uninstall-service" + ext,
+    file: "uninstall-service" + suffix + ext,
    downloadURL: `${SERVICE_URL}/uninstall-service${ext}`,
  });
 };

-const resolveSetDnsScript = () =>
-  resolveResource({
-    file: "set_dns.sh",
-    downloadURL: `https://github.com/clash-verge-rev/set-dns-script/releases/download/script/set_dns.sh`,
-  });
-const resolveUnSetDnsScript = () =>
-  resolveResource({
-    file: "unset_dns.sh",
-    downloadURL: `https://github.com/clash-verge-rev/set-dns-script/releases/download/script/unset_dns.sh`,
-  });
 const resolveMmdb = () =>
  resolveResource({
    file: "Country.mmdb",
@@ -431,6 +480,12 @@ const resolveEnableLoopback = () =>
    downloadURL: `https://github.com/Kuingsmile/uwp-tool/releases/download/latest/enableLoopback.exe`,
  });

+const resolveWinSysproxy = () =>
+  resolveResource({
+    file: "sysproxy.exe",
+    downloadURL: `https://github.com/clash-verge-rev/sysproxy/releases/download/${arch}/sysproxy.exe`,
+  });
+
 const tasks = [
  // { name: "clash", func: resolveClash, retry: 5 },
  {
@@ -449,8 +504,6 @@ const tasks = [
  { name: "service", func: resolveService, retry: 5 },
  { name: "install", func: resolveInstall, retry: 5 },
  { name: "uninstall", func: resolveUninstall, retry: 5 },
-  { name: "set_dns_script", func: resolveSetDnsScript, retry: 5 },
-  { name: "unset_dns_script", func: resolveUnSetDnsScript, retry: 5 },
  { name: "mmdb", func: resolveMmdb, retry: 5 },
  { name: "geosite", func: resolveGeosite, retry: 5 },
  { name: "geoip", func: resolveGeoIP, retry: 5 },
@@ -463,24 +516,48 @@ const tasks = [
  {
    name: "service_chmod",
    func: resolveServicePermission,
-    retry: 1,
-    unixOnly: true,
+    retry: 5,
+    unixOnly: platform === "linux" || platform === "darwin",
+  },
+  {
+    name: "windows-sysproxy",
+    func: resolveWinSysproxy,
+    retry: 5,
+    winOnly: true,
+  },
+  {
+    name: "set_dns_script",
+    func: resolveSetDnsScript,
+    retry: 5,
+    macosOnly: true,
+  },
+  {
+    name: "unset_dns_script",
+    func: resolveUnSetDnsScript,
+    retry: 5,
+    macosOnly: true,
+  },
+  {
+    name: "locales",
+    func: resolveLocales,
+    retry: 2,
  },
 ];

 async function runTask() {
  const task = tasks.shift();
  if (!task) return;
-  if (task.winOnly && platform !== "win32") return runTask();
-  if (task.linuxOnly && platform !== "linux") return runTask();
  if (task.unixOnly && platform === "win32") return runTask();
+  if (task.winOnly && platform !== "win32") return runTask();
+  if (task.macosOnly && platform !== "darwin") return runTask();
+  if (task.linuxOnly && platform !== "linux") 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);
+      log_error(`task::${task.name} try ${i} ==`, err.message);
      if (i === task.retry - 1) throw err;
    }
  }
@@ -488,4 +565,3 @@ async function runTask() {
 }

 runTask();
-runTask();
@@ -1,4 +1,5 @@
-import fs from "fs-extra";
+import fs from "fs";
+import fsp from "fs/promises";
 import path from "path";
 import AdmZip from "adm-zip";
 import { createRequire } from "module";
@@ -30,12 +31,14 @@ async function resolvePortable() {

  const configDir = path.join(releaseDir, ".config");

-  if (!(await fs.pathExists(releaseDir))) {
+  if (!fs.existsSync(releaseDir)) {
    throw new Error("could not found the release dir");
  }

-  await fs.mkdir(configDir);
-  await fs.createFile(path.join(configDir, "PORTABLE"));
+  await fsp.mkdir(configDir, { recursive: true });
+  if (!fs.existsSync(path.join(configDir, "PORTABLE"))) {
+    await fsp.writeFile(path.join(configDir, "PORTABLE"), "");
+  }

  const zip = new AdmZip();

@@ -46,9 +49,9 @@ async function resolvePortable() {
  zip.addLocalFolder(
    path.join(
      releaseDir,
-      `Microsoft.WebView2.FixedVersionRuntime.109.0.1518.78.${arch}`
+      `Microsoft.WebView2.FixedVersionRuntime.109.0.1518.78.${arch}`,
    ),
-    `Microsoft.WebView2.FixedVersionRuntime.109.0.1518.78.${arch}`
+    `Microsoft.WebView2.FixedVersionRuntime.109.0.1518.78.${arch}`,
  );
  zip.addLocalFolder(configDir, ".config");

@@ -1,4 +1,4 @@
-import fs from "fs-extra";
+import fs from "fs";
 import path from "path";
 import AdmZip from "adm-zip";
 import { createRequire } from "module";
@@ -29,12 +29,14 @@ async function resolvePortable() {
    : `./src-tauri/target/release`;
  const configDir = path.join(releaseDir, ".config");

-  if (!(await fs.pathExists(releaseDir))) {
+  if (!fs.existsSync(releaseDir)) {
    throw new Error("could not found the release dir");
  }

-  await fs.mkdir(configDir);
-  await fs.createFile(path.join(configDir, "PORTABLE"));
+  await fsp.mkdir(configDir, { recursive: true });
+  if (!fs.existsSync(path.join(configDir, "PORTABLE"))) {
+    await fsp.writeFile(path.join(configDir, "PORTABLE"), "");
+  }

  const zip = new AdmZip();

@@ -0,0 +1,66 @@
+#!/bin/bash
+
+# 验证IPv4地址格式
+function is_valid_ipv4() {
+    local ip=$1
+    local IFS='.'
+    local -a octets
+
+    [[ ! $ip =~ ^([0-9]+\.){3}[0-9]+$ ]] && return 1
+    read -r -a octets <<<"$ip"
+    [ "${#octets[@]}" -ne 4 ] && return 1
+
+    for octet in "${octets[@]}"; do
+        if ! [[ "$octet" =~ ^[0-9]+$ ]] || ((octet < 0 || octet > 255)); then
+            return 1
+        fi
+    done
+    return 0
+}
+
+# 验证IPv6地址格式
+function is_valid_ipv6() {
+    local ip=$1
+    if [[ ! $ip =~ ^([0-9a-fA-F]{0,4}:){1,7}[0-9a-fA-F]{0,4}$ ]] &&
+        [[ ! $ip =~ ^(([0-9a-fA-F]{0,4}:){0,7}:|(:[0-9a-fA-F]{0,4}:){0,6}:[0-9a-fA-F]{0,4})$ ]]; then
+        return 1
+    fi
+    return 0
+}
+
+# 验证IP地址是否为有效的IPv4或IPv6
+function is_valid_ip() {
+    is_valid_ipv4 "$1" || is_valid_ipv6 "$1"
+}
+
+# 检查参数
+[ $# -lt 1 ] && echo "Usage: $0 <IP address>" && exit 1
+! is_valid_ip "$1" && echo "$1 is not a valid IP address." && exit 1
+
+# 获取网络接口和硬件端口
+nic=$(route -n get default | grep "interface" | awk '{print $2}')
+hardware_port=$(networksetup -listallhardwareports | awk -v dev="$nic" '
+    /Hardware Port:/{port=$0; gsub("Hardware Port: ", "", port)} 
+    /Device: /{if ($2 == dev) {print port; exit}}
+')
+
+# 获取当前DNS设置
+original_dns=$(networksetup -getdnsservers "$hardware_port")
+
+# 检查当前DNS设置是否有效
+is_valid_dns=false
+for ip in $original_dns; do
+    ip=$(echo "$ip" | tr -d '[:space:]')
+    if [ -n "$ip" ] && (is_valid_ipv4 "$ip" || is_valid_ipv6 "$ip"); then
+        is_valid_dns=true
+        break
+    fi
+done
+
+# 更新DNS设置
+if [ "$is_valid_dns" = false ]; then
+    echo "empty" >.original_dns.txt
+else
+    echo "$original_dns" >.original_dns.txt
+fi
+networksetup -setdnsservers "$hardware_port" "$1"
@@ -0,0 +1,20 @@
+#!/bin/bash
+nic=$(route -n get default | grep "interface" | awk '{print $2}')
+
+hardware_port=$(networksetup -listallhardwareports | awk -v dev="$nic" '
+    /Hardware Port:/{
+        port=$0; gsub("Hardware Port: ", "", port)
+    } 
+    /Device: /{
+        if ($2 == dev) {
+            print port; 
+            exit
+        }
+    }
+')
+
+if [ -f .original_dns.txt ]; then
+    original_dns=$(cat .original_dns.txt)
+    networksetup -setdnsservers "$hardware_port" $original_dns
+    rm -rf .original_dns.txt
+fi
@@ -1,4 +1,5 @@
-import fs from "fs-extra";
+import fs from "fs";
+import fsp from "fs/promises";
 import path from "path";

 const UPDATE_LOG = "UPDATELOG.md";
@@ -12,11 +13,11 @@ export async function resolveUpdateLog(tag) {

  const file = path.join(cwd, UPDATE_LOG);

-  if (!(await fs.pathExists(file))) {
+  if (!fs.existsSync(file)) {
    throw new Error("could not found UPDATELOG.md");
  }

-  const data = await fs.readFile(file).then((d) => d.toString("utf8"));
+  const data = await fsp.readFile(file, "utf-8");

  const map = {};
  let p = "";
@@ -100,7 +100,7 @@ async function resolveUpdater() {
  Object.entries(updateDataNew.platforms).forEach(([key, value]) => {
    if (value.url) {
      updateDataNew.platforms[key].url =
-        "https://mirror.ghproxy.com/" + value.url;
+        "https://download.clashverge.dev/" + value.url;
    } else {
      console.log(`[Error]: updateDataNew.platforms.${key} is null`);
    }
@@ -60,35 +60,35 @@ async function resolveUpdater() {
    const { name, browser_download_url } = asset;

    // win64 url
-    if (name.endsWith("x64-setup.nsis.zip")) {
+    if (name.endsWith("x64-setup.exe")) {
      updateData.platforms.win64.url = browser_download_url;
      updateData.platforms["windows-x86_64"].url = browser_download_url;
    }
    // win64 signature
-    if (name.endsWith("x64-setup.nsis.zip.sig")) {
+    if (name.endsWith("x64-setup.exe.sig")) {
      const sig = await getSignature(browser_download_url);
      updateData.platforms.win64.signature = sig;
      updateData.platforms["windows-x86_64"].signature = sig;
    }

    // win32 url
-    if (name.endsWith("x64-setup.nsis.zip")) {
+    if (name.endsWith("x86-setup.exe")) {
      updateData.platforms["windows-x86"].url = browser_download_url;
      updateData.platforms["windows-i686"].url = browser_download_url;
    }
    // win32 signature
-    if (name.endsWith("x64-setup.nsis.zip.sig")) {
+    if (name.endsWith("x86-setup.exe.sig")) {
      const sig = await getSignature(browser_download_url);
      updateData.platforms["windows-x86"].signature = sig;
      updateData.platforms["windows-i686"].signature = sig;
    }

    // win arm url
-    if (name.endsWith("arm64-setup.nsis.zip")) {
+    if (name.endsWith("arm64-setup.exe")) {
      updateData.platforms["windows-aarch64"].url = browser_download_url;
    }
    // win arm signature
-    if (name.endsWith("arm64-setup.nsis.zip.sig")) {
+    if (name.endsWith("arm64-setup.exe.sig")) {
      const sig = await getSignature(browser_download_url);
      updateData.platforms["windows-aarch64"].signature = sig;
    }
@@ -150,7 +150,7 @@ async function resolveUpdater() {
  Object.entries(updateDataNew.platforms).forEach(([key, value]) => {
    if (value.url) {
      updateDataNew.platforms[key].url =
-        "https://mirror.ghproxy.com/" + value.url;
+        "https://download.clashverge.dev/" + value.url;
    } else {
      console.log(`[Error]: updateDataNew.platforms.${key} is null`);
    }
@@ -0,0 +1,11 @@
+import clc from "cli-color";
+
+export const log_success = (msg, ...optionalParams) =>
+  console.log(clc.green(msg), ...optionalParams);
+export const log_error = (msg, ...optionalParams) =>
+  console.log(clc.red(msg), ...optionalParams);
+export const log_info = (msg, ...optionalParams) =>
+  console.log(clc.bgBlue(msg), ...optionalParams);
+var debugMsg = clc.xterm(245);
+export const log_debug = (msg, ...optionalParams) =>
+  console.log(debugMsg(msg), ...optionalParams);
@@ -1,6 +1,8 @@
 # Generated by Cargo
 # will have compiled files and executables
 /target/
+gen/
 WixTools
 resources
 sidecar
+
@@ -1,6 +1,6 @@
 [package]
 name = "clash-verge"
-version = "1.7.2"
+version = "2.1.2"
 description = "clash verge"
 authors = ["zzzgydi", "wonfen", "MystiPanda"]
 license = "GPL-3.0-only"
@@ -9,42 +9,80 @@ default-run = "clash-verge"
 edition = "2021"
 build = "build.rs"

+[package.metadata.bundle]
+identifier = "io.github.clash-verge-rev.clash-verge-rev"
+
 [build-dependencies]
-tauri-build = { version="1", features = [] }
+tauri-build = { version = "2.0.5", features = [] }

 [dependencies]
 warp = "0.3"
 anyhow = "1.0"
-dirs = "5.0"
+dirs = "6.0"
 open = "5.1"
 log = "0.4"
 dunce = "1.0"
 log4rs = "1"
 nanoid = "0.4"
 chrono = "0.4"
-sysinfo = "0.30"
-boa_engine = "0.18"
+sysinfo = "0.33.1"
+boa_engine = "0.20.0"
 serde_json = "1.0"
 serde_yaml = "0.9"
 once_cell = "1.19"
 port_scanner = "0.1.5"
-delay_timer = "0.11"
+delay_timer = "0.11.6"
 parking_lot = "0.12"
-auto-launch = "0.5.0"
 percent-encoding = "2.3.1"
-window-shadows = { version = "0.2" }
-tokio = { version = "1", features = ["full"] }
+window-shadows = { version = "0.2.2" }
+tokio = { version = "1.43", features = ["full"] }
 serde = { version = "1.0", features = ["derive"] }
 reqwest = { version = "0.12", features = ["json", "rustls-tls"] }
-sysproxy = { git="https://github.com/zzzgydi/sysproxy-rs", branch = "main" }
-tauri = { version="1", features = [ "fs-read-file", "fs-exists", "path-all", "protocol-asset", "dialog-open", "notification-all", "icon-png", "icon-ico", "clipboard-all", "global-shortcut-all", "process-all", "shell-all", "system-tray", "updater", "window-all", "devtools"] }
+sysproxy = { git = "https://github.com/clash-verge-rev/sysproxy-rs", rev = "3d748b5" }
+image = "0.24"
+imageproc = "0.23"
+rusttype = "0.9"
+tauri = { version = "2.2.5", features = [
+    "protocol-asset",
+    "devtools",
+    "tray-icon",
+    "image-ico",
+    "image-png",
+] }
+network-interface = { version = "2.0.0", features = ["serde"] }
+tauri-plugin-shell = "2.2.0"
+tauri-plugin-dialog = "2.2.0"
+tauri-plugin-fs = "2.2.0"
+tauri-plugin-notification = "2.2.1"
+tauri-plugin-process = "2.2.0"
+tauri-plugin-clipboard-manager = "2.2.1"
+tauri-plugin-deep-link = "2.2.0"
+tauri-plugin-devtools = "2.0.0-rc"
+url = "2.5.4"
+zip = "2.2.2"
+reqwest_dav = "0.1.14"
+aes-gcm = { version = "0.10.3", features = ["std"] }
+base64 = "0.22.1"
+getrandom = "0.2"
+tokio-tungstenite = "0.26.1"
+futures = "0.3"
+sys-locale = "0.3.1"
+
 [target.'cfg(windows)'.dependencies]
 runas = "=1.2.0"
 deelevate = "0.2.0"
-winreg = "0.52.0"
+winreg = "0.55.0"
+url = "2.5.4"
+

 [target.'cfg(target_os = "linux")'.dependencies]
 users = "0.11.0"
+
+[target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies]
+tauri-plugin-autostart = "2.2.0"
+tauri-plugin-global-shortcut = "2.2.0"
+tauri-plugin-updater = "2.3.0"
+tauri-plugin-window-state = "2.2.1"
 #openssl

 [features]
@@ -57,3 +95,11 @@ panic = "abort"
 codegen-units = 1
 lto = true
 opt-level = "s"
+strip = true
+
+[profile.dev]
+incremental = true
+
+[lib]
+name = "app_lib"
+crate-type = ["staticlib", "cdylib", "rlib"]
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-<key>CFBundleURLTypes</key>
-<array>
-    <dict>
-        <key>CFBundleURLName</key>
-        <string>Clash Verge</string>
-        <key>CFBundleURLSchemes</key>
-        <array>
-            <string>clash</string>
-        </array>
-    </dict>
-</array>
-</dict>
-</plist>
@@ -0,0 +1,21 @@
+{
+  "identifier": "desktop-capability",
+  "platforms": ["macOS", "windows", "linux"],
+  "webviews": ["main"],
+  "windows": ["main"],
+  "permissions": [
+    "global-shortcut:default",
+    "updater:default",
+    "dialog:default",
+    "dialog:allow-ask",
+    "dialog:allow-message",
+    "updater:default",
+    "updater:allow-check",
+    "updater:allow-download-and-install",
+    "process:allow-restart",
+    "deep-link:default",
+    "window-state:default",
+    "window-state:default",
+    "autostart:default"
+  ]
+}
@@ -0,0 +1,85 @@
+{
+  "identifier": "migrated",
+  "description": "permissions that were migrated from v1",
+  "local": true,
+  "windows": ["main"],
+  "permissions": [
+    "core:default",
+    "fs:allow-read-file",
+    "fs:allow-exists",
+    {
+      "identifier": "fs:scope",
+      "allow": ["$APPDATA/**", "$RESOURCE/../**", "**"]
+    },
+    "fs:allow-write-file",
+    {
+      "identifier": "fs:scope",
+      "allow": ["$APPDATA/**", "$RESOURCE/../**", "**"]
+    },
+    "fs:allow-app-read",
+    "fs:allow-app-read-recursive",
+    "fs:allow-appcache-read",
+    "fs:allow-appcache-read-recursive",
+    "fs:allow-appconfig-read",
+    "fs:allow-appconfig-read-recursive",
+    "core:window:allow-create",
+    "core:window:allow-center",
+    "core:window:allow-request-user-attention",
+    "core:window:allow-set-resizable",
+    "core:window:allow-set-maximizable",
+    "core:window:allow-set-minimizable",
+    "core:window:allow-set-closable",
+    "core:window:allow-set-title",
+    "core:window:allow-maximize",
+    "core:window:allow-unmaximize",
+    "core:window:allow-minimize",
+    "core:window:allow-unminimize",
+    "core:window:allow-show",
+    "core:window:allow-hide",
+    "core:window:allow-close",
+    "core:window:allow-set-decorations",
+    "core:window:allow-set-always-on-top",
+    "core:window:allow-set-content-protected",
+    "core:window:allow-set-size",
+    "core:window:allow-set-min-size",
+    "core:window:allow-set-max-size",
+    "core:window:allow-set-position",
+    "core:window:allow-set-fullscreen",
+    "core:window:allow-set-focus",
+    "core:window:allow-set-icon",
+    "core:window:allow-set-skip-taskbar",
+    "core:window:allow-set-cursor-grab",
+    "core:window:allow-set-cursor-visible",
+    "core:window:allow-set-cursor-icon",
+    "core:window:allow-set-cursor-position",
+    "core:window:allow-set-ignore-cursor-events",
+    "core:window:allow-start-dragging",
+    "core:window:allow-maximize",
+    "core:window:allow-toggle-maximize",
+    "core:window:allow-unmaximize",
+    "core:window:allow-minimize",
+    "core:window:allow-unminimize",
+    "core:window:allow-set-maximizable",
+    "core:window:allow-set-minimizable",
+    "core:webview:allow-print",
+    "shell:allow-execute",
+    "shell:allow-open",
+    "shell:allow-kill",
+    "shell:allow-spawn",
+    "shell:allow-stdin-write",
+    "dialog:allow-open",
+    "notification:default",
+    "global-shortcut:allow-is-registered",
+    "global-shortcut:allow-register",
+    "global-shortcut:allow-register-all",
+    "global-shortcut:allow-unregister",
+    "global-shortcut:allow-unregister-all",
+    "process:allow-restart",
+    "process:allow-exit",
+    "clipboard-manager:allow-read-text",
+    "clipboard-manager:allow-write-text",
+    "shell:default",
+    "dialog:default",
+    "notification:default"
+  ]
+}
@@ -2,8 +2,9 @@
 Categories={{{categories}}}
 Comment={{{comment}}}
 Exec={{{exec}}} %u
+StartupWMClass={{{exec}}}
 Icon={{{icon}}}
 Name={{{name}}}
 Terminal=false
 Type=Application
-MimeType=x-scheme-handler/clash;
+MimeType=x-scheme-handler/clash;
@@ -0,0 +1,4 @@
+#!/bin/bash
+chmod +x /usr/bin/install-service
+chmod +x /usr/bin/uninstall-service
+chmod +x /usr/bin/clash-verge-service
@@ -0,0 +1,2 @@
+#!/bin/bash
+/usr/bin/uninstall-service
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>com.apple.security.app-sandbox</key>
+    <false/>
+    <key>com.apple.security.application-groups</key>
+    <array>
+        <string>io.github.clash-verge-rev.clash-verge-rev</string>
+    </array>
+    <key>com.apple.security.inherit</key>
+    <true/>
+</dict>
+</plist>
@@ -1,5 +1,6 @@
 ; This file is copied from https://github.com/tauri-apps/tauri/blob/tauri-v1.5/tooling/bundler/src/bundle/windows/templates/installer.nsi
 ; and edit to fit the needs of the project. the latest tauri 2.x has a different base nsi script.
+RequestExecutionLevel admin

 Unicode true
 ; Set the compression algorithm. Default is LZMA.
@@ -16,6 +17,8 @@ Unicode true
 !include "StrFunc.nsh"
 !include "Win\COM.nsh"
 !include "Win\Propkey.nsh"
+!include "WinVer.nsh"
+!include "LogicLib.nsh"
 !addplugindir "$%AppData%\Local\NSIS\"
 ${StrCase}
 ${StrLoc}
@@ -688,11 +691,114 @@ SectionEnd
  app_check_done:
 !macroend

+
+
+Var VC_REDIST_URL
+Var VC_REDIST_EXE
+
+Section CheckAndInstallVSRuntime
+    ; 检查是否已安装 Visual C++ Redistributable
+    ${If} ${IsNativeARM64}
+        StrCpy $VC_REDIST_URL "https://aka.ms/vs/17/release/vc_redist.arm64.exe"
+        StrCpy $VC_REDIST_EXE "vc_redist.arm64.exe"
+        
+        ; 检查关键DLL
+        IfFileExists "$SYSDIR\vcruntime140.dll" 0 checkInstall
+        IfFileExists "$SYSDIR\msvcp140.dll" Done checkInstall
+        
+    ${ElseIf} ${RunningX64}
+        StrCpy $VC_REDIST_URL "https://aka.ms/vs/17/release/vc_redist.x64.exe"
+        StrCpy $VC_REDIST_EXE "vc_redist.x64.exe"
+        
+        ; 检查关键DLL
+        IfFileExists "$SYSDIR\vcruntime140.dll" 0 checkInstall
+        IfFileExists "$SYSDIR\msvcp140.dll" Done checkInstall
+        
+    ${Else}
+        StrCpy $VC_REDIST_URL "https://aka.ms/vs/17/release/vc_redist.x86.exe"
+        StrCpy $VC_REDIST_EXE "vc_redist.x86.exe"
+        
+        ; 检查关键DLL
+        IfFileExists "$SYSDIR\vcruntime140.dll" 0 checkInstall  
+        IfFileExists "$SYSDIR\msvcp140.dll" Done checkInstall
+    ${EndIf}
+
+    checkInstall:
+    ; 检查注册表
+    ${If} ${RunningX64}
+        SetRegView 64
+        ReadRegDword $R0 HKLM "SOFTWARE\Microsoft\VisualStudio\14.0\VC\Runtimes\${ARCH}" "Installed"
+        ${If} $R0 == "1"
+            Goto Done
+        ${EndIf}
+    ${Else}
+        ReadRegDword $R0 HKLM "SOFTWARE\Microsoft\VisualStudio\14.0\VC\Runtimes\x86" "Installed"
+        ${If} $R0 == "1"
+            Goto Done
+        ${EndIf}
+    ${EndIf}
+
+    ; 如果没有安装,则下载并安装
+    DetailPrint "正在下载 Visual C++ Redistributable..."
+    nsisdl::download "$VC_REDIST_URL" "$TEMP\$VC_REDIST_EXE"
+    Pop $0
+    ${If} $0 == "success"
+        DetailPrint "正在安装 Visual C++ Redistributable..."
+        ExecWait '"$TEMP\$VC_REDIST_EXE" /quiet /norestart' $0
+        ${If} $0 == 0
+            DetailPrint "Visual C++ Redistributable 安装成功"
+        ${Else}
+            DetailPrint "Visual C++ Redistributable 安装失败"
+        ${EndIf}
+        Delete "$TEMP\$VC_REDIST_EXE"
+    ${Else}
+        DetailPrint "Visual C++ Redistributable 下载失败"
+    ${EndIf}
+    
+    Done:
+SectionEnd
+
+
+
 Section Install
  SetOutPath $INSTDIR
-
+  nsExec::Exec 'netsh int tcp res'
  !insertmacro CheckIfAppIsRunning
  !insertmacro CheckAllVergeProcesses
+
+  ; 清理自启动注册表项
+  DetailPrint "Cleaning auto-launch registry entries..."
+
+  StrCpy $R1 "Software\Microsoft\Windows\CurrentVersion\Run"
+  
+  SetRegView 64  
+  ; 清理旧版本的注册表项 (Clash Verge)
+  ReadRegStr $R2 HKCU "$R1" "Clash Verge"
+  ${If} $R2 != ""
+    DeleteRegValue HKCU "$R1" "Clash Verge"
+  ${EndIf}
+  
+  ReadRegStr $R2 HKLM "$R1" "Clash Verge"
+  ${If} $R2 != ""
+    DeleteRegValue HKLM "$R1" "Clash Verge"
+  ${EndIf}
+
+  ; 清理新版本的注册表项 (clash-verge)
+  ReadRegStr $R2 HKCU "$R1" "clash-verge"
+  ${If} $R2 != ""
+    DeleteRegValue HKCU "$R1" "clash-verge"
+  ${EndIf}
+  
+  ReadRegStr $R2 HKLM "$R1" "clash-verge"
+  ${If} $R2 != ""
+    DeleteRegValue HKLM "$R1" "clash-verge"
+  ${EndIf}
+
+  ; Delete old files before installation
+    ; Delete clash-verge.desktop
+  IfFileExists "$INSTDIR\Clash Verge.exe" 0 +2
+    Delete "$INSTDIR\Clash Verge.exe"
+  
  ; Copy main executable
  File "${MAINBINARYSRCPATH}"

@@ -813,6 +919,35 @@ Section Uninstall
  !insertmacro CheckIfAppIsRunning
  !insertmacro CheckAllVergeProcesses
  !insertmacro RemoveVergeService
+
+  ; 清理自启动注册表项
+  DetailPrint "Cleaning auto-launch registry entries..."
+  
+  StrCpy $R1 "Software\Microsoft\Windows\CurrentVersion\Run"
+  
+  SetRegView 64
+  ; 清理旧版本的注册表项 (Clash Verge)
+  ReadRegStr $R2 HKCU "$R1" "Clash Verge"
+  ${If} $R2 != ""
+    DeleteRegValue HKCU "$R1" "Clash Verge"
+  ${EndIf}
+  
+  ReadRegStr $R2 HKLM "$R1" "Clash Verge"
+  ${If} $R2 != ""
+    DeleteRegValue HKLM "$R1" "Clash Verge"
+  ${EndIf}
+
+  ; 清理新版本的注册表项 (clash-verge)
+  ReadRegStr $R2 HKCU "$R1" "clash-verge"
+  ${If} $R2 != ""
+    DeleteRegValue HKCU "$R1" "clash-verge"
+  ${EndIf}
+  
+  ReadRegStr $R2 HKLM "$R1" "clash-verge"
+  ${If} $R2 != ""
+    DeleteRegValue HKLM "$R1" "clash-verge"
+  ${EndIf}
+
  ; Delete the app directory and its content from disk
  ; Copy main executable
  Delete "$INSTDIR\${MAINBINARYNAME}.exe"
@@ -827,6 +962,10 @@ Section Uninstall
    Delete "$INSTDIR\\{{this}}"
  {{/each}}

+  ; Delete clash-verge.desktop
+  IfFileExists "$INSTDIR\Clash Verge.exe" 0 +2
+    Delete "$INSTDIR\Clash Verge.exe"
+
  ; Delete uninstaller
  Delete "$INSTDIR\uninstall.exe"

@@ -2,26 +2,51 @@ use crate::{
    config::*,
    core::*,
    feat,
-    utils::{dirs, help, resolve},
+    utils::{dirs, help},
 };
-use crate::{ret_err, wrap_err};
+use crate::{log_err, ret_err, wrap_err};
 use anyhow::{Context, Result};
+use network_interface::NetworkInterface;
 use serde_yaml::Mapping;
-use std::collections::{HashMap, VecDeque};
+use std::collections::HashMap;
 use sysproxy::{Autoproxy, Sysproxy};
-use tauri::{api, Manager};
 type CmdResult<T = ()> = Result<T, String>;
+use reqwest_dav::list_cmd::ListFile;
+use tauri::Manager;
+use std::fs;
+
+#[tauri::command]
+pub fn copy_clash_env() -> CmdResult {
+    feat::copy_clash_env();
+    Ok(())
+}

 #[tauri::command]
 pub fn get_profiles() -> CmdResult<IProfiles> {
+    let _ = tray::Tray::global().update_menu();
    Ok(Config::profiles().data().clone())
 }

 #[tauri::command]
 pub async fn enhance_profiles() -> CmdResult {
-    wrap_err!(CoreManager::global().update_config().await)?;
-    handle::Handle::refresh_clash();
-    Ok(())
+    match CoreManager::global().update_config().await {
+        Ok((true, _)) => {
+            println!("[enhance_profiles] 配置更新成功");
+            log_err!(tray::Tray::global().update_tooltip());
+            handle::Handle::refresh_clash();
+            Ok(())
+        }
+        Ok((false, error_msg)) => {
+            println!("[enhance_profiles] 配置验证失败: {}", error_msg);
+            handle::Handle::notice_message("config_validate::error", &error_msg);
+            Ok(())
+        }
+        Err(e) => {
+            println!("[enhance_profiles] 更新过程发生错误: {}", e);
+            handle::Handle::notice_message("config_validate::process_terminated", &e.to_string());
+            Ok(())
+        }
+    }
 }

 #[tauri::command]
@@ -53,36 +78,80 @@ pub async fn delete_profile(index: String) -> CmdResult {
        wrap_err!(CoreManager::global().update_config().await)?;
        handle::Handle::refresh_clash();
    }
-
    Ok(())
 }

-/// 修改profiles的
+/// 修改profiles的配置
 #[tauri::command]
-pub async fn patch_profiles_config(profiles: IProfiles) -> CmdResult {
+pub async fn patch_profiles_config(
+    profiles: IProfiles
+) -> CmdResult<bool> {
+    println!("[cmd配置patch] 开始修改配置文件");
+    
+    // 保存当前配置，以便在验证失败时恢复
+    let current_profile = Config::profiles().latest().current.clone();
+    println!("[cmd配置patch] 当前配置: {:?}", current_profile);
+    
+    // 更新profiles配置
+    println!("[cmd配置patch] 正在更新配置草稿");
    wrap_err!({ Config::profiles().draft().patch_config(profiles) })?;
-
+    
+    // 更新配置并进行验证
    match CoreManager::global().update_config().await {
-        Ok(_) => {
+        Ok((true, _)) => {
+            println!("[cmd配置patch] 配置更新成功");
            handle::Handle::refresh_clash();
-            let _ = handle::Handle::update_systray_part();
+            let _ = tray::Tray::global().update_tooltip();
            Config::profiles().apply();
            wrap_err!(Config::profiles().data().save_file())?;
-            Ok(())
+            Ok(true)
        }
-        Err(err) => {
+        Ok((false, error_msg)) => {
+            println!("[cmd配置patch] 配置验证失败: {}", error_msg);
            Config::profiles().discard();
-            log::error!(target: "app", "{err}");
-            Err(format!("{err}"))
+            
+            // 如果验证失败，恢复到之前的配置
+            if let Some(prev_profile) = current_profile {
+                println!("[cmd配置patch] 尝试恢复到之前的配置: {}", prev_profile);
+                let restore_profiles = IProfiles {
+                    current: Some(prev_profile),
+                    items: None,
+                };
+                // 静默恢复，不触发验证
+                wrap_err!({ Config::profiles().draft().patch_config(restore_profiles) })?;
+                Config::profiles().apply();
+                wrap_err!(Config::profiles().data().save_file())?;
+                println!("[cmd配置patch] 成功恢复到之前的配置");
+            }
+
+            // 发送验证错误通知
+            handle::Handle::notice_message("config_validate::error", &error_msg);
+            Ok(false)
+        }
+        Err(e) => {
+            println!("[cmd配置patch] 更新过程发生错误: {}", e);
+            Config::profiles().discard();
+            handle::Handle::notice_message("config_validate::boot_error", &e.to_string());
+            Ok(false)
        }
    }
 }

+/// 根据profile name修改profiles
+#[tauri::command]
+pub async fn patch_profiles_config_by_profile_index(
+    _app_handle: tauri::AppHandle,
+    profile_index: String
+) -> CmdResult<bool> {
+    let profiles = IProfiles{current: Some(profile_index), items: None};
+    patch_profiles_config(profiles).await
+}
+
 /// 修改某个profile item的
 #[tauri::command]
 pub fn patch_profile(index: String, profile: PrfItem) -> CmdResult {
    wrap_err!(Config::profiles().data().patch_item(index, profile))?;
-    wrap_err!(timer::Timer::global().refresh())
+    Ok(())
 }

 #[tauri::command]
@@ -110,17 +179,107 @@ pub fn read_profile_file(index: String) -> CmdResult<String> {
    let data = wrap_err!(item.read_file())?;
    Ok(data)
 }
-
+/// 保存profiles的配置
 #[tauri::command]
-pub fn save_profile_file(index: String, file_data: Option<String>) -> CmdResult {
+pub async fn save_profile_file(index: String, file_data: Option<String>) -> CmdResult {
    if file_data.is_none() {
        return Ok(());
    }

-    let profiles = Config::profiles();
-    let profiles = profiles.latest();
-    let item = wrap_err!(profiles.get_item(&index))?;
-    wrap_err!(item.save_file(file_data.unwrap()))
+    // 在异步操作前完成所有文件操作
+    let (file_path, original_content, is_merge_file) = {
+        let profiles = Config::profiles();
+        let profiles_guard = profiles.latest();
+        let item = wrap_err!(profiles_guard.get_item(&index))?;
+        // 确定是否为merge类型文件
+        let is_merge = item.itype.as_ref().map_or(false, |t| t == "merge");
+        let content = wrap_err!(item.read_file())?;
+        let path = item.file.clone().ok_or("file field is null")?;
+        let profiles_dir = wrap_err!(dirs::app_profiles_dir())?;
+        (profiles_dir.join(path), content, is_merge)
+    };
+
+    // 保存新的配置文件
+    wrap_err!(fs::write(&file_path, file_data.clone().unwrap()))?;
+    
+    let file_path_str = file_path.to_string_lossy().to_string();
+    println!("[cmd配置save] 开始验证配置文件: {}, 是否为merge文件: {}", file_path_str, is_merge_file);
+    
+    // 对于 merge 文件，只进行语法验证，不进行后续内核验证
+    if is_merge_file {
+        println!("[cmd配置save] 检测到merge文件，只进行语法验证");
+        match CoreManager::global().validate_config_file(&file_path_str, Some(true)).await {
+            Ok((true, _)) => {
+                println!("[cmd配置save] merge文件语法验证通过");
+                // 成功后尝试更新整体配置
+                if let Err(e) = CoreManager::global().update_config().await {
+                    println!("[cmd配置save] 更新整体配置时发生错误: {}", e);
+                    log::warn!(target: "app", "更新整体配置时发生错误: {}", e);
+                }
+                return Ok(());
+            }
+            Ok((false, error_msg)) => {
+                println!("[cmd配置save] merge文件语法验证失败: {}", error_msg);
+                // 恢复原始配置文件
+                wrap_err!(fs::write(&file_path, original_content))?;
+                // 发送合并文件专用错误通知
+                let result = (false, error_msg.clone());
+                handle_yaml_validation_notice(&result, "合并配置文件");
+                return Ok(());
+            }
+            Err(e) => {
+                println!("[cmd配置save] 验证过程发生错误: {}", e);
+                // 恢复原始配置文件
+                wrap_err!(fs::write(&file_path, original_content))?;
+                return Err(e.to_string());
+            }
+        }
+    }
+    
+    // 非merge文件使用完整验证流程
+    match CoreManager::global().validate_config_file(&file_path_str, None).await {
+        Ok((true, _)) => {
+            println!("[cmd配置save] 验证成功");
+            Ok(())
+        }
+        Ok((false, error_msg)) => {
+            println!("[cmd配置save] 验证失败: {}", error_msg);
+            // 恢复原始配置文件
+            wrap_err!(fs::write(&file_path, original_content))?;
+            
+            // 智能判断错误类型
+            let is_script_error = file_path_str.ends_with(".js") || 
+                               error_msg.contains("Script syntax error") || 
+                               error_msg.contains("Script must contain a main function") ||
+                               error_msg.contains("Failed to read script file");
+            
+            if error_msg.contains("YAML syntax error") || 
+               error_msg.contains("Failed to read file:") ||
+               (!file_path_str.ends_with(".js") && !is_script_error) {
+                // 普通YAML错误使用YAML通知处理
+                println!("[cmd配置save] YAML配置文件验证失败，发送通知");
+                let result = (false, error_msg.clone());
+                handle_yaml_validation_notice(&result, "YAML配置文件");
+            } else if is_script_error {
+                // 脚本错误使用专门的通知处理
+                println!("[cmd配置save] 脚本文件验证失败，发送通知");
+                let result = (false, error_msg.clone());
+                handle_script_validation_notice(&result, "脚本文件");
+            } else {
+                // 普通配置错误使用一般通知
+                println!("[cmd配置save] 其他类型验证失败，发送一般通知");
+                handle::Handle::notice_message("config_validate::error", &error_msg);
+            }
+            
+            Ok(())
+        }
+        Err(e) => {
+            println!("[cmd配置save] 验证过程发生错误: {}", e);
+            // 恢复原始配置文件
+            wrap_err!(fs::write(&file_path, original_content))?;
+            Err(e.to_string())
+        }
+    }
 }

 #[tauri::command]
@@ -161,24 +320,47 @@ pub async fn patch_clash_config(payload: Mapping) -> CmdResult {
 }

 #[tauri::command]
-pub fn get_verge_config() -> CmdResult<IVerge> {
-    Ok(Config::verge().data().clone())
+pub async fn patch_clash_mode(payload: String) -> CmdResult {
+    Ok(feat::change_clash_mode(payload))
+}
+
+
+#[tauri::command]
+pub fn get_verge_config() -> CmdResult<IVergeResponse> {
+    let verge = Config::verge();
+    let verge_data = verge.data().clone();
+    Ok(IVergeResponse::from(verge_data))
 }

 #[tauri::command]
 pub async fn patch_verge_config(payload: IVerge) -> CmdResult {
-    wrap_err!(feat::patch_verge(payload).await)
+    wrap_err!(feat::patch_verge(payload, false).await)
 }

 #[tauri::command]
-pub async fn change_clash_core(clash_core: Option<String>) -> CmdResult {
-    wrap_err!(CoreManager::global().change_core(clash_core).await)
+pub async fn change_clash_core(clash_core: String) -> CmdResult<Option<String>> {
+    log::info!(target: "app", "changing core to {clash_core}");
+    
+    match CoreManager::global().change_core(Some(clash_core.clone())).await {
+        Ok(_) => {
+            log::info!(target: "app", "core changed to {clash_core}");
+            handle::Handle::notice_message("config_core::change_success", &clash_core);
+            handle::Handle::refresh_clash();
+            Ok(None)
+        }
+        Err(err) => {
+            let error_msg = err.to_string();
+            log::error!(target: "app", "failed to change core: {error_msg}");
+            handle::Handle::notice_message("config_core::change_error", &error_msg);
+            Ok(Some(error_msg))
+        }
+    }
 }

 /// restart the sidecar
 #[tauri::command]
-pub async fn restart_sidecar() -> CmdResult {
-    wrap_err!(CoreManager::global().run_core().await)
+pub async fn restart_core() -> CmdResult {
+    wrap_err!(CoreManager::global().restart_core().await)
 }

 /// get the system proxy
@@ -208,11 +390,6 @@ pub fn get_auto_proxy() -> CmdResult<Mapping> {
    Ok(map)
 }

-#[tauri::command]
-pub fn get_clash_logs() -> CmdResult<VecDeque<String>> {
-    Ok(logger::Logger::global().get_log())
-}
-
 #[tauri::command]
 pub fn open_app_dir() -> CmdResult<()> {
    let app_dir = wrap_err!(dirs::app_home_dir())?;
@@ -322,9 +499,39 @@ pub fn copy_icon_file(path: String, name: String) -> CmdResult<String> {
    }
 }

+#[tauri::command]
+pub fn get_network_interfaces() -> Vec<String> {
+    use sysinfo::Networks;
+    let mut result = Vec::new();
+    let networks = Networks::new_with_refreshed_list();
+    for (interface_name, _) in &networks {
+        result.push(interface_name.clone());
+    }
+    result
+}
+
+#[tauri::command]
+pub fn get_network_interfaces_info() -> CmdResult<Vec<NetworkInterface>> {
+    use network_interface::NetworkInterface;
+    use network_interface::NetworkInterfaceConfig;
+
+    let names = get_network_interfaces();
+    let interfaces = wrap_err!(NetworkInterface::show())?;
+
+    let mut result = Vec::new();
+
+    for interface in interfaces {
+        if names.contains(&interface.name) {
+            result.push(interface);
+        }
+    }
+
+    Ok(result)
+}
+
 #[tauri::command]
 pub fn open_devtools(app_handle: tauri::AppHandle) {
-    if let Some(window) = app_handle.get_window("main") {
+    if let Some(window) = app_handle.get_webview_window("main") {
        if !window.is_devtools_open() {
            window.open_devtools();
        } else {
@@ -334,32 +541,52 @@ pub fn open_devtools(app_handle: tauri::AppHandle) {
 }

 #[tauri::command]
-pub fn exit_app(app_handle: tauri::AppHandle) {
-    let _ = resolve::save_window_size_position(&app_handle, true);
-    resolve::resolve_reset();
-    api::process::kill_children();
-    app_handle.exit(0);
-    std::process::exit(0);
+pub fn exit_app() {
+    feat::quit(Some(0));
 }

-pub mod service {
-    use super::*;
-    use crate::core::service;
+#[tauri::command]
+pub async fn save_webdav_config(url: String, username: String, password: String) -> CmdResult<()> {
+    let patch = IVerge {
+        webdav_url: Some(url),
+        webdav_username: Some(username),
+        webdav_password: Some(password),
+        ..IVerge::default()
+    };
+    Config::verge().draft().patch_config(patch.clone());
+    Config::verge().apply();
+    Config::verge()
+        .data()
+        .save_file()
+        .map_err(|err| err.to_string())?;
+    backup::WebDavClient::global().reset();
+    Ok(())
+}

-    #[tauri::command]
-    pub async fn check_service() -> CmdResult<service::JsonResponse> {
-        wrap_err!(service::check_service().await)
-    }
+#[tauri::command]
+pub async fn create_webdav_backup() -> CmdResult<()> {
+    wrap_err!(feat::create_backup_and_upload_webdav().await)
+}

-    #[tauri::command]
-    pub async fn install_service() -> CmdResult {
-        wrap_err!(service::install_service().await)
-    }
+#[tauri::command]
+pub async fn list_webdav_backup() -> CmdResult<Vec<ListFile>> {
+    wrap_err!(feat::list_wevdav_backup().await)
+}

-    #[tauri::command]
-    pub async fn uninstall_service() -> CmdResult {
-        wrap_err!(service::uninstall_service().await)
-    }
+#[tauri::command]
+pub async fn delete_webdav_backup(filename: String) -> CmdResult<()> {
+    wrap_err!(feat::delete_webdav_backup(filename).await)
+}
+
+#[tauri::command]
+pub async fn restore_webdav_backup(filename: String) -> CmdResult<()> {
+    wrap_err!(feat::restore_webdav_backup(filename).await)
+}
+
+#[tauri::command]
+pub async fn restart_app() -> CmdResult<()> {
+    feat::restart_app();
+    Ok(())
 }

 #[cfg(not(windows))]
@@ -371,3 +598,101 @@ pub mod uwp {
        Ok(())
    }
 }
+
+#[tauri::command]
+pub async fn script_validate_notice(status: String, msg: String) -> CmdResult {
+    handle::Handle::notice_message(&status, &msg);
+    Ok(())
+}
+
+/// 处理脚本验证相关的所有消息通知
+/// 统一通知接口，保持消息类型一致性
+pub fn handle_script_validation_notice(result: &(bool, String), file_type: &str) {
+    if !result.0 {
+        let error_msg = &result.1;
+        
+        // 根据错误消息内容判断错误类型
+        let status = if error_msg.starts_with("File not found:") {
+            "config_validate::file_not_found"
+        } else if error_msg.starts_with("Failed to read script file:") {
+            "config_validate::script_error"
+        } else if error_msg.starts_with("Script syntax error:") {
+            "config_validate::script_syntax_error"
+        } else if error_msg == "Script must contain a main function" {
+            "config_validate::script_missing_main"
+        } else {
+            // 如果是其他类型错误，作为一般脚本错误处理
+            "config_validate::script_error"
+        };
+        
+        log::warn!(target: "app", "{} 验证失败: {}", file_type, error_msg);
+        handle::Handle::notice_message(status, error_msg);
+    }
+}
+
+/// 验证指定脚本文件
+#[tauri::command]
+pub async fn validate_script_file(file_path: String) -> CmdResult<bool> {
+    log::info!(target: "app", "验证脚本文件: {}", file_path);
+    
+    match CoreManager::global().validate_config_file(&file_path, None).await {
+        Ok(result) => {
+            handle_script_validation_notice(&result, "脚本文件");
+            Ok(result.0)  // 返回验证结果布尔值
+        },
+        Err(e) => {
+            let error_msg = e.to_string();
+            log::error!(target: "app", "验证脚本文件过程发生错误: {}", error_msg);
+            handle::Handle::notice_message("config_validate::process_terminated", &error_msg);
+            Ok(false)
+        }
+    }
+}
+
+/// 处理YAML验证相关的所有消息通知
+/// 统一通知接口，保持消息类型一致性
+pub fn handle_yaml_validation_notice(result: &(bool, String), file_type: &str) {
+    if !result.0 {
+        let error_msg = &result.1;
+        println!("[通知] 处理{}验证错误: {}", file_type, error_msg);
+        
+        // 检查是否为merge文件
+        let is_merge_file = file_type.contains("合并");
+        
+        // 根据错误消息内容判断错误类型
+        let status = if error_msg.starts_with("File not found:") {
+            "config_validate::file_not_found"
+        } else if error_msg.starts_with("Failed to read file:") {
+            "config_validate::yaml_read_error"
+        } else if error_msg.starts_with("YAML syntax error:") {
+            if is_merge_file {
+                "config_validate::merge_syntax_error"
+            } else {
+                "config_validate::yaml_syntax_error"
+            }
+        } else if error_msg.contains("mapping values are not allowed") {
+            if is_merge_file {
+                "config_validate::merge_mapping_error"
+            } else {
+                "config_validate::yaml_mapping_error"
+            }
+        } else if error_msg.contains("did not find expected key") {
+            if is_merge_file {
+                "config_validate::merge_key_error"
+            } else {
+                "config_validate::yaml_key_error"
+            }
+        } else {
+            // 如果是其他类型错误，根据文件类型作为一般错误处理
+            if is_merge_file {
+                "config_validate::merge_error"
+            } else {
+                "config_validate::yaml_error"
+            }
+        };
+        
+        log::warn!(target: "app", "{} 验证失败: {}", file_type, error_msg);
+        println!("[通知] 发送通知: status={}, msg={}", status, error_msg);
+        handle::Handle::notice_message(status, error_msg);
+    }
+}
@@ -32,13 +32,12 @@ impl IClashTemp {
    pub fn template() -> Self {
        let mut map = Mapping::new();
        let mut tun = Mapping::new();
-        tun.insert("stack".into(), "gvisor".into());
-        tun.insert("device".into(), "Mihomo".into());
+        tun.insert("enable".into(), false.into());
+        tun.insert("stack".into(), "mixed".into());
        tun.insert("auto-route".into(), true.into());
        tun.insert("strict-route".into(), false.into());
        tun.insert("auto-detect-interface".into(), true.into());
        tun.insert("dns-hijack".into(), vec!["any:53"].into());
-        tun.insert("mtu".into(), 1500.into());
        #[cfg(not(target_os = "windows"))]
        map.insert("redir-port".into(), 7895.into());
        #[cfg(target_os = "linux")]
@@ -50,9 +49,13 @@ impl IClashTemp {
        map.insert("allow-lan".into(), false.into());
        map.insert("mode".into(), "rule".into());
        map.insert("external-controller".into(), "127.0.0.1:9097".into());
+        let mut cors_map = Mapping::new();
+        cors_map.insert("allow-private-network".into(), true.into());
+        cors_map.insert("allow-origins".into(), vec!["*"].into());
        map.insert("secret".into(), "".into());
        map.insert("tun".into(), tun.into());
-
+        map.insert("external-controller-cors".into(), cors_map.into());
+        map.insert("unified-delay".into(), true.into());
        Self(map)
    }

@@ -153,17 +156,20 @@ impl IClashTemp {
    }

    pub fn guard_mixed_port(config: &Mapping) -> u16 {
-        let mut port = config
-            .get("mixed-port")
+        let raw_value = config.get("mixed-port");
+
+        let mut port = raw_value
            .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(7897);
+
        if port == 0 {
            port = 7897;
        }
+
        port
    }

@@ -3,10 +3,12 @@ use crate::{
    config::PrfItem,
    enhance,
    utils::{dirs, help},
+    core::{handle, CoreManager},
 };
 use anyhow::{anyhow, Result};
 use once_cell::sync::OnceCell;
-use std::{env::temp_dir, path::PathBuf};
+use std::path::PathBuf;
+use tokio::time::{sleep, Duration};

 pub const RUNTIME_CONFIG: &str = "clash-verge.yaml";
 pub const CHECK_CONFIG: &str = "clash-verge-check.yaml";
@@ -64,20 +66,57 @@ impl Config {
            let script_item = PrfItem::from_script(Some("Script".to_string()))?;
            Self::profiles().data().append_item(script_item.clone())?;
        }
-        crate::log_err!(Self::generate().await);
-        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"),
-                )?;
+        // 生成运行时配置
+        crate::log_err!(Self::generate().await);
+
+        // 生成运行时配置文件并验证
+        let config_result = Self::generate_file(ConfigType::Run);
+
+        let validation_result = if let Ok(_) = config_result {
+            // 验证配置文件
+            println!("[首次启动] 开始验证配置");
+            
+            match CoreManager::global().validate_config().await {
+                Ok((is_valid, error_msg)) => {
+                    if !is_valid {
+                        println!("[首次启动] 配置验证失败，使用默认最小配置启动: {}", error_msg);
+                        CoreManager::global()
+                            .use_default_config("config_validate::boot_error", &error_msg)
+                            .await?;
+                        Some(("config_validate::boot_error", error_msg))
+                    } else {
+                        println!("[首次启动] 配置验证成功");
+                        Some(("config_validate::success", String::new()))
+                    }
+                }
+                Err(err) => {
+                    println!("[首次启动] 验证进程执行失败: {}", err);
+                    CoreManager::global()
+                        .use_default_config("config_validate::process_terminated", "")
+                        .await?;
+                    Some(("config_validate::process_terminated", String::new()))
+                }
            }
+        } else {
+            println!("[首次启动] 生成配置文件失败，使用默认配置");
+            CoreManager::global()
+                .use_default_config(
+                    "config_validate::error",
+                    "",
+                )
+                .await?;
+            Some(("config_validate::error", String::new()))
+        };
+
+        // 在单独的任务中发送通知
+        if let Some((msg_type, msg_content)) = validation_result {
+            tauri::async_runtime::spawn(async move {
+                sleep(Duration::from_secs(2)).await;
+                handle::Handle::notice_message(msg_type, &msg_content);
+            });
        }
+
        Ok(())
    }

@@ -85,7 +124,7 @@ impl Config {
    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),
+            ConfigType::Check => dirs::app_home_dir()?.join(CHECK_CONFIG),
        };

        let runtime = Config::runtime();
@@ -0,0 +1,95 @@
+use crate::utils::dirs::get_encryption_key;
+use aes_gcm::{
+    aead::{Aead, KeyInit},
+    Aes256Gcm, Key,
+};
+use base64::{engine::general_purpose::STANDARD, Engine};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+const NONCE_LENGTH: usize = 12;
+
+/// Encrypt data
+pub fn encrypt_data(data: &str) -> Result<String, Box<dyn std::error::Error>> {
+    let encryption_key = get_encryption_key()?;
+    let key = Key::<Aes256Gcm>::from_slice(&encryption_key);
+    let cipher = Aes256Gcm::new(key);
+
+    // Generate random nonce
+    let mut nonce = vec![0u8; NONCE_LENGTH];
+    getrandom::getrandom(&mut nonce)?;
+
+    // Encrypt data
+    let ciphertext = cipher
+        .encrypt(nonce.as_slice().into(), data.as_bytes())
+        .map_err(|e| format!("Encryption failed: {}", e))?;
+
+    // Concatenate nonce and ciphertext and encode them in base64
+    let mut combined = nonce;
+    combined.extend(ciphertext);
+    Ok(STANDARD.encode(combined))
+}
+
+/// Decrypt data
+pub fn decrypt_data(encrypted: &str) -> Result<String, Box<dyn std::error::Error>> {
+    let encryption_key = get_encryption_key()?;
+    let key = Key::<Aes256Gcm>::from_slice(&encryption_key);
+    let cipher = Aes256Gcm::new(key);
+    // Decode from base64
+    let data = STANDARD.decode(encrypted)?;
+    if data.len() < NONCE_LENGTH {
+        return Err("Invalid encrypted data".into());
+    }
+
+    // Separate nonce and ciphertext
+    let (nonce, ciphertext) = data.split_at(NONCE_LENGTH);
+
+    // Decrypt data
+    let plaintext = cipher
+        .decrypt(nonce.into(), ciphertext)
+        .map_err(|e| format!("Decryption failed: {}", e))?;
+
+    String::from_utf8(plaintext).map_err(|e| e.into())
+}
+
+/// Serialize encrypted function
+pub fn serialize_encrypted<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
+where
+    T: Serialize,
+    S: Serializer,
+{
+    // 如果序列化失败，返回 None
+    let json = match serde_json::to_string(value) {
+        Ok(j) => j,
+        Err(_) => return serializer.serialize_none(),
+    };
+
+    // 如果加密失败，返回 None
+    match encrypt_data(&json) {
+        Ok(encrypted) => serializer.serialize_str(&encrypted),
+        Err(_) => serializer.serialize_none(),
+    }
+}
+
+/// Deserialize decrypted function
+pub fn deserialize_encrypted<'a, T, D>(deserializer: D) -> Result<T, D::Error>
+where
+    T: for<'de> Deserialize<'de> + Default,
+    D: Deserializer<'a>,
+{
+    // 如果反序列化字符串失败，返回默认值
+    let encrypted = match String::deserialize(deserializer) {
+        Ok(s) => s,
+        Err(_) => return Ok(T::default()),
+    };
+
+    // 如果解密失败，返回默认值
+    let decrypted_string = match decrypt_data(&encrypted) {
+        Ok(data) => data,
+        Err(_) => return Ok(T::default()),
+    };
+    // 如果 JSON 解析失败，返回默认值
+    match serde_json::from_str(&decrypted_string) {
+        Ok(value) => Ok(value),
+        Err(_) => Ok(T::default()),
+    }
+}
@@ -2,6 +2,7 @@ mod clash;
 #[allow(clippy::module_inception)]
 mod config;
 mod draft;
+mod encrypt;
 mod prfitem;
 mod profiles;
 mod runtime;
@@ -10,6 +11,7 @@ mod verge;
 pub use self::clash::*;
 pub use self::config::*;
 pub use self::draft::*;
+pub use self::encrypt::*;
 pub use self::prfitem::*;
 pub use self::profiles::*;
 pub use self::runtime::*;
@@ -71,7 +71,6 @@ impl IProfiles {
        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;
            }
@@ -111,6 +110,7 @@ impl IProfiles {
        if item.uid.is_none() {
            bail!("the uid should not be null");
        }
+        let uid = item.uid.clone();

        // save the file data
        // move the field value after save
@@ -128,6 +128,12 @@ impl IProfiles {
                .with_context(|| format!("failed to write to file \"{}\"", file))?;
        }

+        if self.current.is_none()
+            && (item.itype == Some("remote".to_string()) || item.itype == Some("local".to_string()))
+        {
+            self.current = uid;
+        }
+
        if self.items.is_none() {
            self.items = Some(vec![]);
        }
@@ -135,6 +141,7 @@ impl IProfiles {
        if let Some(items) = self.items.as_mut() {
            items.push(item)
        }
+
        self.save_file()
    }

@@ -355,10 +362,15 @@ impl IProfiles {
        }
        // delete the original uid
        if current == uid {
-            self.current = match !items.is_empty() {
-                true => items[0].uid.clone(),
-                false => None,
-            };
+            self.current = None;
+            for item in items.iter() {
+                if item.itype == Some("remote".to_string())
+                    || item.itype == Some("local".to_string())
+                {
+                    self.current = item.uid.clone();
+                    break;
+                }
+            }
        }

        self.items = Some(items);
@@ -452,4 +464,23 @@ impl IProfiles {
            _ => None,
        }
    }
+
+    /// 判断profile是否是current指向的
+    pub fn is_current_profile_index(&self, index: String) -> bool {
+        self.current == Some(index)
+    }
+
+    /// 获取所有的profiles(uid，名称)
+    pub fn all_profile_uid_and_name(&self) -> Option<Vec<(String, String)>> {
+        match self.items.as_ref() {
+            Some(items) => Some(items.iter().filter_map(|e| {
+                if let (Some(uid), Some(name)) = (e.uid.clone(), e.name.clone()) {
+                    Some((uid, name))
+                } else {
+                    None
+                }
+            }).collect()),
+            None => None,
+        }
+    }
 }
@@ -19,27 +19,31 @@ impl IRuntime {
    // 这里只更改 allow-lan | ipv6 | log-level | tun
    pub fn patch_config(&mut self, patch: Mapping) {
        if let Some(config) = self.config.as_mut() {
-            ["allow-lan", "ipv6", "log-level"]
+            ["allow-lan", "ipv6", "log-level", "unified-delay"]
                .into_iter()
                .for_each(|key| {
                    if let Some(value) = patch.get(key).to_owned() {
                        config.insert(key.into(), value.clone());
                    }
                });
-            let tun = config.get("tun");
-            let mut tun = tun.map_or(Mapping::new(), |val| {
-                val.as_mapping().cloned().unwrap_or(Mapping::new())
-            });
+
            let patch_tun = patch.get("tun");
-            let patch_tun = patch_tun.map_or(Mapping::new(), |val| {
-                val.as_mapping().cloned().unwrap_or(Mapping::new())
-            });
-            use_keys(&patch_tun).into_iter().for_each(|key| {
-                if let Some(value) = patch_tun.get(&key).to_owned() {
-                    tun.insert(key.into(), value.clone());
-                }
-            });
-            config.insert("tun".into(), Value::from(tun));
+            if patch_tun.is_some() {
+                let tun = config.get("tun");
+                let mut tun = tun.map_or(Mapping::new(), |val| {
+                    val.as_mapping().cloned().unwrap_or(Mapping::new())
+                });
+                let patch_tun = patch_tun.map_or(Mapping::new(), |val| {
+                    val.as_mapping().cloned().unwrap_or(Mapping::new())
+                });
+                use_keys(&patch_tun).into_iter().for_each(|key| {
+                    if let Some(value) = patch_tun.get(&key).to_owned() {
+                        tun.insert(key.into(), value.clone());
+                    }
+                });
+
+                config.insert("tun".into(), Value::from(tun));
+            }
        }
    }
 }
@@ -1,4 +1,6 @@
 use crate::config::DEFAULT_PAC;
+use crate::config::{deserialize_encrypted, serialize_encrypted};
+use crate::utils::i18n;
 use crate::utils::{dirs, help};
 use anyhow::Result;
 use log::LevelFilter;
@@ -7,9 +9,6 @@ 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>,
@@ -59,10 +58,6 @@ pub struct IVerge {
    /// 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>,

@@ -103,6 +98,9 @@ pub struct IVerge {
    /// hotkey map
    /// format: {func},{key}
    pub hotkeys: Option<Vec<String>>,
+    
+    /// enable global hotkey
+    pub enable_global_hotkey: Option<bool>,

    /// 切换代理时自动关闭连接
    pub auto_close_connection: Option<bool>,
@@ -122,21 +120,13 @@ pub struct IVerge {
    /// proxy 页面布局 列数
    pub proxy_layout_column: Option<i32>,

-    /// 测试网站列表
+    /// 测试站列表
    pub test_list: Option<Vec<IVergeTestItem>>,

    /// 日志清理
    /// 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>>,
-
-    /// window size and position
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub window_is_maximized: Option<bool>,
-
    /// 是否启用随机端口
    pub enable_random_port: Option<bool>,

@@ -162,6 +152,38 @@ pub struct IVerge {
    pub verge_port: Option<u16>,

    pub verge_http_enabled: Option<bool>,
+
+    /// WebDAV 配置 (加密存储)
+    #[serde(
+        serialize_with = "serialize_encrypted",
+        deserialize_with = "deserialize_encrypted",
+        skip_serializing_if = "Option::is_none",
+        default
+    )]
+    pub webdav_url: Option<String>,
+
+    /// WebDAV 用户名 (加密存储)
+    #[serde(
+        serialize_with = "serialize_encrypted",
+        deserialize_with = "deserialize_encrypted",
+        skip_serializing_if = "Option::is_none",
+        default
+    )]
+    pub webdav_username: Option<String>,
+
+    /// WebDAV 密码 (加密存储)
+    #[serde(
+        serialize_with = "serialize_encrypted",
+        deserialize_with = "deserialize_encrypted",
+        skip_serializing_if = "Option::is_none",
+        default
+    )]
+    pub webdav_password: Option<String>,
+
+    pub enable_tray_speed: Option<bool>,
+
+    /// 轻量模式 - 只保留内核运行
+    pub enable_lite_mode: Option<bool>,
 }

 #[derive(Default, Debug, Clone, Deserialize, Serialize)]
@@ -189,6 +211,21 @@ pub struct IVergeTheme {
 }

 impl IVerge {
+    fn get_system_language() -> String {
+        let sys_lang = sys_locale::get_locale()
+            .unwrap_or_else(|| String::from("en"))
+            .to_lowercase();
+
+        let lang_code = sys_lang.split(['_', '-']).next().unwrap_or("en");
+        let supported_languages = i18n::get_supported_languages();
+
+        if supported_languages.contains(&lang_code.to_string()) {
+            lang_code.to_string()
+        } else {
+            String::from("en")
+        }
+    }
+
    pub fn new() -> Self {
        match dirs::verge_path().and_then(|path| help::read_yaml::<IVerge>(&path)) {
            Ok(config) => config,
@@ -202,7 +239,7 @@ impl IVerge {
    pub fn template() -> Self {
        Self {
            clash_core: Some("verge-mihomo".into()),
-            language: Some("zh".into()),
+            language: Some(Self::get_system_language()),
            theme_mode: Some("system".into()),
            #[cfg(not(target_os = "windows"))]
            env_type: Some("bash".into()),
@@ -227,16 +264,16 @@ impl IVerge {
            #[cfg(not(target_os = "windows"))]
            verge_redir_port: Some(7895),
            #[cfg(not(target_os = "windows"))]
-            verge_redir_enabled: Some(true),
+            verge_redir_enabled: Some(false),
            #[cfg(target_os = "linux")]
            verge_tproxy_port: Some(7896),
            #[cfg(target_os = "linux")]
-            verge_tproxy_enabled: Some(true),
+            verge_tproxy_enabled: Some(false),
            verge_mixed_port: Some(7897),
            verge_socks_port: Some(7898),
-            verge_socks_enabled: Some(true),
+            verge_socks_enabled: Some(false),
            verge_port: Some(7899),
-            verge_http_enabled: Some(true),
+            verge_http_enabled: Some(false),
            enable_proxy_guard: Some(false),
            use_default_bypass: Some(true),
            proxy_guard_duration: Some(30),
@@ -244,6 +281,12 @@ impl IVerge {
            auto_check_update: Some(true),
            enable_builtin_enhanced: Some(true),
            auto_log_clean: Some(3),
+            webdav_url: None,
+            webdav_username: None,
+            webdav_password: None,
+            enable_tray_speed: Some(true),
+            enable_global_hotkey: Some(true),
+            enable_lite_mode: Some(false),
            ..Self::default()
        }
    }
@@ -282,7 +325,6 @@ impl IVerge {
        patch!(tun_tray_icon);

        patch!(enable_tun_mode);
-        patch!(enable_service_mode);
        patch!(enable_auto_launch);
        patch!(enable_silent_start);
        patch!(enable_random_port);
@@ -311,6 +353,7 @@ impl IVerge {
        patch!(web_ui_list);
        patch!(clash_core);
        patch!(hotkeys);
+        patch!(enable_global_hotkey);

        patch!(auto_close_connection);
        patch!(auto_check_update);
@@ -320,8 +363,12 @@ impl IVerge {
        patch!(proxy_layout_column);
        patch!(test_list);
        patch!(auto_log_clean);
-        patch!(window_size_position);
-        patch!(window_is_maximized);
+
+        patch!(webdav_url);
+        patch!(webdav_username);
+        patch!(webdav_password);
+        patch!(enable_tray_speed);
+        patch!(enable_lite_mode);
    }

    /// 在初始化前尝试拿到单例端口的值
@@ -330,11 +377,7 @@ impl IVerge {
        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错误了
-        }
+        SERVER_PORT
    }

    /// 获取日志等级
@@ -354,3 +397,130 @@ impl IVerge {
        }
    }
 }
+
+#[derive(Debug, Clone, Serialize)]
+pub struct IVergeResponse {
+    pub app_log_level: Option<String>,
+    pub language: Option<String>,
+    pub theme_mode: Option<String>,
+    pub tray_event: Option<String>,
+    pub env_type: Option<String>,
+    pub start_page: Option<String>,
+    pub startup_script: Option<String>,
+    pub traffic_graph: Option<bool>,
+    pub enable_memory_usage: Option<bool>,
+    pub enable_group_icon: Option<bool>,
+    pub common_tray_icon: Option<bool>,
+    #[cfg(target_os = "macos")]
+    pub tray_icon: Option<String>,
+    pub menu_icon: Option<String>,
+    pub sysproxy_tray_icon: Option<bool>,
+    pub tun_tray_icon: Option<bool>,
+    pub enable_tun_mode: Option<bool>,
+    pub enable_auto_launch: Option<bool>,
+    pub enable_silent_start: Option<bool>,
+    pub enable_system_proxy: Option<bool>,
+    pub enable_proxy_guard: Option<bool>,
+    pub enable_global_hotkey: Option<bool>,
+    pub use_default_bypass: Option<bool>,
+    pub system_proxy_bypass: Option<String>,
+    pub proxy_guard_duration: Option<u64>,
+    pub proxy_auto_config: Option<bool>,
+    pub pac_file_content: Option<String>,
+    pub theme_setting: Option<IVergeTheme>,
+    pub web_ui_list: Option<Vec<String>>,
+    pub clash_core: Option<String>,
+    pub hotkeys: Option<Vec<String>>,
+    pub auto_close_connection: Option<bool>,
+    pub auto_check_update: Option<bool>,
+    pub default_latency_test: Option<String>,
+    pub default_latency_timeout: Option<i32>,
+    pub enable_builtin_enhanced: Option<bool>,
+    pub proxy_layout_column: Option<i32>,
+    pub test_list: Option<Vec<IVergeTestItem>>,
+    pub auto_log_clean: Option<i32>,
+    pub enable_random_port: Option<bool>,
+    #[cfg(not(target_os = "windows"))]
+    pub verge_redir_port: Option<u16>,
+    #[cfg(not(target_os = "windows"))]
+    pub verge_redir_enabled: Option<bool>,
+    #[cfg(target_os = "linux")]
+    pub verge_tproxy_port: Option<u16>,
+    #[cfg(target_os = "linux")]
+    pub verge_tproxy_enabled: Option<bool>,
+    pub verge_mixed_port: Option<u16>,
+    pub verge_socks_port: Option<u16>,
+    pub verge_socks_enabled: Option<bool>,
+    pub verge_port: Option<u16>,
+    pub verge_http_enabled: Option<bool>,
+    pub webdav_url: Option<String>,
+    pub webdav_username: Option<String>,
+    pub webdav_password: Option<String>,
+    pub enable_tray_speed: Option<bool>,
+    pub enable_lite_mode: Option<bool>,
+}
+
+impl From<IVerge> for IVergeResponse {
+    fn from(verge: IVerge) -> Self {
+        Self {
+            app_log_level: verge.app_log_level,
+            language: verge.language,
+            theme_mode: verge.theme_mode,
+            tray_event: verge.tray_event,
+            env_type: verge.env_type,
+            start_page: verge.start_page,
+            startup_script: verge.startup_script,
+            traffic_graph: verge.traffic_graph,
+            enable_memory_usage: verge.enable_memory_usage,
+            enable_group_icon: verge.enable_group_icon,
+            common_tray_icon: verge.common_tray_icon,
+            #[cfg(target_os = "macos")]
+            tray_icon: verge.tray_icon,
+            menu_icon: verge.menu_icon,
+            sysproxy_tray_icon: verge.sysproxy_tray_icon,
+            tun_tray_icon: verge.tun_tray_icon,
+            enable_tun_mode: verge.enable_tun_mode,
+            enable_auto_launch: verge.enable_auto_launch,
+            enable_silent_start: verge.enable_silent_start,
+            enable_system_proxy: verge.enable_system_proxy,
+            enable_proxy_guard: verge.enable_proxy_guard,
+            enable_global_hotkey: verge.enable_global_hotkey,
+            use_default_bypass: verge.use_default_bypass,
+            system_proxy_bypass: verge.system_proxy_bypass,
+            proxy_guard_duration: verge.proxy_guard_duration,
+            proxy_auto_config: verge.proxy_auto_config,
+            pac_file_content: verge.pac_file_content,
+            theme_setting: verge.theme_setting,
+            web_ui_list: verge.web_ui_list,
+            clash_core: verge.clash_core,
+            hotkeys: verge.hotkeys,
+            auto_close_connection: verge.auto_close_connection,
+            auto_check_update: verge.auto_check_update,
+            default_latency_test: verge.default_latency_test,
+            default_latency_timeout: verge.default_latency_timeout,
+            enable_builtin_enhanced: verge.enable_builtin_enhanced,
+            proxy_layout_column: verge.proxy_layout_column,
+            test_list: verge.test_list,
+            auto_log_clean: verge.auto_log_clean,
+            enable_random_port: verge.enable_random_port,
+            #[cfg(not(target_os = "windows"))]
+            verge_redir_port: verge.verge_redir_port,
+            #[cfg(not(target_os = "windows"))]
+            verge_redir_enabled: verge.verge_redir_enabled,
+            #[cfg(target_os = "linux")]
+            verge_tproxy_port: verge.verge_tproxy_port,
+            #[cfg(target_os = "linux")]
+            verge_tproxy_enabled: verge.verge_tproxy_enabled,
+            verge_mixed_port: verge.verge_mixed_port,
+            verge_socks_port: verge.verge_socks_port,
+            verge_socks_enabled: verge.verge_socks_enabled,
+            verge_port: verge.verge_port,
+            verge_http_enabled: verge.verge_http_enabled,
+            webdav_url: verge.webdav_url,
+            webdav_username: verge.webdav_username,
+            webdav_password: verge.webdav_password,
+            enable_tray_speed: verge.enable_tray_speed,
+            enable_lite_mode: verge.enable_lite_mode,
+        }
+    }
+}
@@ -0,0 +1,226 @@
+use crate::config::Config;
+use crate::utils::dirs;
+use anyhow::Error;
+use once_cell::sync::OnceCell;
+use parking_lot::Mutex;
+use reqwest_dav::list_cmd::{ListEntity, ListFile};
+use std::collections::HashMap;
+use std::env::{consts::OS, temp_dir};
+use std::fs;
+use std::io::Write;
+use std::path::PathBuf;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::time::timeout;
+use zip::write::SimpleFileOptions;
+
+const TIMEOUT_UPLOAD: u64 = 300; // 上传超时 5 分钟
+const TIMEOUT_DOWNLOAD: u64 = 300; // 下载超时 5 分钟
+const TIMEOUT_LIST: u64 = 3; // 列表超时 30 秒
+const TIMEOUT_DELETE: u64 = 3; // 删除超时 30 秒
+
+#[derive(Clone)]
+struct WebDavConfig {
+    url: String,
+    username: String,
+    password: String,
+}
+
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
+enum Operation {
+    Upload,
+    Download,
+    List,
+    Delete,
+}
+
+impl Operation {
+    fn timeout(&self) -> u64 {
+        match self {
+            Operation::Upload => TIMEOUT_UPLOAD,
+            Operation::Download => TIMEOUT_DOWNLOAD,
+            Operation::List => TIMEOUT_LIST,
+            Operation::Delete => TIMEOUT_DELETE,
+        }
+    }
+}
+
+pub struct WebDavClient {
+    config: Arc<Mutex<Option<WebDavConfig>>>,
+    clients: Arc<Mutex<HashMap<Operation, reqwest_dav::Client>>>,
+}
+
+impl WebDavClient {
+    pub fn global() -> &'static WebDavClient {
+        static WEBDAV_CLIENT: OnceCell<WebDavClient> = OnceCell::new();
+        WEBDAV_CLIENT.get_or_init(|| WebDavClient {
+            config: Arc::new(Mutex::new(None)),
+            clients: Arc::new(Mutex::new(HashMap::new())),
+        })
+    }
+
+    async fn get_client(&self, op: Operation) -> Result<reqwest_dav::Client, Error> {
+        // 先尝试从缓存获取
+        {
+            let clients = self.clients.lock();
+            if let Some(client) = clients.get(&op) {
+                return Ok(client.clone());
+            }
+        }
+
+        // 获取或创建配置
+        let config = {
+            let mut lock = self.config.lock();
+            if let Some(cfg) = lock.as_ref() {
+                cfg.clone()
+            } else {
+                let verge = Config::verge().latest().clone();
+                if verge.webdav_url.is_none()
+                    || verge.webdav_username.is_none()
+                    || verge.webdav_password.is_none()
+                {
+                    let msg = "Unable to create web dav client, please make sure the webdav config is correct".to_string();
+                    return Err(anyhow::Error::msg(msg));
+                }
+
+                let config = WebDavConfig {
+                    url: verge
+                        .webdav_url
+                        .unwrap_or_default()
+                        .trim_end_matches('/')
+                        .to_string(),
+                    username: verge.webdav_username.unwrap_or_default(),
+                    password: verge.webdav_password.unwrap_or_default(),
+                };
+
+                *lock = Some(config.clone());
+                config
+            }
+        };
+
+        // 创建新的客户端
+        let client = reqwest_dav::ClientBuilder::new()
+            .set_agent(
+                reqwest::Client::builder()
+                    .danger_accept_invalid_certs(true)
+                    .timeout(Duration::from_secs(op.timeout()))
+                    .build()
+                    .unwrap(),
+            )
+            .set_host(config.url)
+            .set_auth(reqwest_dav::Auth::Basic(config.username, config.password))
+            .build()?;
+
+        // 确保备份目录存在
+        let list_result = client
+            .list(dirs::BACKUP_DIR, reqwest_dav::Depth::Number(0))
+            .await;
+        if list_result.is_err() {
+            client.mkcol(dirs::BACKUP_DIR).await?;
+        }
+
+        // 缓存客户端
+        {
+            let mut clients = self.clients.lock();
+            clients.insert(op, client.clone());
+        }
+
+        Ok(client)
+    }
+
+    pub fn reset(&self) {
+        *self.config.lock() = None;
+        self.clients.lock().clear();
+    }
+
+    pub async fn upload(&self, file_path: PathBuf, file_name: String) -> Result<(), Error> {
+        let client = self.get_client(Operation::Upload).await?;
+        let webdav_path: String = format!("{}/{}", dirs::BACKUP_DIR, file_name);
+        let fut = client.put(webdav_path.as_ref(), fs::read(file_path)?);
+        timeout(Duration::from_secs(TIMEOUT_UPLOAD), fut).await??;
+        Ok(())
+    }
+
+    pub async fn download(&self, filename: String, storage_path: PathBuf) -> Result<(), Error> {
+        let client = self.get_client(Operation::Download).await?;
+        let path = format!("{}/{}", dirs::BACKUP_DIR, filename);
+
+        let fut = async {
+            let response = client.get(path.as_str()).await?;
+            let content = response.bytes().await?;
+            fs::write(&storage_path, &content)?;
+            Ok::<(), Error>(())
+        };
+
+        timeout(Duration::from_secs(TIMEOUT_DOWNLOAD), fut).await??;
+        Ok(())
+    }
+
+    pub async fn list(&self) -> Result<Vec<ListFile>, Error> {
+        let client = self.get_client(Operation::List).await?;
+        let path = format!("{}/", dirs::BACKUP_DIR);
+
+        let fut = async {
+            let files = client
+                .list(path.as_str(), reqwest_dav::Depth::Number(1))
+                .await?;
+            let mut final_files = Vec::new();
+            for file in files {
+                if let ListEntity::File(file) = file {
+                    final_files.push(file);
+                }
+            }
+            Ok::<Vec<ListFile>, Error>(final_files)
+        };
+
+        timeout(Duration::from_secs(TIMEOUT_LIST), fut).await?
+    }
+
+    pub async fn delete(&self, file_name: String) -> Result<(), Error> {
+        let client = self.get_client(Operation::Delete).await?;
+        let path = format!("{}/{}", dirs::BACKUP_DIR, file_name);
+
+        let fut = client.delete(&path);
+        timeout(Duration::from_secs(TIMEOUT_DELETE), fut).await??;
+        Ok(())
+    }
+}
+
+pub fn create_backup() -> Result<(String, PathBuf), Error> {
+    let now = chrono::Local::now().format("%Y-%m-%d_%H-%M-%S").to_string();
+    let zip_file_name = format!("{}-backup-{}.zip", OS, now);
+    let zip_path = temp_dir().join(&zip_file_name);
+
+    let file = fs::File::create(&zip_path)?;
+    let mut zip = zip::ZipWriter::new(file);
+    zip.add_directory("profiles/", SimpleFileOptions::default())?;
+    let options = SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored);
+    if let Ok(entries) = fs::read_dir(dirs::app_profiles_dir()?) {
+        for entry in entries {
+            let entry = entry.unwrap();
+            let path = entry.path();
+            if path.is_file() {
+                let backup_path = format!("profiles/{}", entry.file_name().to_str().unwrap());
+                zip.start_file(backup_path, options)?;
+                zip.write_all(fs::read(path).unwrap().as_slice())?;
+            }
+        }
+    }
+    zip.start_file(dirs::CLASH_CONFIG, options)?;
+    zip.write_all(fs::read(dirs::clash_path()?)?.as_slice())?;
+
+    let mut verge_config: serde_json::Value =
+        serde_yaml::from_str(&fs::read_to_string(dirs::verge_path()?)?)?;
+    if let Some(obj) = verge_config.as_object_mut() {
+        obj.remove("webdav_username");
+        obj.remove("webdav_password");
+        obj.remove("webdav_url");
+    }
+    zip.start_file(dirs::VERGE_CONFIG, options)?;
+    zip.write_all(serde_yaml::to_string(&verge_config)?.as_bytes())?;
+
+    zip.start_file(dirs::PROFILE_YAML, options)?;
+    zip.write_all(fs::read(dirs::profiles_path()?)?.as_slice())?;
+    zip.finish()?;
+    Ok((zip_file_name, zip_path))
+}
@@ -5,11 +5,17 @@ use serde::{Deserialize, Serialize};
 use serde_yaml::Mapping;
 use std::collections::HashMap;

+#[derive(Debug, Clone, Default, PartialEq)]
+pub struct Rate {
+    pub up: u64,
+    pub down: u64,
+}
+
 /// PUT /configs
 /// path 是绝对路径
 pub async fn put_configs(path: &str) -> Result<()> {
    let (url, headers) = clash_client_info()?;
-    let url = format!("{url}/configs");
+    let url = format!("{url}/configs?force=true");

    let mut data = HashMap::new();
    data.insert("path", path);
@@ -21,7 +27,9 @@ pub async fn put_configs(path: &str) -> Result<()> {
    match response.status().as_u16() {
        204 => Ok(()),
        status => {
-            bail!("failed to put configs with status \"{status}\"")
+            let body = response.text().await?;
+           // print!("failed to put configs with status \"{}\"\n{}\n{}", status, url, body);
+            bail!("failed to put configs with status \"{status}\"\n{url}\n{body}");
        }
    }
 }
@@ -52,7 +60,7 @@ pub async fn get_proxy_delay(
    let (url, headers) = clash_client_info()?;
    let url = format!("{url}/proxies/{name}/delay");

-    let default_url = "http://1.1.1.1";
+    let default_url = "http://cp.cloudflare.com/generate_204";
    let test_url = test_url
        .map(|s| if s.is_empty() { default_url.into() } else { s })
        .unwrap_or(default_url.into());
@@ -96,8 +104,7 @@ pub fn parse_log(log: String) -> String {
    log
 }

-/// 缩短clash -t的错误输出
-/// 仅适配 clash p核 8-26、clash meta 1.13.1
+#[allow(dead_code)]
 pub fn parse_check_output(log: String) -> String {
    let t = log.find("time=");
    let m = log.find("msg=");
@@ -124,10 +131,17 @@ pub fn parse_check_output(log: String) -> String {
    log
 }

+#[cfg(target_os = "macos")]
+pub fn get_traffic_ws_url() -> Result<String> {
+    let (url, _) = clash_client_info()?;
+    let ws_url = url.replace("http://", "ws://") + "/traffic";
+    Ok(ws_url)
+}
+
 #[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 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 {}'"
@@ -135,12 +149,8 @@ fn test_parse_check_output() {
    "#;

    let res1 = parse_check_output(str1.into());
-    let res2 = parse_check_output(str2.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);
 }
@@ -1,249 +1,110 @@
 use crate::config::*;
-use crate::core::{clash_api, handle, logger::Logger, service};
+use crate::core::{clash_api, handle, service};
+#[cfg(target_os = "macos")]
+use crate::core::tray::Tray;
 use crate::log_err;
-use crate::utils::dirs;
+use crate::utils::{dirs, help};
 use anyhow::{bail, Result};
 use once_cell::sync::OnceCell;
-use parking_lot::Mutex;
 use serde_yaml::Mapping;
 use std::{sync::Arc, time::Duration};
-use sysinfo::System;
-use tauri::api::process::{Command, CommandChild, CommandEvent};
+use tauri_plugin_shell::ShellExt;
+use tokio::sync::Mutex;
 use tokio::time::sleep;

 #[derive(Debug)]
 pub struct CoreManager {
-    sidecar: Arc<Mutex<Option<CommandChild>>>,
-
-    #[allow(unused)]
-    use_service_mode: Arc<Mutex<bool>>,
+    running: 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)),
+            running: Arc::new(Mutex::new(false)),
        })
    }

-    pub fn init(&self) -> Result<()> {
-        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.is_empty() {
-                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(_) => true,
-            None => false,
-        };
-
-        // 关闭tun模式
-        let mut disable = Mapping::new();
-        let mut tun = Mapping::new();
-        tun.insert("enable".into(), false.into());
-        disable.insert("tun".into(), tun.into());
-        log::debug!(target: "app", "disable tun mode");
-        let _ = clash_api::patch_configs(&disable).await;
-
-        let mut system = System::new();
-        system.refresh_all();
-        let procs = system.processes_by_name("verge-mihomo");
-        for proc in procs {
-            log::debug!(target: "app", "kill all clash process");
-            proc.kill();
-        }
-
-        if *self.use_service_mode.lock() {
-            log::debug!(target: "app", "stop the core by service");
-            log_err!(service::stop_core_by_service().await);
-            should_kill = true;
-        }
-
-        // 这里得等一会儿
-        if should_kill {
-            sleep(Duration::from_millis(500)).await;
-        }
-
-        // 服务模式
-        let enable = { Config::verge().latest().enable_service_mode };
-        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");
-
-            let res = async {
-                service::check_service().await?;
-                service::run_core_by_service(&config_path).await
-            }
-            .await;
-            match res {
-                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 mut clash_core = clash_core.unwrap_or("verge-mihomo".into());
-
-        // compatibility
-        if clash_core.contains("clash") {
-            clash_core = "verge-mihomo".to_string();
-            Config::verge().draft().patch_config(IVerge {
-                clash_core: Some("verge-mihomo".to_string()),
-                ..IVerge::default()
-            });
-            Config::verge().apply();
-            match Config::verge().data().save_file() {
-                Ok(_) => handle::Handle::refresh_verge(),
-                Err(err) => log::error!(target: "app", "{err}"),
-            }
-        }
-
-        let config_path = dirs::path_to_str(&config_path)?;
-
-        let args = vec!["-d", app_dir, "-f", config_path];
-
-        let cmd = Command::new_sidecar(clash_core)?;
-        let (mut rx, cmd_child) = cmd.args(args).spawn()?;
-
-        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) => {
-                        log::info!(target: "app", "[mihomo]: {line}");
-                        Logger::global().set_log(line);
-                    }
-                    CommandEvent::Stderr(err) => {
-                        log::error!(target: "app", "[mihomo]: {err}");
-                        Logger::global().set_log(err);
-                    }
-                    CommandEvent::Error(err) => {
-                        log::error!(target: "app", "[mihomo]: {err}");
-                        Logger::global().set_log(err);
-                    }
-                    CommandEvent::Terminated(_) => {
-                        log::info!(target: "app", "mihomo core terminated");
-                        let _ = CoreManager::global().recover_core();
-                        break;
-                    }
-                    _ => {}
-                }
-            }
-        });
-
-        Ok(())
-    }
-
-    /// 重启内核
-    pub fn recover_core(&'static self) -> Result<()> {
-        // 服务模式不管
-        if *self.use_service_mode.lock() {
-            return Ok(());
-        }
-
-        // 清空原来的sidecar值
-        let _ = self.sidecar.lock().take();
-
-        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();
-                }
-            }
-        });
-
+    pub async fn init(&self) -> Result<()> {
+        log::trace!("run core start");
+        // 启动clash
+        log_err!(Self::global().start_core().await);
+        log::trace!("run core end");
        Ok(())
    }

    /// 停止核心运行
    pub async fn stop_core(&self) -> Result<()> {
+        let mut running = self.running.lock().await;
+
+        if !*running {
+            log::debug!("core is not running");
+            return Ok(());
+        }
+
        // 关闭tun模式
        let mut disable = Mapping::new();
        let mut tun = Mapping::new();
        tun.insert("enable".into(), false.into());
        disable.insert("tun".into(), tun.into());
        log::debug!(target: "app", "disable tun mode");
-        let _ = clash_api::patch_configs(&disable).await;
+        log_err!(clash_api::patch_configs(&disable).await);

-        if *self.use_service_mode.lock() {
-            log::debug!(target: "app", "stop the core by service");
-            log_err!(service::stop_core_by_service().await);
+        // 服务模式
+        if service::check_service().await.is_ok() {
+            log::info!(target: "app", "stop the core by service");
+            service::stop_core_by_service().await?;
+        }
+        *running = false;
+        Ok(())
+    }
+
+    /// 启动核心
+    pub async fn start_core(&self) -> Result<()> {
+        let mut running = self.running.lock().await;
+        if *running {
+            log::info!("core is running");
            return Ok(());
        }

-        let mut sidecar = self.sidecar.lock();
-        let _ = sidecar.take();
+        let config_path = Config::generate_file(ConfigType::Run)?;

-        let mut system = System::new();
-        system.refresh_all();
-        let procs = system.processes_by_name("verge-mihomo");
-        for proc in procs {
-            log::debug!(target: "app", "kill all clash process");
-            proc.kill();
+        // 服务模式
+        if service::check_service().await.is_ok() {
+            log::info!(target: "app", "try to run core in service mode");
+            service::run_core_by_service(&config_path).await?;
        }
+        // 流量订阅
+        #[cfg(target_os = "macos")]
+        log_err!(Tray::global().subscribe_traffic().await);
+
+        *running = true;
+
+        Ok(())
+    }
+
+    /// 重启内核
+    pub async fn restart_core(&self) -> Result<()> {
+        // 重新启动app
+        self.stop_core().await?;
+        self.start_core().await?;
+        Ok(())
+    }
+
+    /// 使用默认配置
+    pub async fn use_default_config(&self, msg_type: &str, msg_content: &str) -> Result<()> {
+        let runtime_path = dirs::app_home_dir()?.join(RUNTIME_CONFIG);
+        *Config::runtime().draft() = IRuntime {
+            config: Some(Config::clash().latest().0.clone()),
+            exists_keys: vec![],
+            chain_logs: Default::default(),
+        };
+        help::save_yaml(
+            &runtime_path,
+            &Config::clash().latest().0,
+            Some("# Clash Verge Runtime"),
+        )?;
+        handle::Handle::notice_message(msg_type, msg_content);
        Ok(())
    }

@@ -256,63 +117,364 @@ impl CoreManager {
            bail!("invalid clash core name \"{clash_core}\"");
        }

-        log::debug!(target: "app", "change core to `{clash_core}`");
-
+        log::info!(target: "app", "change core to `{clash_core}`");
+        
+        // 1. 先更新内核配置（但不应用）
        Config::verge().draft().clash_core = Some(clash_core);
-
-        // 更新订阅
-        Config::generate().await?;
-
-        self.check_config()?;
-
-        // 清掉旧日志
-        Logger::global().clear_log();
-
-        match self.run_core().await {
-            Ok(_) => {
+        
+        // 2. 使用新内核验证配置
+        println!("[切换内核] 使用新内核验证配置");
+        match self.validate_config().await {
+            Ok((true, _)) => {
+                println!("[切换内核] 配置验证通过，开始切换内核");
+                // 3. 验证通过后，应用内核配置并重启
                Config::verge().apply();
-                Config::runtime().apply();
                log_err!(Config::verge().latest().save_file());
-                Ok(())
+                
+                match self.restart_core().await {
+                    Ok(_) => {
+                        println!("[切换内核] 内核切换成功");
+                        Config::runtime().apply();
+                        Ok(())
+                    }
+                    Err(err) => {
+                        println!("[切换内核] 内核切换失败: {}", err);
+                        Config::verge().discard();
+                        Config::runtime().discard();
+                        Err(err)
+                    }
+                }
+            }
+            Ok((false, error_msg)) => {
+                println!("[切换内核] 配置验证失败: {}", error_msg);
+                // 使用默认配置并继续切换内核
+                self.use_default_config("config_validate::core_change", &error_msg).await?;
+                Config::verge().apply();
+                log_err!(Config::verge().latest().save_file());
+                
+                match self.restart_core().await {
+                    Ok(_) => {
+                        println!("[切换内核] 内核切换成功（使用默认配置）");
+                        Ok(())
+                    }
+                    Err(err) => {
+                        println!("[切换内核] 内核切换失败: {}", err);
+                        Config::verge().discard();
+                        Err(err)
+                    }
+                }
            }
            Err(err) => {
+                println!("[切换内核] 验证过程发生错误: {}", 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");
+    /// 内部验证配置文件的实现
+    async fn validate_config_internal(&self, config_path: &str) -> Result<(bool, String)> {
+        println!("[core配置验证] 开始验证配置文件: {}", config_path);
+        
+        let clash_core = { Config::verge().latest().clash_core.clone() };
+        let clash_core = clash_core.unwrap_or("verge-mihomo".into());
+        println!("[core配置验证] 使用内核: {}", clash_core);
+        
+        let app_handle = handle::Handle::global().app_handle().unwrap();
+        let test_dir = dirs::app_home_dir()?.join("test");
+        let test_dir = dirs::path_to_str(&test_dir)?;
+        println!("[core配置验证] 测试目录: {}", test_dir);

-        // 更新订阅
-        Config::generate().await?;
+        // 使用子进程运行clash验证配置
+        println!("[core配置验证] 运行子进程验证配置");
+        let output = app_handle
+            .shell()
+            .sidecar(clash_core)?
+            .args(["-t", "-d", test_dir, "-f", config_path])
+            .output()
+            .await?;

-        // 检查订阅是否正常
-        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;
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        
+        // 检查进程退出状态和错误输出
+        let error_keywords = ["FATA", "fatal", "Parse config error", "level=fatal"];
+        let has_error = !output.status.success() || error_keywords.iter().any(|&kw| stderr.contains(kw));
+        
+        println!("\n[core配置验证] -------- 验证结果 --------");
+        println!("[core配置验证] 进程退出状态: {:?}", output.status);
+    
+        if !stderr.is_empty() {
+            println!("[core配置验证] stderr输出:\n{}", stderr);
+        }
+        if !stdout.is_empty() {
+            println!("[core配置验证] stdout输出:\n{}", stdout);
        }

-        Ok(())
+        if has_error {
+            println!("[core配置验证] 发现错误，开始处理错误信息");
+            let error_msg = if !stdout.is_empty() {
+                stdout.to_string()
+            } else if !stderr.is_empty() {
+                stderr.to_string()
+            } else if let Some(code) = output.status.code() {
+                format!("验证进程异常退出，退出码: {}", code)
+            } else {
+                "验证进程被终止".to_string()
+            };
+
+            println!("[core配置验证] -------- 验证结束 --------\n");
+            Ok((false, error_msg))  // 返回错误消息给调用者处理
+        } else {
+            println!("[core配置验证] 验证成功");
+            println!("[core配置验证] -------- 验证结束 --------\n");
+            Ok((true, String::new()))
+        }
    }
-}
+
+    /// 验证运行时配置
+    pub async fn validate_config(&self) -> Result<(bool, String)> {
+        let config_path = Config::generate_file(ConfigType::Check)?;
+        let config_path = dirs::path_to_str(&config_path)?;
+        self.validate_config_internal(config_path).await
+    }
+
+    /// 验证指定的配置文件
+    pub async fn validate_config_file(&self, config_path: &str, is_merge_file: Option<bool>) -> Result<(bool, String)> {
+        // 检查文件是否存在
+        if !std::path::Path::new(config_path).exists() {
+            let error_msg = format!("File not found: {}", config_path);
+            //handle::Handle::notice_message("config_validate::file_not_found", &error_msg);
+            return Ok((false, error_msg));
+        }
+        
+        // 如果是合并文件且不是强制验证，执行语法检查但不进行完整验证
+        if is_merge_file.unwrap_or(false) {
+            println!("[core配置验证] 检测到Merge文件，仅进行语法检查: {}", config_path);
+            return self.validate_file_syntax(config_path).await;
+        }
+        
+        // 检查是否为脚本文件
+        let is_script = if config_path.ends_with(".js") {
+            true
+        } else {
+            match self.is_script_file(config_path) {
+                Ok(result) => result,
+                Err(err) => {
+                    // 如果无法确定文件类型，尝试使用Clash内核验证
+                    log::warn!(target: "app", "无法确定文件类型: {}, 错误: {}", config_path, err);
+                    return self.validate_config_internal(config_path).await;
+                }
+            }
+        };
+        
+        if is_script {
+            log::info!(target: "app", "检测到脚本文件，使用JavaScript验证: {}", config_path);
+            return self.validate_script_file(config_path).await;
+        }
+        
+        // 对YAML配置文件使用Clash内核验证
+        log::info!(target: "app", "使用Clash内核验证配置文件: {}", config_path);
+        self.validate_config_internal(config_path).await
+    }
+
+    /// 检查文件是否为脚本文件
+    fn is_script_file(&self, path: &str) -> Result<bool> {
+        // 1. 先通过扩展名快速判断
+        if path.ends_with(".yaml") || path.ends_with(".yml") {
+            return Ok(false); // YAML文件不是脚本文件
+        } else if path.ends_with(".js") {
+            return Ok(true); // JS文件是脚本文件
+        }
+        
+        // 2. 读取文件内容
+        let content = match std::fs::read_to_string(path) {
+            Ok(content) => content,
+            Err(err) => {
+                log::warn!(target: "app", "无法读取文件以检测类型: {}, 错误: {}", path, err);
+                return Err(anyhow::anyhow!("Failed to read file to detect type: {}", err));
+            }
+        };
+        
+        // 3. 检查是否存在明显的YAML特征
+        let has_yaml_features = content.contains(": ") || 
+                               content.contains("#") || 
+                               content.contains("---") ||
+                               content.lines().any(|line| line.trim().starts_with("- "));
+                               
+        // 4. 检查是否存在明显的JS特征
+        let has_js_features = content.contains("function ") || 
+                             content.contains("const ") || 
+                             content.contains("let ") ||
+                             content.contains("var ") ||
+                             content.contains("//") ||
+                             content.contains("/*") ||
+                             content.contains("*/") ||
+                             content.contains("export ") ||
+                             content.contains("import ");
+        
+        // 5. 决策逻辑
+        if has_yaml_features && !has_js_features {
+            // 只有YAML特征，没有JS特征
+            return Ok(false);
+        } else if has_js_features && !has_yaml_features {
+            // 只有JS特征，没有YAML特征
+            return Ok(true);
+        } else if has_yaml_features && has_js_features {
+            // 两种特征都有，需要更精细判断
+            // 优先检查是否有明确的JS结构特征
+            if content.contains("function main") || 
+               content.contains("module.exports") ||
+               content.contains("export default") {
+                return Ok(true);
+            }
+            
+            // 检查冒号后是否有空格（YAML的典型特征）
+            let yaml_pattern_count = content.lines()
+                .filter(|line| line.contains(": "))
+                .count();
+                
+            if yaml_pattern_count > 2 {
+                return Ok(false); // 多个键值对格式，更可能是YAML
+            }
+        }
+        
+        // 默认情况：无法确定时，假设为非脚本文件（更安全）
+        log::debug!(target: "app", "无法确定文件类型，默认当作YAML处理: {}", path);
+        Ok(false)
+    }
+
+    /// 验证脚本文件语法
+    async fn validate_script_file(&self, path: &str) -> Result<(bool, String)> {
+        // 读取脚本内容
+        let content = match std::fs::read_to_string(path) {
+            Ok(content) => content,
+            Err(err) => {
+                let error_msg = format!("Failed to read script file: {}", err);
+                log::warn!(target: "app", "脚本语法错误: {}", err);
+                //handle::Handle::notice_message("config_validate::script_syntax_error", &error_msg);
+                return Ok((false, error_msg));
+            }
+        };
+        
+        log::debug!(target: "app", "验证脚本文件: {}", path);
+        
+        // 使用boa引擎进行基本语法检查
+        use boa_engine::{Context, Source};
+        
+        let mut context = Context::default();
+        let result = context.eval(Source::from_bytes(&content));
+        
+        match result {
+            Ok(_) => {
+                log::debug!(target: "app", "脚本语法验证通过: {}", path);
+                
+                // 检查脚本是否包含main函数
+                if !content.contains("function main") && !content.contains("const main") && !content.contains("let main") {
+                    let error_msg = "Script must contain a main function";
+                    log::warn!(target: "app", "脚本缺少main函数: {}", path);
+                    //handle::Handle::notice_message("config_validate::script_missing_main", error_msg);
+                    return Ok((false, error_msg.to_string()));
+                }
+                
+                Ok((true, String::new()))
+            },
+            Err(err) => {
+                let error_msg = format!("Script syntax error: {}", err);
+                log::warn!(target: "app", "脚本语法错误: {}", err);
+                //handle::Handle::notice_message("config_validate::script_syntax_error", &error_msg);
+                Ok((false, error_msg))
+            }
+        }
+    }
+
+    /// 更新proxies等配置
+    pub async fn update_config(&self) -> Result<(bool, String)> {
+        println!("[core配置更新] 开始更新配置");
+        
+        // 1. 先生成新的配置内容
+        println!("[core配置更新] 生成新的配置内容");
+        Config::generate().await?;
+        
+        // 2. 生成临时文件并进行验证
+        println!("[core配置更新] 生成临时配置文件用于验证");
+        let temp_config = Config::generate_file(ConfigType::Check)?;
+        let temp_config = dirs::path_to_str(&temp_config)?;
+        println!("[core配置更新] 临时配置文件路径: {}", temp_config);
+
+        // 3. 验证配置
+        match self.validate_config().await {
+            Ok((true, _)) => {
+                println!("[core配置更新] 配置验证通过");
+                // 4. 验证通过后，生成正式的运行时配置
+                println!("[core配置更新] 生成运行时配置");
+                let run_path = Config::generate_file(ConfigType::Run)?;
+                let run_path = dirs::path_to_str(&run_path)?;
+
+                // 5. 应用新配置
+                println!("[core配置更新] 应用新配置");
+                for i in 0..3 {
+                    match clash_api::put_configs(run_path).await {
+                        Ok(_) => {
+                            println!("[core配置更新] 配置应用成功");
+                            Config::runtime().apply();
+                            return Ok((true, String::new()));
+                        }
+                        Err(err) => {
+                            if i < 2 {
+                                println!("[core配置更新] 第{}次重试应用配置", i + 1);
+                                log::info!(target: "app", "{err}");
+                                sleep(Duration::from_millis(100)).await;
+                            } else {
+                                println!("[core配置更新] 配置应用失败: {}", err);
+                                Config::runtime().discard();
+                                return Ok((false, err.to_string()));
+                            }
+                        }
+                    }
+                }
+                Ok((true, String::new()))
+            }
+            Ok((false, error_msg)) => {
+                println!("[core配置更新] 配置验证失败: {}", error_msg);
+                Config::runtime().discard();
+                Ok((false, error_msg))
+            }
+            Err(e) => {
+                println!("[core配置更新] 验证过程发生错误: {}", e);
+                Config::runtime().discard();
+                Err(e)
+            }
+        }
+    }
+
+    /// 只进行文件语法检查，不进行完整验证
+    async fn validate_file_syntax(&self, config_path: &str) -> Result<(bool, String)> {
+        println!("[core配置语法检查] 开始检查文件: {}", config_path);
+        
+        // 读取文件内容
+        let content = match std::fs::read_to_string(config_path) {
+            Ok(content) => content,
+            Err(err) => {
+                let error_msg = format!("Failed to read file: {}", err);
+                println!("[core配置语法检查] 无法读取文件: {}", error_msg);
+                return Ok((false, error_msg));
+            }
+        };
+        
+        // 对YAML文件尝试解析，只检查语法正确性
+        println!("[core配置语法检查] 进行YAML语法检查");
+        match serde_yaml::from_str::<serde_yaml::Value>(&content) {
+            Ok(_) => {
+                println!("[core配置语法检查] YAML语法检查通过");
+                Ok((true, String::new()))
+            },
+            Err(err) => {
+                // 使用标准化的前缀，以便错误处理函数能正确识别
+                let error_msg = format!("YAML syntax error: {}", err);
+                println!("[core配置语法检查] YAML语法错误: {}", error_msg);
+                Ok((false, error_msg))
+            }
+        }
+    }
+}
@@ -1,14 +1,13 @@
-use super::tray::Tray;
 use crate::log_err;
-use anyhow::{bail, Result};
 use once_cell::sync::OnceCell;
-use parking_lot::Mutex;
+use parking_lot::RwLock;
 use std::sync::Arc;
-use tauri::{AppHandle, Manager, Window};
+use tauri::{AppHandle, Emitter, Manager, WebviewWindow};

 #[derive(Debug, Default, Clone)]
 pub struct Handle {
-    pub app_handle: Arc<Mutex<Option<AppHandle>>>,
+    pub app_handle: Arc<RwLock<Option<AppHandle>>>,
+    pub is_exiting: Arc<RwLock<bool>>,
 }

 impl Handle {
@@ -16,19 +15,27 @@ impl Handle {
        static HANDLE: OnceCell<Handle> = OnceCell::new();

        HANDLE.get_or_init(|| Handle {
-            app_handle: Arc::new(Mutex::new(None)),
+            app_handle: Arc::new(RwLock::new(None)),
+            is_exiting: Arc::new(RwLock::new(false)),
        })
    }

-    pub fn init(&self, app_handle: AppHandle) {
-        *self.app_handle.lock() = Some(app_handle);
+    pub fn init(&self, app_handle: &AppHandle) {
+        let mut handle = self.app_handle.write();
+        *handle = Some(app_handle.clone());
    }

-    pub fn get_window(&self) -> Option<Window> {
-        self.app_handle
-            .lock()
-            .as_ref()
-            .and_then(|a| a.get_window("main"))
+    pub fn app_handle(&self) -> Option<AppHandle> {
+        self.app_handle.read().clone()
+    }
+
+    pub fn get_window(&self) -> Option<WebviewWindow> {
+        let app_handle = self.app_handle().unwrap();
+        let window: Option<WebviewWindow> = app_handle.get_webview_window("main");
+        if window.is_none() {
+            log::debug!(target:"app", "main window not found");
+        }
+        window
    }

    pub fn refresh_clash() {
@@ -56,22 +63,12 @@ impl Handle {
        }
    }

-    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(())
+    pub fn set_is_exiting(&self) {
+        let mut is_exiting = self.is_exiting.write();
+        *is_exiting = true;
    }

-    /// 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(())
+    pub fn is_exiting(&self) -> bool {
+        *self.is_exiting.read()
    }
 }
@@ -1,14 +1,16 @@
+use crate::core::handle;
 use crate::{config::Config, feat, log_err};
+use crate::utils::resolve;
 use anyhow::{bail, Result};
 use once_cell::sync::OnceCell;
 use parking_lot::Mutex;
 use std::{collections::HashMap, sync::Arc};
-use tauri::{AppHandle, GlobalShortcutManager};
+use tauri::Manager;
+use tauri_plugin_global_shortcut::{Code, GlobalShortcutExt, ShortcutState};
+use tauri::async_runtime;

 pub struct Hotkey {
    current: Arc<Mutex<Vec<String>>>, // 保存当前的热键设置
-
-    app_handle: Arc<Mutex<Option<AppHandle>>>,
 }

 impl Hotkey {
@@ -17,16 +19,27 @@ impl Hotkey {

        HOTKEY.get_or_init(|| Hotkey {
            current: Arc::new(Mutex::new(Vec::new())),
-            app_handle: Arc::new(Mutex::new(None)),
        })
    }

-    pub fn init(&self, app_handle: AppHandle) -> Result<()> {
-        *self.app_handle.lock() = Some(app_handle);
-
+    pub fn init(&self) -> Result<()> {
        let verge = Config::verge();
+        let enable_global_hotkey = verge.latest().enable_global_hotkey.unwrap_or(true);
+
+        println!("Initializing hotkeys, global hotkey enabled: {}", enable_global_hotkey);
+        log::info!(target: "app", "Initializing hotkeys, global hotkey enabled: {}", enable_global_hotkey);
+
+        // 如果全局热键被禁用，则不注册热键
+        if !enable_global_hotkey {
+            println!("Global hotkey is disabled, skipping registration");
+            log::info!(target: "app", "Global hotkey is disabled, skipping registration");
+            return Ok(());
+        }

        if let Some(hotkeys) = verge.latest().hotkeys.as_ref() {
+            println!("Found {} hotkeys to register", hotkeys.len());
+            log::info!(target: "app", "Found {} hotkeys to register", hotkeys.len());
+
            for hotkey in hotkeys.iter() {
                let mut iter = hotkey.split(',');
                let func = iter.next();
@@ -34,55 +47,159 @@ impl Hotkey {

                match (key, func) {
                    (Some(key), Some(func)) => {
-                        log_err!(self.register(key, func));
+                        println!("Registering hotkey: {} -> {}", key, func);
+                        log::info!(target: "app", "Registering hotkey: {} -> {}", key, func);
+                        if let Err(e) = self.register(key, func) {
+                            println!("Failed to register hotkey {} -> {}: {:?}", key, func, e);
+                            log::error!(target: "app", "Failed to register hotkey {} -> {}: {:?}", key, func, e);
+                        } else {
+                            println!("Successfully registered hotkey {} -> {}", key, func);
+                            log::info!(target: "app", "Successfully registered hotkey {} -> {}", key, func);
+                        }
                    }
                    _ => {
                        let key = key.unwrap_or("None");
                        let func = func.unwrap_or("None");
-                        log::error!(target: "app", "invalid hotkey `{key}`:`{func}`");
+                        println!("Invalid hotkey configuration: `{key}`:`{func}`");
+                        log::error!(target: "app", "Invalid hotkey configuration: `{key}`:`{func}`");
                    }
                }
            }
            self.current.lock().clone_from(hotkeys);
+        } else {
+            println!("No hotkeys configured");
+            log::info!(target: "app", "No hotkeys configured");
        }

        Ok(())
    }

-    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())
+    pub fn reset(&self) -> Result<()> {
+        let app_handle = handle::Handle::global().app_handle().unwrap();
+        let manager = app_handle.global_shortcut();
+        manager.unregister_all()?;
+        Ok(())
    }

-    fn register(&self, hotkey: &str, func: &str) -> Result<()> {
-        let mut manager = self.get_manager()?;
+    pub fn register(&self, hotkey: &str, func: &str) -> Result<()> {
+        let app_handle = handle::Handle::global().app_handle().unwrap();
+        let manager = app_handle.global_shortcut();

-        if manager.is_registered(hotkey)? {
+        println!("Attempting to register hotkey: {} for function: {}", hotkey, func);
+        log::info!(target: "app", "Attempting to register hotkey: {} for function: {}", hotkey, func);
+
+        if manager.is_registered(hotkey) {
+            println!("Hotkey {} was already registered, unregistering first", hotkey);
+            log::info!(target: "app", "Hotkey {} was already registered, unregistering first", hotkey);
            manager.unregister(hotkey)?;
        }

        let f = match func.trim() {
-            "open_or_close_dashboard" => feat::open_or_close_dashboard,
+            "open_or_close_dashboard" => {
+                println!("Registering open_or_close_dashboard function");
+                log::info!(target: "app", "Registering open_or_close_dashboard function");
+                || {
+                    println!("=== Hotkey Dashboard Window Operation Start ===");
+                    log::info!(target: "app", "=== Hotkey Dashboard Window Operation Start ===");
+                    
+                    // 使用 spawn_blocking 来确保在正确的线程上执行
+                    async_runtime::spawn_blocking(|| {
+                        println!("Toggle dashboard window visibility");
+                        log::info!(target: "app", "Toggle dashboard window visibility");
+                        
+                        // 检查窗口是否存在
+                        if let Some(window) = handle::Handle::global().get_window() {
+                            // 如果窗口可见，则隐藏它
+                            if window.is_visible().unwrap_or(false) {
+                                println!("Window is visible, hiding it");
+                                log::info!(target: "app", "Window is visible, hiding it");
+                                let _ = window.hide();
+                            } else {
+                                // 如果窗口不可见，则显示它
+                                println!("Window is hidden, showing it");
+                                log::info!(target: "app", "Window is hidden, showing it");
+                                if window.is_minimized().unwrap_or(false) {
+                                    let _ = window.unminimize();
+                                }
+                                let _ = window.show();
+                                let _ = window.set_focus();
+                            }
+                        } else {
+                            // 如果窗口不存在，创建一个新窗口
+                            println!("Window does not exist, creating a new one");
+                            log::info!(target: "app", "Window does not exist, creating a new one");
+                            resolve::create_window();
+                        }
+                    });
+                    
+                    println!("=== Hotkey Dashboard Window Operation End ===");
+                    log::info!(target: "app", "=== Hotkey Dashboard Window Operation End ===");
+                }
+            },
            "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()),
-            "toggle_system_proxy" => feat::toggle_system_proxy,
-            "toggle_tun_mode" => feat::toggle_tun_mode,
+            "toggle_system_proxy" => || feat::toggle_system_proxy(),
+            "toggle_tun_mode" => || feat::toggle_tun_mode(None),
+            "quit" => || feat::quit(Some(0)),

-            _ => bail!("invalid function \"{func}\""),
+            _ => {
+                println!("Invalid function: {}", func);
+                log::error!(target: "app", "Invalid function: {}", func);
+                bail!("invalid function \"{func}\"");
+            }
        };

-        manager.register(hotkey, f)?;
-        log::info!(target: "app", "register hotkey {hotkey} {func}");
+        let is_quit = func.trim() == "quit";
+
+        let _ = manager.on_shortcut(hotkey, move |app_handle, hotkey, event| {
+            if event.state == ShortcutState::Pressed {
+                println!("Hotkey pressed: {:?}", hotkey);
+                log::info!(target: "app", "Hotkey pressed: {:?}", hotkey);
+
+                if hotkey.key == Code::KeyQ && is_quit {
+                    if let Some(window) = app_handle.get_webview_window("main") {
+                        if window.is_focused().unwrap_or(false) {
+                            println!("Executing quit function");
+                            log::info!(target: "app", "Executing quit function");
+                            f();
+                        }
+                    }
+                } else {
+                    // 直接执行函数，不做任何状态检查
+                    println!("Executing function directly");
+                    log::info!(target: "app", "Executing function directly");
+                    
+                    // 获取轻量模式状态和全局热键状态
+                    let is_lite_mode = Config::verge().latest().enable_lite_mode.unwrap_or(false);
+                    let is_enable_global_hotkey = Config::verge().latest().enable_global_hotkey.unwrap_or(true);
+                    
+                    // 在轻量模式下或配置了全局热键时，始终执行热键功能
+                    if is_lite_mode || is_enable_global_hotkey {
+                        f();
+                    } else if let Some(window) = app_handle.get_webview_window("main") {
+                        // 非轻量模式且未启用全局热键时，只在窗口可见且有焦点的情况下响应热键
+                        let is_visible = window.is_visible().unwrap_or(false);
+                        let is_focused = window.is_focused().unwrap_or(false);
+                        
+                        if is_focused && is_visible {
+                            f();
+                        }
+                    }
+                }
+            }
+        });
+
+        println!("Successfully registered hotkey {} for {}", hotkey, func);
+        log::info!(target: "app", "Successfully registered hotkey {} for {}", hotkey, func);
        Ok(())
    }

-    fn unregister(&self, hotkey: &str) -> Result<()> {
-        self.get_manager()?.unregister(hotkey)?;
-        log::info!(target: "app", "unregister hotkey {hotkey}");
+    pub fn unregister(&self, hotkey: &str) -> Result<()> {
+        let app_handle = handle::Handle::global().app_handle().unwrap();
+        let manager = app_handle.global_shortcut();
+        manager.unregister(hotkey)?;
+        log::debug!(target: "app", "unregister hotkey {hotkey}");
        Ok(())
    }

@@ -105,7 +222,7 @@ impl Hotkey {
        Ok(())
    }

-    fn get_map_from_vec(hotkeys: &Vec<String>) -> HashMap<&str, &str> {
+    fn get_map_from_vec(hotkeys: &[String]) -> HashMap<&str, &str> {
        let mut map = HashMap::new();

        hotkeys.iter().for_each(|hotkey| {
@@ -153,8 +270,9 @@ impl Hotkey {

 impl Drop for Hotkey {
    fn drop(&mut self) {
-        if let Ok(mut manager) = self.get_manager() {
-            let _ = manager.unregister_all();
+        let app_handle = handle::Handle::global().app_handle().unwrap();
+        if let Err(e) = app_handle.global_shortcut().unregister_all() {
+            log::error!(target:"app", "Error unregistering all hotkeys: {:?}", e);
        }
    }
 }
@@ -1,36 +0,0 @@
-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();
-    }
-}
@@ -1,9 +1,9 @@
+pub mod backup;
 pub mod clash_api;
 #[allow(clippy::module_inception)]
 mod core;
 pub mod handle;
 pub mod hotkey;
-pub mod logger;
 pub mod service;
 pub mod sysopt;
 pub mod timer;
@@ -1,17 +1,16 @@
-use crate::config::{Config, IVerge};
-use crate::core::handle;
+use crate::config::Config;
 use crate::utils::dirs;
 use anyhow::{bail, Context, Result};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::path::PathBuf;
-use std::time::Duration;
 use std::{env::current_exe, process::Command as StdCommand};
-use tokio::time::sleep;
+use tokio::time::Duration;

 // Windows only

 const SERVICE_URL: &str = "http://127.0.0.1:33211";
+const REQUIRED_SERVICE_VERSION: &str = "1.0.1"; // 定义所需的服务版本号

 #[derive(Debug, Deserialize, Serialize, Clone)]
 pub struct ResponseBody {
@@ -21,6 +20,12 @@ pub struct ResponseBody {
    pub log_file: String,
 }

+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct VersionResponse {
+    pub service: String,
+    pub version: String,
+}
+
 #[derive(Debug, Deserialize, Serialize, Clone)]
 pub struct JsonResponse {
    pub code: u64,
@@ -28,24 +33,41 @@ pub struct JsonResponse {
    pub data: Option<ResponseBody>,
 }

-/// Install the Clash Verge Service
-/// 该函数应该在协程或者线程中执行，避免UAC弹窗阻塞主线程
-///
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct VersionJsonResponse {
+    pub code: u64,
+    pub msg: String,
+    pub data: Option<VersionResponse>,
+}
+
 #[cfg(target_os = "windows")]
-pub async fn install_service() -> Result<()> {
+pub async fn reinstall_service() -> Result<()> {
+    log::info!(target:"app", "reinstall service");
+
    use deelevate::{PrivilegeLevel, Token};
    use runas::Command as RunasCommand;
    use std::os::windows::process::CommandExt;

    let binary_path = dirs::service_path()?;
    let install_path = binary_path.with_file_name("install-service.exe");
+    let uninstall_path = binary_path.with_file_name("uninstall-service.exe");

    if !install_path.exists() {
-        bail!("installer exe not found");
+        bail!(format!("installer not found: {install_path:?}"));
+    }
+
+    if !uninstall_path.exists() {
+        bail!(format!("uninstaller not found: {uninstall_path:?}"));
    }

    let token = Token::with_current_process()?;
    let level = token.privilege_level()?;
+    let _ = match level {
+        PrivilegeLevel::NotPrivileged => RunasCommand::new(uninstall_path).show(false).status()?,
+        _ => StdCommand::new(uninstall_path)
+            .creation_flags(0x08000000)
+            .status()?,
+    };

    let status = match level {
        PrivilegeLevel::NotPrivileged => RunasCommand::new(install_path).show(false).status()?,
@@ -65,113 +87,42 @@ pub async fn install_service() -> Result<()> {
 }

 #[cfg(target_os = "linux")]
-pub async fn install_service() -> Result<()> {
+pub async fn reinstall_service() -> Result<()> {
+    log::info!(target:"app", "reinstall service");
    use users::get_effective_uid;

-    let binary_path = dirs::service_path()?;
-    let installer_path = binary_path.with_file_name("install-service");
+    let install_path = tauri::utils::platform::current_exe()?.with_file_name("install-service");

-    if !installer_path.exists() {
-        bail!("installer not found");
+    let uninstall_path = tauri::utils::platform::current_exe()?.with_file_name("uninstall-service");
+
+    if !install_path.exists() {
+        bail!(format!("installer not found: {install_path:?}"));
    }

-    let elevator = crate::utils::unix_helper::linux_elevator();
-    let status = match get_effective_uid() {
-        0 => StdCommand::new(installer_path).status()?,
-        _ => StdCommand::new(elevator)
-            .arg("sh")
-            .arg("-c")
-            .arg(installer_path)
-            .status()?,
-    };
-
-    if !status.success() {
-        bail!(
-            "failed to install service with status {}",
-            status.code().unwrap()
-        );
-    }
-
-    Ok(())
-}
-
-#[cfg(target_os = "macos")]
-pub async fn install_service() -> Result<()> {
-    let binary_path = dirs::service_path()?;
-    let installer_path = binary_path.with_file_name("install-service");
-
-    if !installer_path.exists() {
-        bail!("installer not found");
-    }
-    let shell = installer_path.to_string_lossy().replace(" ", "\\\\ ");
-    let command = format!(r#"do shell script "{shell}" with administrator privileges"#);
-
-    let status = StdCommand::new("osascript")
-        .args(vec!["-e", &command])
-        .status()?;
-
-    if !status.success() {
-        bail!(
-            "failed to install service with status {}",
-            status.code().unwrap()
-        );
-    }
-
-    Ok(())
-}
-/// Uninstall the Clash Verge Service
-/// 该函数应该在协程或者线程中执行，避免UAC弹窗阻塞主线程
-#[cfg(target_os = "windows")]
-pub async fn uninstall_service() -> Result<()> {
-    use deelevate::{PrivilegeLevel, Token};
-    use runas::Command as RunasCommand;
-    use std::os::windows::process::CommandExt;
-
-    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");
+        bail!(format!("uninstaller not found: {uninstall_path:?}"));
    }

-    let token = Token::with_current_process()?;
-    let level = token.privilege_level()?;
+    let install_shell: String = install_path.to_string_lossy().replace(" ", "\\ ");
+    let uninstall_shell: String = uninstall_path.to_string_lossy().replace(" ", "\\ ");

-    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(())
-}
-
-#[cfg(target_os = "linux")]
-pub async fn uninstall_service() -> Result<()> {
-    use users::get_effective_uid;
-
-    let binary_path = dirs::service_path()?;
-    let uninstaller_path = binary_path.with_file_name("uninstall-service");
-
-    if !uninstaller_path.exists() {
-        bail!("uninstaller not found");
-    }
-
-    let elevator = crate::utils::unix_helper::linux_elevator();
+    let elevator = crate::utils::help::linux_elevator();
    let status = match get_effective_uid() {
-        0 => StdCommand::new(uninstaller_path).status()?,
-        _ => StdCommand::new(elevator)
+        0 => StdCommand::new(uninstall_shell).status()?,
+        _ => StdCommand::new(elevator.clone())
            .arg("sh")
            .arg("-c")
-            .arg(uninstaller_path)
+            .arg(uninstall_shell)
+            .status()?,
+    };
+    log::info!(target:"app", "status code:{}", status.code().unwrap());
+
+    let status = match get_effective_uid() {
+        0 => StdCommand::new(install_shell).status()?,
+        _ => StdCommand::new(elevator.clone())
+            .arg("sh")
+            .arg("-c")
+            .arg(install_shell)
            .status()?,
    };

@@ -186,16 +137,28 @@ pub async fn uninstall_service() -> Result<()> {
 }

 #[cfg(target_os = "macos")]
-pub async fn uninstall_service() -> Result<()> {
-    let binary_path = dirs::service_path()?;
-    let uninstaller_path = binary_path.with_file_name("uninstall-service");
+pub async fn reinstall_service() -> Result<()> {
+    log::info!(target:"app", "reinstall service");

-    if !uninstaller_path.exists() {
-        bail!("uninstaller not found");
+    let binary_path = dirs::service_path()?;
+    let install_path = binary_path.with_file_name("install-service");
+    let uninstall_path = binary_path.with_file_name("uninstall-service");
+
+    if !install_path.exists() {
+        bail!(format!("installer not found: {install_path:?}"));
    }

-    let shell = uninstaller_path.to_string_lossy().replace(" ", "\\\\ ");
-    let command = format!(r#"do shell script "{shell}" with administrator privileges"#);
+    if !uninstall_path.exists() {
+        bail!(format!("uninstaller not found: {uninstall_path:?}"));
+    }
+
+    let install_shell: String = install_path.to_string_lossy().into_owned();
+    let uninstall_shell: String = uninstall_path.to_string_lossy().into_owned();
+    let command = format!(
+        r#"do shell script "sudo '{uninstall_shell}' && sudo '{install_shell}'" with administrator privileges"#
+    );
+
+    log::debug!(target: "app", "command: {}", command);

    let status = StdCommand::new("osascript")
        .args(vec!["-e", &command])
@@ -207,7 +170,6 @@ pub async fn uninstall_service() -> Result<()> {
            status.code().unwrap()
        );
    }
-
    Ok(())
 }

@@ -216,6 +178,7 @@ pub async fn check_service() -> Result<JsonResponse> {
    let url = format!("{SERVICE_URL}/get_clash");
    let response = reqwest::ClientBuilder::new()
        .no_proxy()
+        .timeout(Duration::from_secs(3))
        .build()?
        .get(url)
        .send()
@@ -228,31 +191,45 @@ pub async fn check_service() -> Result<JsonResponse> {
    Ok(response)
 }

+/// check the service version
+pub async fn check_service_version() -> Result<String> {
+    let url = format!("{SERVICE_URL}/version");
+    let response = reqwest::ClientBuilder::new()
+        .no_proxy()
+        .timeout(Duration::from_secs(3))
+        .build()?
+        .get(url)
+        .send()
+        .await
+        .context("failed to connect to the Clash Verge Service")?
+        .json::<VersionJsonResponse>()
+        .await
+        .context("failed to parse the Clash Verge Service version response")?;
+
+    match response.data {
+        Some(data) => Ok(data.version),
+        None => bail!("service version not found in response"),
+    }
+}
+
+/// check if service needs to be reinstalled
+pub async fn check_service_needs_reinstall() -> bool {
+    match check_service_version().await {
+        Ok(version) => version != REQUIRED_SERVICE_VERSION,
+        Err(_) => true, // 如果无法获取版本或服务未运行，也需要重新安装
+    }
+}
+
 /// 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;
+    // 检查服务版本，如果不匹配则重新安装
+    if check_service_needs_reinstall().await {
+        log::info!(target: "app", "service version mismatch, reinstalling");
+        reinstall_service().await?;
    }

    let clash_core = { Config::verge().latest().clash_core.clone() };
-    let mut clash_core = clash_core.unwrap_or("verge-mihomo".into());
-
-    // compatibility
-    if clash_core.contains("clash") {
-        clash_core = "verge-mihomo".to_string();
-        Config::verge().draft().patch_config(IVerge {
-            clash_core: Some("verge-mihomo".to_string()),
-            ..IVerge::default()
-        });
-        Config::verge().apply();
-        match Config::verge().data().save_file() {
-            Ok(_) => handle::Handle::refresh_verge(),
-            Err(err) => log::error!(target: "app", "{err}"),
-        }
-    }
+    let clash_core = clash_core.unwrap_or("verge-mihomo".into());

    let bin_ext = if cfg!(windows) { ".exe" } else { "" };
    let clash_bin = format!("{clash_core}{bin_ext}");
@@ -274,81 +251,31 @@ pub(super) async fn run_core_by_service(config_file: &PathBuf) -> Result<()> {
    map.insert("config_file", config_file);
    map.insert("log_file", log_path);

+    log::info!(target:"app", "start service: {:?}", map.clone());
+
    let url = format!("{SERVICE_URL}/start_clash");
-    let res = reqwest::ClientBuilder::new()
+    let _ = 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()
+    let _ = 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(())
-}
-
-/// set dns by service
-pub async fn set_dns_by_service() -> Result<()> {
-    let url = format!("{SERVICE_URL}/set_dns");
-    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(())
-}
-
-/// unset dns by service
-pub async fn unset_dns_by_service() -> Result<()> {
-    let url = format!("{SERVICE_URL}/unset_dns");
-    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(())
 }
@@ -1,48 +1,36 @@
+use crate::core::handle::Handle;
 use crate::{
    config::{Config, IVerge},
    log_err,
 };
-use anyhow::{anyhow, Result};
-use auto_launch::{AutoLaunch, AutoLaunchBuilder};
+use anyhow::Result;
 use once_cell::sync::OnceCell;
 use parking_lot::Mutex;
-use std::env::current_exe;
 use std::sync::Arc;
 use sysproxy::{Autoproxy, Sysproxy};
 use tauri::async_runtime::Mutex as TokioMutex;
+use tauri_plugin_autostart::ManagerExt;
+use tokio::time::{sleep, Duration};

 pub struct Sysopt {
-    /// current system proxy setting
-    cur_sysproxy: Arc<Mutex<Option<Sysproxy>>>,
-
-    /// record the original system proxy
-    /// recover it when exit
-    old_sysproxy: Arc<Mutex<Option<Sysproxy>>>,
-
-    /// current auto proxy setting
-    cur_autoproxy: Arc<Mutex<Option<Autoproxy>>>,
-
-    /// record the original auto proxy
-    /// recover it when exit
-    old_autoproxy: Arc<Mutex<Option<Autoproxy>>>,
-
+    update_sysproxy: Arc<TokioMutex<bool>>,
+    reset_sysproxy: Arc<TokioMutex<bool>>,
    /// helps to auto launch the app
-    auto_launch: Arc<Mutex<Option<AutoLaunch>>>,
-
+    auto_launch: Arc<Mutex<bool>>,
    /// record whether the guard async is running or not
-    guard_state: Arc<TokioMutex<bool>>,
+    guard_state: Arc<Mutex<bool>>,
 }

 #[cfg(target_os = "windows")]
 static DEFAULT_BYPASS: &str = "localhost;127.*;192.168.*;10.*;172.16.*;172.17.*;172.18.*;172.19.*;172.20.*;172.21.*;172.22.*;172.23.*;172.24.*;172.25.*;172.26.*;172.27.*;172.28.*;172.29.*;172.30.*;172.31.*;<local>";
 #[cfg(target_os = "linux")]
-static DEFAULT_BYPASS: &str = "localhost,127.0.0.1,192.168.0.0/16,10.0.0.0/8,172.16.0.0/12,::1";
+static DEFAULT_BYPASS: &str =
+    "localhost,127.0.0.1,192.168.0.0/16,10.0.0.0/8,172.16.0.0/12,172.29.0.0/16,::1";
 #[cfg(target_os = "macos")]
 static DEFAULT_BYPASS: &str =
-    "127.0.0.1,192.168.0.0/16,10.0.0.0/8,172.16.0.0/12,localhost,*.local,*.crashlytics.com,<local>";
+    "127.0.0.1,192.168.0.0/16,10.0.0.0/8,172.16.0.0/12,172.29.0.0/16,localhost,*.local,*.crashlytics.com,<local>";

 fn get_bypass() -> String {
-    // let bypass = DEFAULT_BYPASS.to_string();
    let use_default = Config::verge().latest().use_default_bypass.unwrap_or(true);
    let res = {
        let verge = Config::verge();
@@ -53,125 +41,35 @@ fn get_bypass() -> String {
        Some(bypass) => bypass,
        None => "".to_string(),
    };
-    #[cfg(target_os = "windows")]
-    let bypass = if custom_bypass.is_empty() {
-        DEFAULT_BYPASS.to_string()
-    } else {
-        if use_default {
-            format!("{};{}", DEFAULT_BYPASS, custom_bypass)
-        } else {
-            custom_bypass
-        }
-    };
-    #[cfg(not(target_os = "windows"))]
-    let bypass = if custom_bypass.is_empty() {
-        DEFAULT_BYPASS.to_string()
-    } else {
-        if use_default {
-            format!("{},{}", DEFAULT_BYPASS, custom_bypass)
-        } else {
-            custom_bypass
-        }
-    };

-    bypass
+    if custom_bypass.is_empty() {
+        DEFAULT_BYPASS.to_string()
+    } else if use_default {
+        format!("{},{}", DEFAULT_BYPASS, custom_bypass)
+    } else {
+        custom_bypass
+    }
 }

 impl Sysopt {
    pub fn global() -> &'static Sysopt {
        static SYSOPT: OnceCell<Sysopt> = OnceCell::new();
-
        SYSOPT.get_or_init(|| Sysopt {
-            cur_sysproxy: Arc::new(Mutex::new(None)),
-            old_sysproxy: Arc::new(Mutex::new(None)),
-            cur_autoproxy: Arc::new(Mutex::new(None)),
-            old_autoproxy: Arc::new(Mutex::new(None)),
-            auto_launch: Arc::new(Mutex::new(None)),
-            guard_state: Arc::new(TokioMutex::new(false)),
+            update_sysproxy: Arc::new(TokioMutex::new(false)),
+            reset_sysproxy: Arc::new(TokioMutex::new(false)),
+            auto_launch: Arc::new(Mutex::new(false)),
+            guard_state: Arc::new(false.into()),
        })
    }

-    /// init the sysproxy
-    pub fn init_sysproxy(&self) -> Result<()> {
-        let port = Config::verge()
-            .latest()
-            .verge_mixed_port
-            .unwrap_or(Config::clash().data().get_mixed_port());
-        let pac_port = IVerge::get_singleton_port();
-
-        let (enable, pac) = {
-            let verge = Config::verge();
-            let verge = verge.latest();
-            (
-                verge.enable_system_proxy.unwrap_or(false),
-                verge.proxy_auto_config.unwrap_or(false),
-            )
-        };
-        let mut sys = Sysproxy {
-            enable,
-            host: String::from("127.0.0.1"),
-            port,
-            bypass: get_bypass(),
-        };
-        let mut auto = Autoproxy {
-            enable,
-            url: format!("http://127.0.0.1:{pac_port}/commands/pac"),
-        };
-        if pac {
-            sys.enable = false;
-            let old = Sysproxy::get_system_proxy().ok();
-            sys.set_system_proxy()?;
-            *self.old_sysproxy.lock() = old;
-            *self.cur_sysproxy.lock() = Some(sys);
-
-            let old = Autoproxy::get_auto_proxy().ok();
-            auto.set_auto_proxy()?;
-            *self.old_autoproxy.lock() = old;
-            *self.cur_autoproxy.lock() = Some(auto);
-        } else {
-            auto.enable = false;
-            let old = Autoproxy::get_auto_proxy().ok();
-            auto.set_auto_proxy()?;
-            *self.old_autoproxy.lock() = old;
-            *self.cur_autoproxy.lock() = Some(auto);
-
-            let old = Sysproxy::get_system_proxy().ok();
-            sys.set_system_proxy()?;
-            *self.old_sysproxy.lock() = old;
-            *self.cur_sysproxy.lock() = Some(sys);
-        }
-
-        // run the system proxy guard
+    pub fn init_guard_sysproxy(&self) -> Result<()> {
        self.guard_proxy();
        Ok(())
    }

-    /// 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();
-        let mut cur_autoproxy = self.cur_autoproxy.lock();
-        let old_autoproxy = self.old_autoproxy.lock();
-
-        let (enable, pac) = {
-            let verge = Config::verge();
-            let verge = verge.latest();
-            (
-                verge.enable_system_proxy.unwrap_or(false),
-                verge.proxy_auto_config.unwrap_or(false),
-            )
-        };
-        if pac && (cur_autoproxy.is_none() || old_autoproxy.is_none()) {
-            drop(cur_autoproxy);
-            drop(old_autoproxy);
-            return self.init_sysproxy();
-        }
-
-        if !pac && (cur_sysproxy.is_none() || old_sysproxy.is_none()) {
-            drop(cur_sysproxy);
-            drop(old_sysproxy);
-            return self.init_sysproxy();
-        }
+    /// init the sysproxy
+    pub async fn update_sysproxy(&self) -> Result<()> {
+        let _lock = self.update_sysproxy.lock().await;

        let port = Config::verge()
            .latest()
@@ -179,185 +77,164 @@ impl Sysopt {
            .unwrap_or(Config::clash().data().get_mixed_port());
        let pac_port = IVerge::get_singleton_port();

-        let mut sysproxy = cur_sysproxy.take().unwrap();
-        sysproxy.bypass = get_bypass();
-        sysproxy.port = port;
+        let (sys_enable, pac_enable) = {
+            let verge = Config::verge();
+            let verge = verge.latest();
+            (
+                verge.enable_system_proxy.unwrap_or(false),
+                verge.proxy_auto_config.unwrap_or(false),
+            )
+        };

-        let mut autoproxy = cur_autoproxy.take().unwrap();
-        autoproxy.url = format!("http://127.0.0.1:{pac_port}/commands/pac");
+        #[cfg(not(target_os = "windows"))]
+        {
+            let mut sys = Sysproxy {
+                enable: false,
+                host: String::from("127.0.0.1"),
+                port,
+                bypass: get_bypass(),
+            };
+            let mut auto = Autoproxy {
+                enable: false,
+                url: format!("http://127.0.0.1:{pac_port}/commands/pac"),
+            };

-        if pac {
-            sysproxy.enable = false;
-            sysproxy.set_system_proxy()?;
-            *cur_sysproxy = Some(sysproxy);
-            autoproxy.enable = enable;
-            autoproxy.set_auto_proxy()?;
-            *cur_autoproxy = Some(autoproxy);
-        } else {
-            autoproxy.enable = false;
-            autoproxy.set_auto_proxy()?;
-            *cur_autoproxy = Some(autoproxy);
-            sysproxy.enable = enable;
-            sysproxy.set_system_proxy()?;
-            *cur_sysproxy = Some(sysproxy);
+            if !sys_enable {
+                sys.set_system_proxy()?;
+                auto.set_auto_proxy()?;
+                return Ok(());
+            }
+
+            if pac_enable {
+                sys.enable = false;
+                auto.enable = true;
+                sys.set_system_proxy()?;
+                auto.set_auto_proxy()?;
+                return Ok(());
+            }
+
+            if sys_enable {
+                auto.enable = false;
+                sys.enable = true;
+                auto.set_auto_proxy()?;
+                sys.set_system_proxy()?;
+                return Ok(());
+            }
+        }
+        #[cfg(target_os = "windows")]
+        {
+            if !sys_enable {
+                return self.reset_sysproxy().await;
+            }
+            use crate::core::handle::Handle;
+            use crate::utils::dirs;
+            use anyhow::bail;
+            use tauri_plugin_shell::ShellExt;
+
+            let app_handle = Handle::global().app_handle().unwrap();
+
+            let binary_path = dirs::service_path()?;
+            let sysproxy_exe = binary_path.with_file_name("sysproxy.exe");
+            if !sysproxy_exe.exists() {
+                bail!("sysproxy.exe not found");
+            }
+
+            let shell = app_handle.shell();
+            let output = if pac_enable {
+                let address = format!("http://{}:{}/commands/pac", "127.0.0.1", pac_port);
+                let output = shell
+                    .command(sysproxy_exe.as_path().to_str().unwrap())
+                    .args(["pac", address.as_str()])
+                    .output()
+                    .await
+                    .unwrap();
+                output
+            } else {
+                let address = format!("{}:{}", "127.0.0.1", port);
+                let bypass = get_bypass();
+                let output = shell
+                    .command(sysproxy_exe.as_path().to_str().unwrap())
+                    .args(["global", address.as_str(), bypass.as_ref()])
+                    .output()
+                    .await
+                    .unwrap();
+                output
+            };
+
+            if !output.status.success() {
+                bail!("sysproxy exe run failed");
+            }
        }

        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 mut cur_autoproxy = self.cur_autoproxy.lock();
-        let mut old_autoproxy = self.old_autoproxy.lock();
-
-        let cur_sysproxy = cur_sysproxy.take();
-        let cur_autoproxy = cur_autoproxy.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");
+    pub async fn reset_sysproxy(&self) -> Result<()> {
+        let _lock = self.reset_sysproxy.lock().await;
+        //直接关闭所有代理
+        #[cfg(not(target_os = "windows"))]
+        {
+            let mut sysproxy: Sysproxy = Sysproxy::get_system_proxy()?;
+            let mut autoproxy = Autoproxy::get_auto_proxy()?;
+            sysproxy.enable = false;
+            autoproxy.enable = false;
+            autoproxy.set_auto_proxy()?;
+            sysproxy.set_system_proxy()?;
        }

-        if let Some(mut old) = old_autoproxy.take() {
-            // 如果原代理和当前代理 URL一致，就disable关闭，否则就恢复原代理设置
-            // 当前没有设置代理的时候，不确定旧设置是否和当前一致，全关了
-            let url_same = cur_autoproxy.map_or(true, |cur| old.url == cur.url);
-
-            if old.enable && url_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_auto_proxy()?;
-        } else if let Some(mut cur @ Autoproxy { enable: true, .. }) = cur_autoproxy {
-            // 没有原代理，就按现在的代理设置disable即可
-            log::info!(target: "app", "reset proxy by disabling the current proxy");
-            cur.enable = false;
-            cur.set_auto_proxy()?;
-        } else {
-            log::info!(target: "app", "reset proxy with no action");
-        }
-
-        Ok(())
-    }
-
-    /// init the auto launch
-    pub fn init_launch(&self) -> Result<()> {
-        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;
+            use crate::utils::dirs;
+            use anyhow::bail;
+            use tauri_plugin_shell::ShellExt;

-            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 app_handle = Handle::global().app_handle().unwrap();
+
+            let binary_path = dirs::service_path()?;
+            let sysproxy_exe = binary_path.with_file_name("sysproxy.exe");
+
+            if !sysproxy_exe.exists() {
+                bail!("sysproxy.exe not found");
            }
-        };

-        let auto = AutoLaunchBuilder::new()
-            .set_app_name(app_name)
-            .set_app_path(&app_path)
-            .build()?;
+            let shell = app_handle.shell();
+            let output = shell
+                .command(sysproxy_exe.as_path().to_str().unwrap())
+                .args(["set", "1"])
+                .output()
+                .await
+                .unwrap();

-        *self.auto_launch.lock() = Some(auto);
+            if !output.status.success() {
+                bail!("sysproxy exe run failed");
+            }
+        }

        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 _lock = self.auto_launch.lock();
        let enable = { Config::verge().latest().enable_auto_launch };
        let enable = enable.unwrap_or(false);
-        let auto_launch = auto_launch.as_ref().unwrap();
-
+        let app_handle = Handle::global().app_handle().unwrap();
+        let autostart_manager = app_handle.autolaunch();
+        println!("enable: {}", enable);
        match enable {
-            true => auto_launch.enable()?,
-            false => log_err!(auto_launch.disable()), // 忽略关闭的错误
+            true => log_err!(autostart_manager.enable()),
+            false => log_err!(autostart_manager.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();
+    fn guard_proxy(&self) {
+        let _lock = self.guard_state.lock();

        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;

@@ -377,7 +254,7 @@ impl Sysopt {

                // stop loop
                if !enable || !guard {
-                    break;
+                    continue;
                }

                // update duration
@@ -385,6 +262,20 @@ impl Sysopt {

                log::debug!(target: "app", "try to guard the system proxy");

+                let sysproxy = Sysproxy::get_system_proxy();
+                let autoproxy = Autoproxy::get_auto_proxy();
+                if sysproxy.is_err() || autoproxy.is_err() {
+                    log::error!(target: "app", "failed to get the system proxy");
+                    continue;
+                }
+
+                let sysproxy_enable = sysproxy.ok().map(|s| s.enable).unwrap_or(false);
+                let autoproxy_enable = autoproxy.ok().map(|s| s.enable).unwrap_or(false);
+
+                if sysproxy_enable || autoproxy_enable {
+                    continue;
+                }
+
                let port = {
                    Config::verge()
                        .latest()
@@ -392,27 +283,66 @@ impl Sysopt {
                        .unwrap_or(Config::clash().data().get_mixed_port())
                };
                let pac_port = IVerge::get_singleton_port();
-                if pac {
-                    let autoproxy = Autoproxy {
-                        enable: true,
-                        url: format!("http://127.0.0.1:{pac_port}/commands/pac"),
-                    };
-                    log_err!(autoproxy.set_auto_proxy());
-                } else {
-                    let sysproxy = Sysproxy {
-                        enable: true,
-                        host: "127.0.0.1".into(),
-                        port,
-                        bypass: get_bypass(),
-                    };
+                #[cfg(not(target_os = "windows"))]
+                {
+                    if pac {
+                        let autoproxy = Autoproxy {
+                            enable: true,
+                            url: format!("http://127.0.0.1:{pac_port}/commands/pac"),
+                        };
+                        log_err!(autoproxy.set_auto_proxy());
+                    } else {
+                        let sysproxy = Sysproxy {
+                            enable: true,
+                            host: "127.0.0.1".into(),
+                            port,
+                            bypass: get_bypass(),
+                        };

-                    log_err!(sysproxy.set_system_proxy());
+                        log_err!(sysproxy.set_system_proxy());
+                    }
                }
-            }

-            let mut state = guard_state.lock().await;
-            *state = false;
-            drop(state);
+                #[cfg(target_os = "windows")]
+                {
+                    use crate::core::handle::Handle;
+                    use crate::utils::dirs;
+                    use tauri_plugin_shell::ShellExt;
+
+                    let app_handle = Handle::global().app_handle().unwrap();
+
+                    let binary_path = dirs::service_path().unwrap();
+                    let sysproxy_exe = binary_path.with_file_name("sysproxy.exe");
+                    if !sysproxy_exe.exists() {
+                        break;
+                    }
+
+                    let shell = app_handle.shell();
+                    let output = if pac {
+                        let address = format!("http://{}:{}/commands/pac", "127.0.0.1", pac_port);
+
+                        shell
+                            .command(sysproxy_exe.as_path().to_str().unwrap())
+                            .args(["pac", address.as_str()])
+                            .output()
+                            .await
+                            .unwrap()
+                    } else {
+                        let address = format!("{}:{}", "127.0.0.1", port);
+                        let bypass = get_bypass();
+
+                        shell
+                            .command(sysproxy_exe.as_path().to_str().unwrap())
+                            .args(["global", address.as_str(), bypass.as_ref()])
+                            .output()
+                            .await
+                            .unwrap()
+                    };
+                    if !output.status.success() {
+                        break;
+                    }
+                };
+            }
        });
    }
 }
@@ -1,5 +1,6 @@
 use crate::config::Config;
 use crate::feat;
+use crate::core::CoreManager;
 use anyhow::{Context, Result};
 use delay_timer::prelude::{DelayTimer, DelayTimerBuilder, TaskBuilder};
 use once_cell::sync::OnceCell;
@@ -172,7 +173,17 @@ impl Timer {
    /// 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);
+        
+        // 使用更轻量级的更新方式
+        if let Err(e) = feat::update_profile(uid.clone(), None).await {
+            log::error!(target: "app", "timer task update error: {}", e);
+            return;
+        }
+
+        // 只有更新成功后才刷新配置
+        if let Err(e) = CoreManager::global().update_config().await {
+            log::error!(target: "app", "timer task refresh error: {}", e);
+        }
    }
 }

@@ -1,349 +0,0 @@
-use crate::{
-    cmds,
-    config::Config,
-    feat,
-    utils::{dirs, resolve},
-};
-use anyhow::Result;
-use tauri::{
-    api, AppHandle, CustomMenuItem, Manager, SystemTrayEvent, SystemTrayMenu, SystemTrayMenuItem,
-    SystemTraySubmenu,
-};
-
-pub struct Tray {}
-
-impl Tray {
-    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();
-
-        macro_rules! t {
-            ($en: expr, $zh: expr) => {
-                if zh {
-                    $zh
-                } else {
-                    $en
-                }
-            };
-        }
-
-        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_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", "退出")))
-    }
-
-    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 zh = { Config::verge().latest().language == Some("zh".into()) };
-
-        let version = app_handle.package_info().version.to_string();
-
-        macro_rules! t {
-            ($en: expr, $zh: expr) => {
-                if zh {
-                    $zh
-                } else {
-                    $en
-                }
-            };
-        }
-
-        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");
-
-        #[cfg(target_os = "linux")]
-        match mode.as_str() {
-            "rule" => {
-                let _ = tray
-                    .get_item("rule_mode")
-                    .set_title(t!("Rule Mode  ✔", "规则模式  ✔"));
-                let _ = tray
-                    .get_item("global_mode")
-                    .set_title(t!("Global Mode", "全局模式"));
-                let _ = tray
-                    .get_item("direct_mode")
-                    .set_title(t!("Direct Mode", "直连模式"));
-            }
-            "global" => {
-                let _ = tray
-                    .get_item("rule_mode")
-                    .set_title(t!("Rule Mode", "规则模式"));
-                let _ = tray
-                    .get_item("global_mode")
-                    .set_title(t!("Global Mode  ✔", "全局模式  ✔"));
-                let _ = tray
-                    .get_item("direct_mode")
-                    .set_title(t!("Direct Mode", "直连模式"));
-            }
-            "direct" => {
-                let _ = tray
-                    .get_item("rule_mode")
-                    .set_title(t!("Rule Mode", "规则模式"));
-                let _ = tray
-                    .get_item("global_mode")
-                    .set_title(t!("Global Mode", "全局模式"));
-                let _ = tray
-                    .get_item("direct_mode")
-                    .set_title(t!("Direct Mode  ✔", "直连模式  ✔"));
-            }
-            _ => {}
-        }
-
-        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 = "macos")]
-        let tray_icon = verge.tray_icon.clone().unwrap_or("monochrome".to_string());
-        let common_tray_icon = verge.common_tray_icon.as_ref().unwrap_or(&false);
-        let sysproxy_tray_icon = verge.sysproxy_tray_icon.as_ref().unwrap_or(&false);
-        let tun_tray_icon = verge.tun_tray_icon.as_ref().unwrap_or(&false);
-        #[cfg(target_os = "macos")]
-        match tray_icon.as_str() {
-            "monochrome" => {
-                let _ = tray.set_icon_as_template(true);
-            }
-            "colorful" => {
-                let _ = tray.set_icon_as_template(false);
-            }
-            _ => {}
-        }
-        let mut indication_icon = if *system_proxy {
-            #[cfg(target_os = "macos")]
-            let mut icon = match tray_icon.as_str() {
-                "monochrome" => include_bytes!("../../icons/tray-icon-sys-mono.ico").to_vec(),
-                "colorful" => include_bytes!("../../icons/tray-icon-sys.ico").to_vec(),
-                _ => include_bytes!("../../icons/tray-icon-sys-mono.ico").to_vec(),
-            };
-            #[cfg(not(target_os = "macos"))]
-            let mut icon = include_bytes!("../../icons/tray-icon-sys.ico").to_vec();
-
-            if *sysproxy_tray_icon {
-                let icon_dir_path = dirs::app_home_dir()?.join("icons");
-                let png_path = icon_dir_path.join("sysproxy.png");
-                let ico_path = icon_dir_path.join("sysproxy.ico");
-                if ico_path.exists() {
-                    icon = std::fs::read(ico_path).unwrap();
-                } else if png_path.exists() {
-                    icon = std::fs::read(png_path).unwrap();
-                }
-            }
-            icon
-        } else {
-            #[cfg(target_os = "macos")]
-            let mut icon = match tray_icon.as_str() {
-                "monochrome" => include_bytes!("../../icons/tray-icon-mono.ico").to_vec(),
-                "colorful" => include_bytes!("../../icons/tray-icon.ico").to_vec(),
-                _ => include_bytes!("../../icons/tray-icon-mono.ico").to_vec(),
-            };
-            #[cfg(not(target_os = "macos"))]
-            let mut icon = include_bytes!("../../icons/tray-icon.ico").to_vec();
-            if *common_tray_icon {
-                let icon_dir_path = dirs::app_home_dir()?.join("icons");
-                let png_path = icon_dir_path.join("common.png");
-                let ico_path = icon_dir_path.join("common.ico");
-                if ico_path.exists() {
-                    icon = std::fs::read(ico_path).unwrap();
-                } else if png_path.exists() {
-                    icon = std::fs::read(png_path).unwrap();
-                }
-            }
-            icon
-        };
-
-        if *tun_mode {
-            #[cfg(target_os = "macos")]
-            let mut icon = match tray_icon.as_str() {
-                "monochrome" => include_bytes!("../../icons/tray-icon-tun-mono.ico").to_vec(),
-                "colorful" => include_bytes!("../../icons/tray-icon-tun.ico").to_vec(),
-                _ => include_bytes!("../../icons/tray-icon-tun-mono.ico").to_vec(),
-            };
-            #[cfg(not(target_os = "macos"))]
-            let mut icon = include_bytes!("../../icons/tray-icon-tun.ico").to_vec();
-            if *tun_tray_icon {
-                let icon_dir_path = dirs::app_home_dir()?.join("icons");
-                let png_path = icon_dir_path.join("tun.png");
-                let ico_path = icon_dir_path.join("tun.ico");
-                if ico_path.exists() {
-                    icon = std::fs::read(ico_path).unwrap();
-                } else if png_path.exists() {
-                    icon = std::fs::read(png_path).unwrap();
-                }
-            }
-            indication_icon = icon
-        }
-
-        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);
-        #[cfg(target_os = "linux")]
-        {
-            if *system_proxy {
-                let _ = tray
-                    .get_item("system_proxy")
-                    .set_title(t!("System Proxy  ✔", "系统代理  ✔"));
-            } else {
-                let _ = tray
-                    .get_item("system_proxy")
-                    .set_title(t!("System Proxy", "系统代理"));
-            }
-            if *tun_mode {
-                let _ = tray
-                    .get_item("tun_mode")
-                    .set_title(t!("TUN Mode  ✔", "Tun 模式  ✔"));
-            } else {
-                let _ = tray
-                    .get_item("tun_mode")
-                    .set_title(t!("TUN Mode", "Tun 模式"));
-            }
-        }
-
-        let switch_map = {
-            let mut map = std::collections::HashMap::new();
-            map.insert(true, "on");
-            map.insert(false, "off");
-            map
-        };
-
-        let mut current_profile_name = "None".to_string();
-        let profiles = Config::profiles();
-        let profiles = profiles.latest();
-        if let Some(current_profile_uid) = profiles.get_current() {
-            let current_profile = profiles.get_item(&current_profile_uid);
-            current_profile_name = match &current_profile.unwrap().name {
-                Some(profile_name) => profile_name.to_string(),
-                None => current_profile_name,
-            };
-        };
-        let _ = tray.set_tooltip(&format!(
-            "Clash Verge {version}\n{}: {}\n{}: {}\n{}: {}",
-            t!("System Proxy", "系统代理"),
-            switch_map[system_proxy],
-            t!("TUN Mode", "Tun 模式"),
-            switch_map[tun_mode],
-            t!("Curent Profile", "当前订阅"),
-            current_profile_name
-        ));
-
-        Ok(())
-    }
-
-    pub fn on_click(app_handle: &AppHandle) {
-        let tray_event = { Config::verge().latest().tray_event.clone() };
-        let tray_event = tray_event.unwrap_or("main_window".into());
-        match tray_event.as_str() {
-            "system_proxy" => feat::toggle_system_proxy(),
-            "tun_mode" => feat::toggle_tun_mode(),
-            "main_window" => resolve::create_window(app_handle),
-            _ => {}
-        }
-    }
-
-    pub fn on_system_tray_event(app_handle: &AppHandle, event: SystemTrayEvent) {
-        match event {
-            #[cfg(not(target_os = "macos"))]
-            SystemTrayEvent::LeftClick { .. } => Tray::on_click(app_handle),
-            #[cfg(target_os = "macos")]
-            SystemTrayEvent::RightClick { .. } => Tray::on_click(app_handle),
-            SystemTrayEvent::MenuItemClick { id, .. } => match id.as_str() {
-                mode @ ("rule_mode" | "global_mode" | "direct_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(app_handle),
-                "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" => cmds::exit_app(app_handle.clone()),
-
-                _ => {}
-            },
-            _ => {}
-        }
-    }
-}
@@ -0,0 +1,614 @@
+use once_cell::sync::OnceCell;
+#[cfg(target_os = "macos")]
+pub mod speed_rate;
+use crate::core::clash_api::Rate;
+use crate::{
+    cmds,
+    config::Config,
+    feat, resolve,
+    utils::resolve::VERSION,
+    utils::{dirs, i18n::t},
+};
+
+use anyhow::Result;
+#[cfg(target_os = "macos")]
+use futures::StreamExt;
+#[cfg(target_os = "macos")]
+use parking_lot::Mutex;
+#[cfg(target_os = "macos")]
+use parking_lot::RwLock;
+#[cfg(target_os = "macos")]
+pub use speed_rate::{SpeedRate, Traffic};
+#[cfg(target_os = "macos")]
+use std::sync::Arc;
+use tauri::menu::{CheckMenuItem, IsMenuItem};
+use tauri::AppHandle;
+use tauri::{
+    menu::{MenuEvent, MenuItem, PredefinedMenuItem, Submenu},
+    tray::{MouseButton, MouseButtonState, TrayIconEvent, TrayIconId},
+    Wry,
+};
+#[cfg(target_os = "macos")]
+use tokio::sync::broadcast;
+
+use super::handle;
+#[cfg(target_os = "macos")]
+pub struct Tray {
+    pub speed_rate: Arc<Mutex<Option<SpeedRate>>>,
+    shutdown_tx: Arc<RwLock<Option<broadcast::Sender<()>>>>,
+    is_subscribed: Arc<RwLock<bool>>,
+}
+
+#[cfg(not(target_os = "macos"))]
+pub struct Tray {}
+
+impl Tray {
+    pub fn global() -> &'static Tray {
+        static TRAY: OnceCell<Tray> = OnceCell::new();
+
+        #[cfg(target_os = "macos")]
+        return TRAY.get_or_init(|| Tray {
+            speed_rate: Arc::new(Mutex::new(None)),
+            shutdown_tx: Arc::new(RwLock::new(None)),
+            is_subscribed: Arc::new(RwLock::new(false)),
+        });
+
+        #[cfg(not(target_os = "macos"))]
+        return TRAY.get_or_init(|| Tray {});
+    }
+
+    pub fn init(&self) -> Result<()> {
+        #[cfg(target_os = "macos")]
+        {
+            let mut speed_rate = self.speed_rate.lock();
+            *speed_rate = Some(SpeedRate::new());
+        }
+        Ok(())
+    }
+
+    pub fn create_systray(&self) -> Result<()> {
+        let app_handle = handle::Handle::global().app_handle().unwrap();
+        let tray_incon_id = TrayIconId::new("main");
+        let tray = app_handle.tray_by_id(&tray_incon_id).unwrap();
+
+        #[cfg(target_os = "macos")]
+        tray.set_show_menu_on_left_click(false)?;
+
+        tray.on_tray_icon_event(|_, event| {
+            let tray_event = { Config::verge().latest().tray_event.clone() };
+            let tray_event: String = tray_event.unwrap_or("main_window".into());
+
+            #[cfg(target_os = "macos")]
+            if let TrayIconEvent::Click {
+                button: MouseButton::Left,
+                button_state: MouseButtonState::Down,
+                ..
+            } = event
+            {
+                match tray_event.as_str() {
+                    "system_proxy" => feat::toggle_system_proxy(),
+                    "tun_mode" => feat::toggle_tun_mode(None),
+                    "main_window" => resolve::create_window(),
+                    _ => {}
+                }
+            }
+
+            #[cfg(not(target_os = "macos"))]
+            if let TrayIconEvent::Click {
+                button: MouseButton::Left,
+                button_state: MouseButtonState::Down,
+                ..
+            } = event
+            {
+                match tray_event.as_str() {
+                    "system_proxy" => feat::toggle_system_proxy(),
+                    "tun_mode" => feat::toggle_tun_mode(None),
+                    "main_window" => resolve::create_window(),
+                    _ => {}
+                }
+            }
+        });
+        tray.on_menu_event(on_menu_event);
+        Ok(())
+    }
+
+    /// 更新托盘菜单
+    pub fn update_menu(&self) -> Result<()> {
+        let app_handle = handle::Handle::global().app_handle().unwrap();
+        let verge = Config::verge().latest().clone();
+        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 mode = {
+            Config::clash()
+                .latest()
+                .0
+                .get("mode")
+                .map(|val| val.as_str().unwrap_or("rule"))
+                .unwrap_or("rule")
+                .to_owned()
+        };
+        let profile_uid_and_name = Config::profiles()
+            .data()
+            .all_profile_uid_and_name()
+            .unwrap_or(Vec::new());
+
+        let tray = app_handle.tray_by_id("main").unwrap();
+        let _ = tray.set_menu(Some(create_tray_menu(
+            &app_handle,
+            Some(mode.as_str()),
+            *system_proxy,
+            *tun_mode,
+            profile_uid_and_name,
+        )?));
+        Ok(())
+    }
+
+    /// 更新托盘图标
+    #[allow(unused_variables)]
+    pub fn update_icon(&self, rate: Option<Rate>) -> Result<()> {
+        let app_handle = handle::Handle::global().app_handle().unwrap();
+        let verge = Config::verge().latest().clone();
+        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 common_tray_icon = verge.common_tray_icon.as_ref().unwrap_or(&false);
+        let sysproxy_tray_icon = verge.sysproxy_tray_icon.as_ref().unwrap_or(&false);
+        let tun_tray_icon = verge.tun_tray_icon.as_ref().unwrap_or(&false);
+
+        let tray = app_handle.tray_by_id("main").unwrap();
+
+        #[cfg(target_os = "macos")]
+        let tray_icon = verge.tray_icon.clone().unwrap_or("monochrome".to_string());
+
+        let icon_bytes = if *system_proxy && !*tun_mode {
+            #[cfg(target_os = "macos")]
+            let mut icon = match tray_icon.as_str() {
+                "colorful" => include_bytes!("../../../icons/tray-icon-sys.ico").to_vec(),
+                _ => include_bytes!("../../../icons/tray-icon-sys-mono.ico").to_vec(),
+            };
+
+            #[cfg(not(target_os = "macos"))]
+            let mut icon = include_bytes!("../../../icons/tray-icon-sys.ico").to_vec();
+            if *sysproxy_tray_icon {
+                let icon_dir_path = dirs::app_home_dir()?.join("icons");
+                let png_path = icon_dir_path.join("sysproxy.png");
+                let ico_path = icon_dir_path.join("sysproxy.ico");
+                if ico_path.exists() {
+                    icon = std::fs::read(ico_path).unwrap();
+                } else if png_path.exists() {
+                    icon = std::fs::read(png_path).unwrap();
+                }
+            }
+            icon
+        } else if *tun_mode {
+            #[cfg(target_os = "macos")]
+            let mut icon = match tray_icon.as_str() {
+                "colorful" => include_bytes!("../../../icons/tray-icon-tun.ico").to_vec(),
+                _ => include_bytes!("../../../icons/tray-icon-tun-mono.ico").to_vec(),
+            };
+
+            #[cfg(not(target_os = "macos"))]
+            let mut icon = include_bytes!("../../../icons/tray-icon-tun.ico").to_vec();
+            if *tun_tray_icon {
+                let icon_dir_path = dirs::app_home_dir()?.join("icons");
+                let png_path = icon_dir_path.join("tun.png");
+                let ico_path = icon_dir_path.join("tun.ico");
+                if ico_path.exists() {
+                    icon = std::fs::read(ico_path).unwrap();
+                } else if png_path.exists() {
+                    icon = std::fs::read(png_path).unwrap();
+                }
+            }
+            icon
+        } else {
+            #[cfg(target_os = "macos")]
+            let mut icon = match tray_icon.as_str() {
+                "colorful" => include_bytes!("../../../icons/tray-icon.ico").to_vec(),
+                _ => include_bytes!("../../../icons/tray-icon-mono.ico").to_vec(),
+            };
+
+            #[cfg(not(target_os = "macos"))]
+            let mut icon = include_bytes!("../../../icons/tray-icon.ico").to_vec();
+            if *common_tray_icon {
+                let icon_dir_path = dirs::app_home_dir()?.join("icons");
+                let png_path = icon_dir_path.join("common.png");
+                let ico_path = icon_dir_path.join("common.ico");
+                if ico_path.exists() {
+                    icon = std::fs::read(ico_path).unwrap();
+                } else if png_path.exists() {
+                    icon = std::fs::read(png_path).unwrap();
+                }
+            }
+            icon
+        };
+
+        #[cfg(target_os = "macos")]
+        {
+            let enable_tray_speed = Config::verge().latest().enable_tray_speed.unwrap_or(true);
+            let is_colorful = tray_icon == "colorful";
+            
+            // 处理图标和速率
+            let final_icon_bytes = if enable_tray_speed {
+                let rate = rate.or_else(|| {
+                    self.speed_rate
+                        .lock()
+                        .as_ref()
+                        .and_then(|speed_rate| speed_rate.get_curent_rate())
+                });
+                
+                // 使用新的方法渲染图标和速率
+                SpeedRate::add_speed_text(icon_bytes, rate)?
+            } else {
+                icon_bytes
+            };
+
+            // 设置系统托盘图标
+            let _ = tray.set_icon(Some(tauri::image::Image::from_bytes(&final_icon_bytes)?));
+            // 只对单色图标使用 template 模式
+            let _ = tray.set_icon_as_template(!is_colorful);
+        }
+
+        #[cfg(not(target_os = "macos"))]
+        let _ = tray.set_icon(Some(tauri::image::Image::from_bytes(&icon_bytes)?));
+
+        Ok(())
+    }
+
+    /// 更新托盘提示
+    pub fn update_tooltip(&self) -> Result<()> {
+        let app_handle = handle::Handle::global().app_handle().unwrap();
+        let version = VERSION.get().unwrap();
+
+        let verge = Config::verge().latest().clone();
+        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 switch_map = {
+            let mut map = std::collections::HashMap::new();
+            map.insert(true, "on");
+            map.insert(false, "off");
+            map
+        };
+
+        let mut current_profile_name = "None".to_string();
+        let profiles = Config::profiles();
+        let profiles = profiles.latest();
+        if let Some(current_profile_uid) = profiles.get_current() {
+            let current_profile = profiles.get_item(&current_profile_uid);
+            current_profile_name = match &current_profile.unwrap().name {
+                Some(profile_name) => profile_name.to_string(),
+                None => current_profile_name,
+            };
+        };
+
+        let tray = app_handle.tray_by_id("main").unwrap();
+        let _ = tray.set_tooltip(Some(&format!(
+            "Clash Verge {version}\n{}: {}\n{}: {}\n{}: {}",
+            t("SysProxy"),
+            switch_map[system_proxy],
+            t("TUN"),
+            switch_map[tun_mode],
+            t("Profile"),
+            current_profile_name
+        )));
+        Ok(())
+    }
+
+    pub fn update_part(&self) -> Result<()> {
+        self.update_menu()?;
+        self.update_icon(None)?;
+        self.update_tooltip()?;
+        Ok(())
+    }
+
+    /// 订阅流量数据
+    #[cfg(target_os = "macos")]
+    pub async fn subscribe_traffic(&self) -> Result<()> {
+        log::info!(target: "app", "subscribe traffic");
+
+        // 如果已经订阅，先取消订阅
+        if *self.is_subscribed.read() {
+            self.unsubscribe_traffic();
+        }
+
+        let (shutdown_tx, shutdown_rx) = broadcast::channel(1);
+        *self.shutdown_tx.write() = Some(shutdown_tx);
+        *self.is_subscribed.write() = true;
+
+        let speed_rate = Arc::clone(&self.speed_rate);
+        let is_subscribed = Arc::clone(&self.is_subscribed);
+
+        tauri::async_runtime::spawn(async move {
+            let mut shutdown = shutdown_rx;
+
+            'outer: loop {
+                match Traffic::get_traffic_stream().await {
+                    Ok(mut stream) => loop {
+                        tokio::select! {
+                            Some(traffic) = stream.next() => {
+                                if let Ok(traffic) = traffic {
+                                    let guard = speed_rate.lock();
+                                    let enable_tray_speed: bool = Config::verge().latest().enable_tray_speed.unwrap_or(true);
+                                    if !enable_tray_speed {
+                                        continue;
+                                    }
+                                    if let Some(sr) = guard.as_ref() {
+                                        if let Some(rate) = sr.update_and_check_changed(traffic.up, traffic.down) {
+                                            let _ = Tray::global().update_icon(Some(rate));
+                                        }
+                                    }
+                                }
+                            }
+                            _ = shutdown.recv() => break 'outer,
+                        }
+                    },
+                    Err(e) => {
+                        log::error!(target: "app", "Failed to get traffic stream: {}", e);
+                        // 如果获取流失败，等待一段时间后重试
+                        tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+
+                        // 检查是否应该继续重试
+                        if !*is_subscribed.read() {
+                            break;
+                        }
+                    }
+                }
+            }
+        });
+
+        Ok(())
+    }
+
+    /// 取消订阅 traffic 数据
+    #[cfg(target_os = "macos")]
+    pub fn unsubscribe_traffic(&self) {
+        log::info!(target: "app", "unsubscribe traffic");
+        *self.is_subscribed.write() = false;
+        if let Some(tx) = self.shutdown_tx.write().take() {
+            drop(tx);
+        }
+    }
+}
+
+fn create_tray_menu(
+    app_handle: &AppHandle,
+    mode: Option<&str>,
+    system_proxy_enabled: bool,
+    tun_mode_enabled: bool,
+    profile_uid_and_name: Vec<(String, String)>,
+) -> Result<tauri::menu::Menu<Wry>> {
+    let mode = mode.unwrap_or("");
+    let version = VERSION.get().unwrap();
+    let hotkeys = Config::verge()
+        .latest()
+        .hotkeys
+        .as_ref()
+        .map(|h| {
+            h.iter()
+                .filter_map(|item| {
+                    let mut parts = item.split(',');
+                    match (parts.next(), parts.next()) {
+                        (Some(func), Some(key)) => Some((func.to_string(), key.to_string())),
+                        _ => None,
+                    }
+                })
+                .collect::<std::collections::HashMap<String, String>>()
+        })
+        .unwrap_or_default();
+    
+    let profile_menu_items: Vec<CheckMenuItem<Wry>> = profile_uid_and_name
+        .iter()
+        .map(|(profile_uid, profile_name)| {
+        let is_current_profile = Config::profiles().data().is_current_profile_index(profile_uid.to_string());
+        CheckMenuItem::with_id(
+            app_handle,
+            &format!("profiles_{}", profile_uid),
+            t(&profile_name),
+            true,
+            is_current_profile,
+            None::<&str>,
+        )
+        .unwrap()
+    }).collect();
+    let profile_menu_items: Vec<&dyn IsMenuItem<Wry>> = profile_menu_items
+        .iter()
+        .map(|item| item as &dyn IsMenuItem<Wry>)
+        .collect();
+
+    let open_window = &MenuItem::with_id(
+        app_handle,
+        "open_window",
+        t("Dashboard"),
+        true,
+        hotkeys.get("open_or_close_dashboard").map(|s| s.as_str()),
+    )
+    .unwrap();
+
+    let rule_mode = &CheckMenuItem::with_id(
+        app_handle,
+        "rule_mode",
+        t("Rule Mode"),
+        true,
+        mode == "rule",
+        hotkeys.get("clash_mode_rule").map(|s| s.as_str()),
+    )
+    .unwrap();
+
+    let global_mode = &CheckMenuItem::with_id(
+        app_handle,
+        "global_mode",
+        t("Global Mode"),
+        true,
+        mode == "global",
+        hotkeys.get("clash_mode_global").map(|s| s.as_str()),
+    )
+    .unwrap();
+
+    let direct_mode = &CheckMenuItem::with_id(
+        app_handle,
+        "direct_mode",
+        t("Direct Mode"),
+        true,
+        mode == "direct",
+        hotkeys.get("clash_mode_direct").map(|s| s.as_str()),
+    )
+    .unwrap();
+
+    let profiles = &Submenu::with_id_and_items(
+        app_handle, 
+        "profiles", 
+        t("Profiles"),
+        true, 
+        &profile_menu_items,
+    ).unwrap();
+
+    let system_proxy = &CheckMenuItem::with_id(
+        app_handle,
+        "system_proxy",
+        t("System Proxy"),
+        true,
+        system_proxy_enabled,
+        hotkeys.get("toggle_system_proxy").map(|s| s.as_str()),
+    )
+    .unwrap();
+
+    let tun_mode = &CheckMenuItem::with_id(
+        app_handle,
+        "tun_mode",
+        t("TUN Mode"),
+        true,
+        tun_mode_enabled,
+        hotkeys.get("toggle_tun_mode").map(|s| s.as_str()),
+    )
+    .unwrap();
+
+    let copy_env =
+        &MenuItem::with_id(app_handle, "copy_env", t("Copy Env"), true, None::<&str>).unwrap();
+
+    let open_app_dir = &MenuItem::with_id(
+        app_handle,
+        "open_app_dir",
+        t("Conf Dir"),
+        true,
+        None::<&str>,
+    )
+    .unwrap();
+
+    let open_core_dir = &MenuItem::with_id(
+        app_handle,
+        "open_core_dir",
+        t("Core Dir"),
+        true,
+        None::<&str>,
+    )
+    .unwrap();
+
+    let open_logs_dir = &MenuItem::with_id(
+        app_handle,
+        "open_logs_dir",
+        t("Logs Dir"),
+        true,
+        None::<&str>,
+    )
+    .unwrap();
+
+    let open_dir = &Submenu::with_id_and_items(
+        app_handle,
+        "open_dir",
+        t("Open Dir"),
+        true,
+        &[open_app_dir, open_core_dir, open_logs_dir],
+    )
+    .unwrap();
+
+    let restart_clash = &MenuItem::with_id(
+        app_handle,
+        "restart_clash",
+        t("Restart Clash Core"),
+        true,
+        None::<&str>,
+    )
+    .unwrap();
+
+    let restart_app = &MenuItem::with_id(
+        app_handle,
+        "restart_app",
+        t("Restart App"),
+        true,
+        None::<&str>,
+    )
+    .unwrap();
+
+    let app_version = &MenuItem::with_id(
+        app_handle,
+        "app_version",
+        format!("{} {version}", t("Verge Version")),
+        true,
+        None::<&str>,
+    )
+    .unwrap();
+
+    let more = &Submenu::with_id_and_items(
+        app_handle,
+        "more",
+        t("More"),
+        true,
+        &[restart_clash, restart_app, app_version],
+    )
+    .unwrap();
+
+    let quit =
+        &MenuItem::with_id(app_handle, "quit", t("Exit"), true, Some("CmdOrControl+Q")).unwrap();
+
+    let separator = &PredefinedMenuItem::separator(app_handle).unwrap();
+
+    let menu = tauri::menu::MenuBuilder::new(app_handle)
+        .items(&[
+            open_window,
+            separator,
+            rule_mode,
+            global_mode,
+            direct_mode,
+            separator,
+            profiles,
+            separator,
+            system_proxy,
+            tun_mode,
+            copy_env,
+            open_dir,
+            more,
+            separator,
+            quit,
+        ])
+        .build()
+        .unwrap();
+    Ok(menu)
+}
+
+fn on_menu_event(_: &AppHandle, event: MenuEvent) {
+    match event.id.as_ref() {
+        mode @ ("rule_mode" | "global_mode" | "direct_mode") => {
+            let mode = &mode[0..mode.len() - 5];
+            println!("change mode to: {}", mode);
+            feat::change_clash_mode(mode.into());
+        }
+        "open_window" => resolve::create_window(),
+        "system_proxy" => feat::toggle_system_proxy(),
+        "tun_mode" => feat::toggle_tun_mode(None),
+        "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" => feat::restart_app(),
+        "quit" => {
+            println!("quit");
+            feat::quit(Some(0));
+        },
+        id if id.starts_with("profiles_") => {
+            let profile_index = &id["profiles_".len()..];
+            feat::toggle_proxy_profile(profile_index.into());
+        }
+        _ => {}
+    }
+}
@@ -0,0 +1,226 @@
+use crate::core::clash_api::{get_traffic_ws_url, Rate};
+use crate::utils::help::format_bytes_speed;
+use anyhow::Result;
+use futures::Stream;
+use image::{Rgba, GenericImageView, RgbaImage};
+use imageproc::drawing::draw_text_mut;
+use parking_lot::Mutex;
+use rusttype::{Font, Scale};
+use std::io::Cursor;
+use std::sync::Arc;
+use tokio_tungstenite::tungstenite::Message;
+
+#[derive(Debug, Clone)]
+pub struct SpeedRate {
+    rate: Arc<Mutex<(Rate, Rate)>>,
+    last_update: Arc<Mutex<std::time::Instant>>,
+    // 移除 base_image，不再缓存原始图像
+}
+
+impl SpeedRate {
+    pub fn new() -> Self {
+        Self {
+            rate: Arc::new(Mutex::new((Rate::default(), Rate::default()))),
+            last_update: Arc::new(Mutex::new(std::time::Instant::now())),
+        }
+    }
+
+    pub fn update_and_check_changed(&self, up: u64, down: u64) -> Option<Rate> {
+        let mut rates = self.rate.lock();
+        let mut last_update = self.last_update.lock();
+        let now = std::time::Instant::now();
+        
+        // 限制更新频率为每秒最多2次（500ms）
+        if now.duration_since(*last_update).as_millis() < 500 {
+            return None;
+        }
+
+        let (current, previous) = &mut *rates;
+
+        // 如果速率变化不大（小于10%），则不更新
+        let should_update = {
+            let up_change = (current.up as f64 - up as f64).abs() / (current.up as f64 + 1.0);
+            let down_change = (current.down as f64 - down as f64).abs() / (current.down as f64 + 1.0);
+            up_change > 0.1 || down_change > 0.1
+        };
+
+        if !should_update {
+            return None;
+        }
+
+        *previous = current.clone();
+        current.up = up;
+        current.down = down;
+        *last_update = now;
+
+        if previous != current {
+            Some(current.clone())
+        } else {
+            None
+        }
+    }
+
+    pub fn get_curent_rate(&self) -> Option<Rate> {
+        let rates = self.rate.lock();
+        let (current, _) = &*rates;
+        Some(current.clone())
+    }
+
+    // 分离图标加载和速率渲染
+    pub fn add_speed_text(icon_bytes: Vec<u8>, rate: Option<Rate>) -> Result<Vec<u8>> {
+        let rate = rate.unwrap_or(Rate { up: 0, down: 0 });
+        
+        // 加载原始图标
+        let icon_image = image::load_from_memory(&icon_bytes)?;
+        let (icon_width, icon_height) = (icon_image.width(), icon_image.height());
+        
+        // 判断是否为彩色图标
+        let is_colorful = !crate::utils::help::is_monochrome_image_from_bytes(&icon_bytes).unwrap_or(false);
+        
+        // 增加文本宽度和间距
+        let text_width = 580;    // 文本区域宽度
+        let total_width = icon_width + text_width;
+        
+        // 创建新的透明画布
+        let mut combined_image = RgbaImage::new(total_width, icon_height);
+        
+        // 将原始图标绘制到新画布的左侧
+        for y in 0..icon_height {
+            for x in 0..icon_width {
+                let pixel = icon_image.get_pixel(x, y);
+                combined_image.put_pixel(x, y, pixel);
+            }
+        }
+        
+        // 选择文本颜色
+        let (text_color, shadow_color) = if is_colorful {
+            // 彩色图标使用黑色文本和轻微白色阴影
+            (Rgba([255u8, 255u8, 255u8, 255u8]), Rgba([0u8, 0u8, 0u8, 160u8]))
+        } else {
+            // 单色图标使用白色文本和轻微黑色阴影
+            (Rgba([255u8, 255u8, 255u8, 255u8]), Rgba([0u8, 0u8, 0u8, 120u8]))
+        };
+        
+        // 减小字体大小以适应文本区域
+        let font = Font::try_from_bytes(include_bytes!("../../../assets/fonts/SF-Pro.ttf")).unwrap();
+        let font_size = icon_height as f32 * 0.6;  // 稍微减小字体
+        let scale = Scale::uniform(font_size);
+        
+        // 使用更简洁的速率格式
+        let up_text = format_bytes_speed(rate.up);
+        let down_text = format_bytes_speed(rate.down);
+        
+        // 计算文本位置，确保垂直间距合适
+        // 修改文本位置为居右显示
+        let up_text_width = imageproc::drawing::text_size(scale, &font, &up_text).0 as u32;
+        let down_text_width = imageproc::drawing::text_size(scale, &font, &down_text).0 as u32;
+        
+        // 计算右对齐的文本位置
+        let up_text_x = total_width - up_text_width;
+        let down_text_x = total_width - down_text_width;
+        
+        // 优化垂直位置，使速率显示的高度和上下间距正好等于图标大小
+        let text_height = font_size as i32;
+        let total_text_height = text_height * 2;
+        let up_y = (icon_height as i32 - total_text_height) / 2;
+        let down_y = up_y + text_height;
+        
+        // 绘制速率文本（先阴影后文字）
+        let shadow_offset = 1;
+        
+        // 绘制上行速率
+        draw_text_mut(
+            &mut combined_image,
+            shadow_color,
+            up_text_x as i32 + shadow_offset,
+            up_y + shadow_offset,
+            scale,
+            &font,
+            &up_text,
+        );
+        draw_text_mut(
+            &mut combined_image,
+            text_color,
+            up_text_x as i32,
+            up_y,
+            scale,
+            &font,
+            &up_text,
+        );
+        
+        // 绘制下行速率
+        draw_text_mut(
+            &mut combined_image,
+            shadow_color,
+            down_text_x as i32 + shadow_offset,
+            down_y + shadow_offset,
+            scale,
+            &font,
+            &down_text,
+        );
+        draw_text_mut(
+            &mut combined_image,
+            text_color,
+            down_text_x as i32,
+            down_y,
+            scale,
+            &font,
+            &down_text,
+        );
+        
+        // 将结果转换为 PNG 数据
+        let mut bytes = Vec::new();
+        combined_image.write_to(&mut Cursor::new(&mut bytes), image::ImageFormat::Png)?;
+        Ok(bytes)
+    }
+
+}
+
+#[derive(Debug, Clone)]
+pub struct Traffic {
+    pub up: u64,
+    pub down: u64,
+}
+
+impl Traffic {
+    pub async fn get_traffic_stream() -> Result<impl Stream<Item = Result<Traffic, anyhow::Error>>>
+    {
+        use futures::stream::{self, StreamExt};
+        use std::time::Duration;
+
+        let stream = Box::pin(
+            stream::unfold((), |_| async {
+                loop {
+                    let ws_url = get_traffic_ws_url().unwrap();
+
+                    match tokio_tungstenite::connect_async(&ws_url).await {
+                        Ok((ws_stream, _)) => {
+                            log::info!(target: "app", "traffic ws connection established");
+                            return Some((
+                                ws_stream.map(|msg| {
+                                    msg.map_err(anyhow::Error::from).and_then(|msg: Message| {
+                                        let data = msg.into_text()?;
+                                        let json: serde_json::Value = serde_json::from_str(&data)?;
+                                        Ok(Traffic {
+                                            up: json["up"].as_u64().unwrap_or(0),
+                                            down: json["down"].as_u64().unwrap_or(0),
+                                        })
+                                    })
+                                }),
+                                (),
+                            ));
+                        }
+                        Err(e) => {
+                            log::error!(target: "app", "traffic ws connection failed: {e}");
+                            tokio::time::sleep(Duration::from_secs(5)).await;
+                            continue;
+                        }
+                    }
+                }
+            })
+            .flatten(),
+        );
+
+        Ok(stream)
+    }
+}
@@ -1,4 +1,4 @@
-function main(config) {
+function main(config, _name) {
  if (config.mode === "script") {
    config.mode = "rule";
  }
@@ -1,4 +1,4 @@
-function main(config) {
+function main(config, _name) {
  if (Array.isArray(config.proxies)) {
    config.proxies.forEach((p, i) => {
      if (p.type === "hysteria" && typeof p.alpn === "string") {
@@ -1,7 +1,7 @@
 use serde_yaml::{Mapping, Value};
 use std::collections::HashSet;

-pub const HANDLE_FIELDS: [&str; 11] = [
+pub const HANDLE_FIELDS: [&str; 12] = [
    "mode",
    "redir-port",
    "tproxy-port",
@@ -13,6 +13,7 @@ pub const HANDLE_FIELDS: [&str; 11] = [
    "ipv6",
    "external-controller",
    "secret",
+    "unified-delay",
 ];

 pub const DEFAULT_FIELDS: [&str; 5] = [
@@ -54,9 +54,7 @@ fn test_merge() -> anyhow::Result<()> {
    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}");
+    let _ = serde_yaml::to_string(&use_merge(merge, config))?;

    Ok(())
 }
@@ -32,21 +32,21 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
            verge.clash_core.clone(),
            verge.enable_tun_mode.unwrap_or(false),
            verge.enable_builtin_enhanced.unwrap_or(true),
-            verge.verge_socks_enabled.unwrap_or(true),
-            verge.verge_http_enabled.unwrap_or(true),
+            verge.verge_socks_enabled.unwrap_or(false),
+            verge.verge_http_enabled.unwrap_or(false),
        )
    };
    #[cfg(not(target_os = "windows"))]
    let redir_enabled = {
        let verge = Config::verge();
        let verge = verge.latest();
-        verge.verge_redir_enabled.unwrap_or(true)
+        verge.verge_redir_enabled.unwrap_or(false)
    };
    #[cfg(target_os = "linux")]
    let tproxy_enabled = {
        let verge = Config::verge();
        let verge = verge.latest();
-        verge.verge_tproxy_enabled.unwrap_or(true)
+        verge.verge_tproxy_enabled.unwrap_or(false)
    };

    // 从profiles里拿东西
@@ -59,6 +59,7 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
        groups_item,
        global_merge,
        global_script,
+        profile_name,
    ) = {
        let profiles = Config::profiles();
        let profiles = profiles.latest();
@@ -123,6 +124,12 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
                data: ChainType::Script(tmpl::ITEM_SCRIPT.into()),
            });

+        let name = profiles
+            .get_item(&profiles.get_current().unwrap_or_default())
+            .ok()
+            .and_then(|item| item.name.clone())
+            .unwrap_or_default();
+
        (
            current,
            merge,
@@ -132,6 +139,7 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
            groups,
            global_merge,
            global_script,
+            name,
        )
    };

@@ -147,7 +155,7 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
    if let ChainType::Script(script) = global_script.data {
        let mut logs = vec![];

-        match use_script(script, config.to_owned()) {
+        match use_script(script, config.to_owned(), profile_name.to_owned()) {
            Ok((res_config, res_logs)) => {
                exists_keys.extend(use_keys(&res_config));
                config = res_config;
@@ -180,7 +188,7 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
    if let ChainType::Script(script) = script_item.data {
        let mut logs = vec![];

-        match use_script(script, config.to_owned()) {
+        match use_script(script, config.to_owned(), profile_name.to_owned()) {
            Ok((res_config, res_logs)) => {
                exists_keys.extend(use_keys(&res_config));
                config = res_config;
@@ -239,7 +247,7 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
            .for_each(|item| {
                log::debug!(target: "app", "run builtin script {}", item.uid);
                if let ChainType::Script(script) = item.data {
-                    match use_script(script, config.to_owned()) {
+                    match use_script(script, config.to_owned(), "".to_string()) {
                        Ok((res_config, _)) => {
                            config = res_config;
                        }
@@ -2,7 +2,11 @@ use super::use_lowercase;
 use anyhow::{Error, Result};
 use serde_yaml::Mapping;

-pub fn use_script(script: String, config: Mapping) -> Result<(Mapping, Vec<(String, String)>)> {
+pub fn use_script(
+    script: String,
+    config: Mapping,
+    name: String,
+) -> Result<(Mapping, Vec<(String, String)>)> {
    use boa_engine::{native_function::NativeFunction, Context, JsValue, Source};
    use std::sync::{Arc, Mutex};
    let mut context = Context::default();
@@ -42,7 +46,7 @@ pub fn use_script(script: String, config: Mapping) -> Result<(Mapping, Vec<(Stri
    let code = format!(
        r#"try{{
        {script};
-        JSON.stringify(main({config_str})||'')
+        JSON.stringify(main({config_str},'{name}')||'')
      }} catch(err) {{
        `__error_flag__ ${{err.toString()}}`
      }}"#
@@ -97,11 +101,9 @@ fn test_script() {
  "#;

    let config = serde_yaml::from_str(config).unwrap();
-    let (config, results) = use_script(script.into(), config).unwrap();
+    let (config, results) = use_script(script.into(), config, "".to_string()).unwrap();

-    let config_str = serde_yaml::to_string(&config).unwrap();
-
-    println!("{config_str}");
+    let _ = serde_yaml::to_string(&config).unwrap();

    dbg!(results);
 }
@@ -1,53 +1,138 @@
 use serde::{Deserialize, Serialize};
 use serde_yaml::{Mapping, Sequence, Value};
+
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
 pub struct SeqMap {
-    prepend: Sequence,
-    append: Sequence,
-    delete: Sequence,
+    pub prepend: Sequence,
+    pub append: Sequence,
+    pub delete: Vec<String>,
 }

-pub fn use_seq(seq_map: SeqMap, config: Mapping, name: &str) -> Mapping {
-    let mut prepend = seq_map.prepend;
-    let append = seq_map.append;
-    let delete = seq_map.delete;
+pub fn use_seq(seq: SeqMap, mut config: Mapping, field: &str) -> Mapping {
+    let SeqMap {
+        prepend,
+        append,
+        delete,
+    } = seq;

-    let origin_seq = config.get(&name).map_or(Sequence::default(), |val| {
-        val.as_sequence().unwrap_or(&Sequence::default()).clone()
-    });
-    let mut seq = origin_seq.clone();
-    prepend.reverse();
-    for item in prepend {
-        seq.insert(0, item);
+    let mut new_seq = Sequence::new();
+    new_seq.extend(prepend);
+
+    if let Some(Value::Sequence(origin)) = config.get(field) {
+        // Filter out deleted items
+        let filtered: Sequence = origin
+            .iter()
+            .filter(|item| {
+                if let Value::String(s) = item {
+                    !delete.contains(s)
+                } else if let Value::Mapping(m) = item {
+                    if let Some(Value::String(name)) = m.get("name") {
+                        !delete.contains(name)
+                    } else {
+                        true
+                    }
+                } else {
+                    true
+                }
+            })
+            .cloned()
+            .collect();
+        new_seq.extend(filtered);
    }

-    for item in append {
-        seq.push(item);
-    }
-    let mut delete_names = Vec::new();
-    for item in delete {
-        let item = item.clone();
-        if let Some(name) = if item.is_string() {
-            Some(item)
-        } else {
-            item.get("name").map(|y| y.clone())
-        } {
-            delete_names.push(name.clone());
+    new_seq.extend(append);
+    config.insert(Value::String(field.into()), Value::Sequence(new_seq));
+
+    // If this is proxies field, we also need to filter proxy-groups
+    if field == "proxies" {
+        if let Some(Value::Sequence(groups)) = config.get_mut("proxy-groups") {
+            let mut new_groups = Sequence::new();
+            for group in groups {
+                if let Value::Mapping(group_map) = group {
+                    let mut new_group = group_map.clone();
+                    if let Some(Value::Sequence(proxies)) = group_map.get("proxies") {
+                        let filtered_proxies: Sequence = proxies
+                            .iter()
+                            .filter(|p| {
+                                if let Value::String(name) = p {
+                                    !delete.contains(name)
+                                } else {
+                                    true
+                                }
+                            })
+                            .cloned()
+                            .collect();
+                        new_group.insert(
+                            Value::String("proxies".into()),
+                            Value::Sequence(filtered_proxies),
+                        );
+                    }
+                    new_groups.push(Value::Mapping(new_group));
+                } else {
+                    new_groups.push(group.clone());
+                }
+            }
+            config.insert(
+                Value::String("proxy-groups".into()),
+                Value::Sequence(new_groups),
+            );
        }
    }
-    seq.retain(|x| {
-        if let Some(x_name) = if x.is_string() {
-            Some(x)
-        } else {
-            x.get("name")
-        } {
-            !delete_names.contains(&x_name)
-        } else {
-            true
-        }
-    });

-    let mut config = config.clone();
-    config.insert(Value::from(name), Value::from(seq));
-    return config;
+    config
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_yaml::Value;
+
+    #[test]
+    fn test_delete_proxy_and_references() {
+        let config_str = r#"
+proxies:
+- name: "proxy1"
+  type: "ss"
+- name: "proxy2"
+  type: "vmess"
+proxy-groups:
+- name: "group1"
+  type: "select"
+  proxies:
+    - "proxy1"
+    - "proxy2"
+- name: "group2"
+  type: "select"
+  proxies:
+    - "proxy1"
+"#;
+        let mut config: Mapping = serde_yaml::from_str(config_str).unwrap();
+        
+        let seq = SeqMap {
+            prepend: Sequence::new(),
+            append: Sequence::new(),
+            delete: vec!["proxy1".to_string()],
+        };
+
+        config = use_seq(seq, config, "proxies");
+
+        // Check if proxy1 is removed from proxies
+        let proxies = config.get("proxies").unwrap().as_sequence().unwrap();
+        assert_eq!(proxies.len(), 1);
+        assert_eq!(
+            proxies[0].as_mapping().unwrap().get("name").unwrap().as_str().unwrap(),
+            "proxy2"
+        );
+
+        // Check if proxy1 is removed from all groups
+        let groups = config.get("proxy-groups").unwrap().as_sequence().unwrap();
+        let group1_proxies = groups[0].as_mapping().unwrap()
+            .get("proxies").unwrap().as_sequence().unwrap();
+        let group2_proxies = groups[1].as_mapping().unwrap()
+            .get("proxies").unwrap().as_sequence().unwrap();
+
+        assert_eq!(group1_proxies.len(), 1);
+        assert_eq!(group1_proxies[0].as_str().unwrap(), "proxy2");
+        assert_eq!(group2_proxies.len(), 0);
+    }
 }
@@ -1,4 +1,3 @@
-use crate::{core::service, log_err};
 use serde_yaml::{Mapping, Value};

 macro_rules! revise {
@@ -9,6 +8,7 @@ macro_rules! revise {
 }

 // if key not exists then append value
+#[allow(unused_macros)]
 macro_rules! append {
    ($map: expr, $key: expr, $val: expr) => {
        let ret_key = Value::String($key.into());
@@ -21,58 +21,82 @@ macro_rules! append {
 pub async 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);
-
-    revise!(config, "tun", tun_val);
-
-    if enable {
-        log_err!(service::set_dns_by_service().await);
-        use_dns_for_tun(config)
-    } else {
-        log_err!(service::unset_dns_by_service().await);
-        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())
    });
+    let ipv6_key = Value::from("ipv6");
+    let ipv6_val = config
+        .get(&ipv6_key)
+        .and_then(|v| v.as_bool())
+        .unwrap_or(false);

-    // 开启tun将同时开启dns
-    revise!(dns_val, "enable", true);
+    if enable {
+        // 检查现有的 enhanced-mode 设置
+        let current_mode = dns_val
+            .get(&Value::from("enhanced-mode"))
+            .and_then(|v| v.as_str())
+            .unwrap_or("fake-ip");

-    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>);
+        // 只有当 enhanced-mode 是 fake-ip 或未设置时才修改 DNS 配置
+        if current_mode == "fake-ip" || !dns_val.contains_key(&Value::from("enhanced-mode")) {
+            revise!(dns_val, "enable", true);
+            revise!(dns_val, "ipv6", ipv6_val);
+            
+            if !dns_val.contains_key(&Value::from("enhanced-mode")) {
+                revise!(dns_val, "enhanced-mode", "fake-ip");
+            }
+            
+            if !dns_val.contains_key(&Value::from("fake-ip-range")) {
+                revise!(dns_val, "fake-ip-range", "198.18.0.1/16");
+            }

-    #[cfg(target_os = "windows")]
-    append!(
-        dns_val,
-        "fake-ip-filter",
-        vec![
-            "dns.msftncsi.com",
-            "www.msftncsi.com",
-            "www.msftconnecttest.com"
-        ]
-    );
+            #[cfg(target_os = "macos")]
+            {
+                crate::utils::resolve::restore_public_dns().await;
+                crate::utils::resolve::set_public_dns("223.6.6.6".to_string()).await;
+            }
+        }
+    } else {
+        revise!(
+            dns_val,
+            "enable",
+            dns_val
+                .get("enable")
+                .and_then(|v| v.as_bool())
+                .unwrap_or(true)
+        );
+
+        revise!(dns_val, "ipv6", ipv6_val);
+
+        revise!(
+            dns_val,
+            "enhanced-mode",
+            dns_val
+                .get("enhanced-mode")
+                .and_then(|v| v.as_str())
+                .unwrap_or("redir-host")
+        );
+
+        revise!(
+            dns_val,
+            "fake-ip-range",
+            dns_val
+                .get("fake-ip-range")
+                .and_then(|v| v.as_str())
+                .unwrap_or("198.18.0.1/16")
+        );
+
+        #[cfg(target_os = "macos")]
+        crate::utils::resolve::restore_public_dns().await;
+    }
+
+    revise!(tun_val, "enable", enable);
+    revise!(config, "tun", tun_val);
    revise!(config, "dns", dns_val);
    config
 }
@@ -4,33 +4,67 @@
 //! - timer 定时器
 //! - cmds 页面调用
 //!
+use crate::cmds;
 use crate::config::*;
 use crate::core::*;
 use crate::log_err;
+use crate::utils::dirs::app_home_dir;
 use crate::utils::resolve;
 use anyhow::{bail, Result};
+use reqwest_dav::list_cmd::ListFile;
 use serde_yaml::{Mapping, Value};
-use tauri::{AppHandle, ClipboardManager, Manager};
+use std::fs;
+use tauri::Manager;
+use tauri_plugin_clipboard_manager::ClipboardExt;
+use tauri_plugin_window_state::{AppHandleExt, StateFlags};
+use std::env;

 // 打开面板
+#[allow(dead_code)]
 pub fn open_or_close_dashboard() {
-    let handle = handle::Handle::global();
-    let app_handle = handle.app_handle.lock();
-    if let Some(app_handle) = app_handle.as_ref() {
-        if let Some(window) = app_handle.get_window("main") {
-            if let Ok(true) = window.is_focused() {
-                let _ = window.close();
-                return;
+    println!("Attempting to open/close dashboard");
+    log::info!(target: "app", "Attempting to open/close dashboard");
+
+    if let Some(window) = handle::Handle::global().get_window() {
+        println!("Found existing window");
+        log::info!(target: "app", "Found existing window");
+
+        // 如果窗口存在，则切换其显示状态
+        match window.is_visible() {
+            Ok(visible) => {
+                println!("Window visibility status: {}", visible);
+                log::info!(target: "app", "Window visibility status: {}", visible);
+
+                if visible {
+                    println!("Attempting to hide window");
+                    log::info!(target: "app", "Attempting to hide window");
+                    let _ = window.hide();
+                } else {
+                    println!("Attempting to show and focus window");
+                    log::info!(target: "app", "Attempting to show and focus window");
+                    if window.is_minimized().unwrap_or(false) {
+                        let _ = window.unminimize();
+                    }
+                    let _ = window.show();
+                    let _ = window.set_focus();
+                }
+            }
+            Err(e) => {
+                println!("Failed to get window visibility: {:?}", e);
+                log::error!(target: "app", "Failed to get window visibility: {:?}", e);
            }
        }
-        resolve::create_window(app_handle);
+    } else {
+        println!("No existing window found, creating new window");
+        log::info!(target: "app", "No existing window found, creating new window");
+        resolve::create_window();
    }
 }

 // 重启clash
 pub fn restart_clash_core() {
    tauri::async_runtime::spawn(async {
-        match CoreManager::global().run_core().await {
+        match CoreManager::global().restart_core().await {
            Ok(_) => {
                handle::Handle::refresh_clash();
                handle::Handle::notice_message("set_config::ok", "ok");
@@ -43,11 +77,52 @@ pub fn restart_clash_core() {
    });
 }

+pub fn restart_app() {
+    tauri::async_runtime::spawn_blocking(|| {
+        tauri::async_runtime::block_on(async {
+            log_err!(CoreManager::global().stop_core().await);
+        });
+        resolve::resolve_reset();
+        let app_handle = handle::Handle::global().app_handle().unwrap();
+        std::thread::sleep(std::time::Duration::from_secs(1));
+        tauri::process::restart(&app_handle.env());
+    });
+}
+
+/// 设置窗口状态监控，实时保存窗口位置和大小
+pub fn setup_window_state_monitor(app_handle: &tauri::AppHandle) {
+    let window = app_handle.get_webview_window("main").unwrap();
+    let app_handle_clone = app_handle.clone();
+    
+    // 监听窗口移动事件
+    let app_handle_move = app_handle_clone.clone();
+    window.on_window_event(move |event| {
+        match event {
+            // 窗口移动时保存状态
+            tauri::WindowEvent::Moved(_) => {
+                let _ = app_handle_move.save_window_state(StateFlags::all());
+            },
+            // 窗口调整大小时保存状态
+            tauri::WindowEvent::Resized(_) => {
+                let _ = app_handle_move.save_window_state(StateFlags::all());
+            },
+            // 其他可能改变窗口状态的事件
+            tauri::WindowEvent::ScaleFactorChanged { .. } => {
+                let _ = app_handle_move.save_window_state(StateFlags::all());
+            },
+            // 窗口关闭时保存
+            tauri::WindowEvent::CloseRequested { .. } => {
+                let _ = app_handle_move.save_window_state(StateFlags::all());
+            },
+            _ => {}
+        }
+    });
+}
+
 // 切换模式 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}");

@@ -58,7 +133,8 @@ pub fn change_clash_mode(mode: String) {

                if Config::clash().data().save_config().is_ok() {
                    handle::Handle::refresh_clash();
-                    log_err!(handle::Handle::update_systray_part());
+                    log_err!(tray::Tray::global().update_menu());
+                    log_err!(tray::Tray::global().update_icon(None));
                }
            }
            Err(err) => log::error!(target: "app", "{err}"),
@@ -75,7 +151,7 @@ pub fn toggle_system_proxy() {
        match patch_verge(IVerge {
            enable_system_proxy: Some(!enable),
            ..IVerge::default()
-        })
+        }, false)
        .await
        {
            Ok(_) => handle::Handle::refresh_verge(),
@@ -84,8 +160,23 @@ pub fn toggle_system_proxy() {
    });
 }

+// 切换代理文件
+pub fn toggle_proxy_profile(profile_index: String) {
+    tauri::async_runtime::spawn(async move {
+        let app_handle = handle::Handle::global().app_handle().unwrap();
+        match cmds::patch_profiles_config_by_profile_index(app_handle, profile_index).await {
+            Ok(_) => {
+                let _ = tray::Tray::global().update_menu();
+            }
+            Err(err) => {
+                log::error!(target: "app", "{err}");
+            }
+        }
+    });
+}
+
 // 切换tun模式
-pub fn toggle_tun_mode() {
+pub fn toggle_tun_mode(not_save_file: Option<bool>) {
    let enable = Config::verge().data().enable_tun_mode;
    let enable = enable.unwrap_or(false);

@@ -93,7 +184,7 @@ pub fn toggle_tun_mode() {
        match patch_verge(IVerge {
            enable_tun_mode: Some(!enable),
            ..IVerge::default()
-        })
+        }, not_save_file.unwrap_or(false))
        .await
        {
            Ok(_) => handle::Handle::refresh_verge(),
@@ -102,59 +193,33 @@ pub fn toggle_tun_mode() {
    });
 }

+pub fn quit(code: Option<i32>) {
+    let app_handle = handle::Handle::global().app_handle().unwrap();
+    handle::Handle::global().set_is_exiting();
+    toggle_tun_mode(Some(true));
+    resolve::resolve_reset();
+    log_err!(handle::Handle::global().get_window().unwrap().close());
+    app_handle.exit(code.unwrap_or(0));
+}
+
 /// 修改clash的订阅
 pub async fn patch_clash(patch: Mapping) -> Result<()> {
    Config::clash().draft().patch_config(patch.clone());

    let res = {
-        let redir_port = patch.get("redir-port");
-        let tproxy_port = patch.get("tproxy-port");
-        let mixed_port = patch.get("mixed-port");
-        let socks_port = patch.get("socks-port");
-        let port = patch.get("port");
-        let enable_random_port = Config::verge().latest().enable_random_port.unwrap_or(false);
-        if mixed_port.is_some() && !enable_random_port {
-            let changed = mixed_port.unwrap()
-                != Config::verge()
-                    .latest()
-                    .verge_mixed_port
-                    .unwrap_or(Config::clash().data().get_mixed_port());
-            // 检查端口占用
-            if changed {
-                if let Some(port) = mixed_port.unwrap().as_u64() {
-                    if !port_scanner::local_port_available(port as u16) {
-                        Config::clash().discard();
-                        bail!("port already in use");
-                    }
-                }
-            }
-        };
-
        // 激活订阅
-        if redir_port.is_some()
-            || tproxy_port.is_some()
-            || mixed_port.is_some()
-            || socks_port.is_some()
-            || port.is_some()
-            || patch.get("secret").is_some()
-            || patch.get("external-controller").is_some()
-        {
+        if patch.get("secret").is_some() || patch.get("external-controller").is_some() {
            Config::generate().await?;
-            CoreManager::global().run_core().await?;
-            handle::Handle::refresh_clash();
+            CoreManager::global().restart_core().await?;
+        } else {
+            if patch.get("mode").is_some() {
+                log_err!(tray::Tray::global().update_menu());
+                log_err!(tray::Tray::global().update_icon(None));
+            }
+            Config::runtime().latest().patch_config(patch);
+            CoreManager::global().update_config().await?;
        }
-
-        // 更新系统代理
-        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);
-
+        handle::Handle::refresh_clash();
        <Result<()>>::Ok(())
    };
    match res {
@@ -172,7 +237,7 @@ pub async fn patch_clash(patch: Mapping) -> Result<()> {

 /// 修改verge的订阅
 /// 一般都是一个个的修改
-pub async fn patch_verge(patch: IVerge) -> Result<()> {
+pub async fn patch_verge(patch: IVerge, not_save_file: bool) -> Result<()> {
    Config::verge().draft().patch_config(patch.clone());

    let tun_mode = patch.enable_tun_mode;
@@ -182,77 +247,150 @@ pub async fn patch_verge(patch: IVerge) -> Result<()> {
    let pac_content = patch.pac_file_content;
    let proxy_bypass = patch.system_proxy_bypass;
    let language = patch.language;
-    let port = patch.verge_mixed_port;
+    let mixed_port = patch.verge_mixed_port;
+    let lite_mode = patch.enable_lite_mode;
    #[cfg(target_os = "macos")]
    let tray_icon = patch.tray_icon;
+    #[cfg(not(target_os = "macos"))]
+    let tray_icon: Option<String> = None;
    let common_tray_icon = patch.common_tray_icon;
    let sysproxy_tray_icon = patch.sysproxy_tray_icon;
    let tun_tray_icon = patch.tun_tray_icon;
    #[cfg(not(target_os = "windows"))]
    let redir_enabled = patch.verge_redir_enabled;
+    #[cfg(not(target_os = "windows"))]
+    let redir_port = patch.verge_redir_port;
    #[cfg(target_os = "linux")]
    let tproxy_enabled = patch.verge_tproxy_enabled;
+    #[cfg(target_os = "linux")]
+    let tproxy_port = patch.verge_tproxy_port;
    let socks_enabled = patch.verge_socks_enabled;
+    let socks_port = patch.verge_socks_port;
    let http_enabled = patch.verge_http_enabled;
-    let res = {
-        let service_mode = patch.enable_service_mode;
+    let http_port = patch.verge_port;
+    let enable_tray_speed = patch.enable_tray_speed;
+    let enable_global_hotkey = patch.enable_global_hotkey;

-        if service_mode.is_some() {
-            log::debug!(target: "app", "change service mode to {}", service_mode.unwrap());
+    let res: std::result::Result<(), anyhow::Error> = {
+        let mut should_restart_core = false;
+        let mut should_update_clash_config = false;
+        let mut should_update_verge_config = false;
+        let mut should_update_launch = false;
+        let mut should_update_sysproxy = false;
+        let mut should_update_systray_icon = false;
+        let mut should_update_hotkey = false;
+        let mut should_update_systray_menu = false;
+        let mut should_update_systray_tooltip = false;

-            Config::generate().await?;
-            CoreManager::global().run_core().await?;
-        } else if tun_mode.is_some() {
-            update_core_config().await?;
+        if tun_mode.is_some() {
+            should_update_clash_config = true;
+            should_update_systray_menu = true;
+            should_update_systray_tooltip = true;
+            should_update_systray_icon = true;
+        }
+        if enable_global_hotkey.is_some() {
+            should_update_verge_config = true;
        }
        #[cfg(not(target_os = "windows"))]
-        if redir_enabled.is_some() {
-            Config::generate().await?;
-            CoreManager::global().run_core().await?;
+        if redir_enabled.is_some() || redir_port.is_some() {
+            should_restart_core = true;
        }
        #[cfg(target_os = "linux")]
-        if tproxy_enabled.is_some() {
-            Config::generate().await?;
-            CoreManager::global().run_core().await?;
+        if tproxy_enabled.is_some() || tproxy_port.is_some() {
+            should_restart_core = true;
        }
-        if socks_enabled.is_some() || http_enabled.is_some() {
-            Config::generate().await?;
-            CoreManager::global().run_core().await?;
+        if socks_enabled.is_some()
+            || http_enabled.is_some()
+            || socks_port.is_some()
+            || http_port.is_some()
+            || mixed_port.is_some()
+        {
+            should_restart_core = true;
        }
        if auto_launch.is_some() {
-            sysopt::Sysopt::global().update_launch()?;
-        }
-        if system_proxy.is_some()
-            || proxy_bypass.is_some()
-            || port.is_some()
-            || pac.is_some()
-            || pac_content.is_some()
-        {
-            sysopt::Sysopt::global().update_sysproxy()?;
-            sysopt::Sysopt::global().guard_proxy();
+            should_update_launch = true;
        }

-        if let Some(true) = patch.enable_proxy_guard {
-            sysopt::Sysopt::global().guard_proxy();
+        if system_proxy.is_some() {
+            should_update_sysproxy = true;
+            should_update_systray_menu = true;
+            should_update_systray_tooltip = true;
+            should_update_systray_icon = true;
        }

-        if let Some(hotkeys) = patch.hotkeys {
-            hotkey::Hotkey::global().update(hotkeys)?;
+        if proxy_bypass.is_some() || pac_content.is_some() || pac.is_some() {
+            should_update_sysproxy = true;
        }

        if language.is_some() {
-            handle::Handle::update_systray()?;
-        } else if system_proxy.is_some()
-            || tun_mode.is_some()
-            || common_tray_icon.is_some()
+            should_update_systray_menu = true;
+        }
+        if common_tray_icon.is_some()
            || sysproxy_tray_icon.is_some()
            || tun_tray_icon.is_some()
+            || tray_icon.is_some()
        {
-            handle::Handle::update_systray_part()?;
+            should_update_systray_icon = true;
        }
-        #[cfg(target_os = "macos")]
-        if tray_icon.is_some() {
-            handle::Handle::update_systray_part()?;
+
+        if patch.hotkeys.is_some() {
+            should_update_hotkey = true;
+            should_update_systray_menu = true;
+        }
+
+        if enable_tray_speed.is_some() {
+            should_update_systray_icon = true;
+        }
+
+        if should_restart_core {
+            CoreManager::global().restart_core().await?;
+        }
+        if should_update_clash_config {
+            CoreManager::global().update_config().await?;
+            handle::Handle::refresh_clash();
+        }
+        if should_update_verge_config {
+            Config::verge().draft().enable_global_hotkey = enable_global_hotkey;
+            handle::Handle::refresh_verge();
+        }
+        if should_update_launch {
+            sysopt::Sysopt::global().update_launch()?;
+        }
+
+        if should_update_sysproxy {
+            sysopt::Sysopt::global().update_sysproxy().await?;
+        }
+
+        if should_update_hotkey {
+            hotkey::Hotkey::global().update(patch.hotkeys.unwrap())?;
+        }
+
+        if should_update_systray_menu {
+            tray::Tray::global().update_menu()?;
+        }
+
+        if should_update_systray_icon {
+            tray::Tray::global().update_icon(None)?;
+        }
+
+        if should_update_systray_tooltip {
+            tray::Tray::global().update_tooltip()?;
+        }
+
+        // 处理轻量模式切换
+        if lite_mode.is_some() {
+            if let Some(window) = handle::Handle::global().get_window() {
+                if lite_mode.unwrap() {
+                    // 完全退出 webview 进程
+                    window.close()?;  // 先关闭窗口
+                    let app_handle = handle::Handle::global().app_handle().unwrap();
+                    if let Some(webview) = app_handle.get_webview_window("main") {
+                        webview.destroy()?;  // 销毁 webview 进程
+                    }
+                } else {
+                    resolve::create_window();  // 重新创建窗口
+                }
+            }
        }

        <Result<()>>::Ok(())
@@ -260,7 +398,10 @@ pub async fn patch_verge(patch: IVerge) -> Result<()> {
    match res {
        Ok(()) => {
            Config::verge().apply();
-            Config::verge().data().save_file()?;
+            if !not_save_file {
+                Config::verge().data().save_file()?;
+            }
+
            Ok(())
        }
        Err(err) => {
@@ -273,6 +414,8 @@ pub async fn patch_verge(patch: IVerge) -> Result<()> {
 /// 更新某个profile
 /// 如果更新当前订阅就激活订阅
 pub async fn update_profile(uid: String, option: Option<PrfOption>) -> Result<()> {
+    println!("[订阅更新] 开始更新订阅 {}", uid);
+    
    let url_opt = {
        let profiles = Config::profiles();
        let profiles = profiles.latest();
@@ -280,62 +423,71 @@ pub async fn update_profile(uid: String, option: Option<PrfOption>) -> Result<()
        let is_remote = item.itype.as_ref().map_or(false, |s| s == "remote");

        if !is_remote {
-            None // 直接更新
+            println!("[订阅更新] {} 不是远程订阅，跳过更新", uid);
+            None // 非远程订阅直接更新
        } else if item.url.is_none() {
+            println!("[订阅更新] {} 缺少URL，无法更新", uid);
            bail!("failed to get the profile item url");
        } else {
+            println!("[订阅更新] {} 是远程订阅，URL: {}", uid, item.url.clone().unwrap());
            Some((item.url.clone().unwrap(), item.option.clone()))
        }
    };

    let should_update = match url_opt {
        Some((url, opt)) => {
+            println!("[订阅更新] 开始下载新的订阅内容");
            let merged_opt = PrfOption::merge(opt, option);
            let item = PrfItem::from_url(&url, None, None, merged_opt).await?;
+            
+            println!("[订阅更新] 更新订阅配置");
            let profiles = Config::profiles();
            let mut profiles = profiles.latest();
            profiles.update_item(uid.clone(), item)?;

-            Some(uid) == profiles.get_current()
+            let is_current = Some(uid.clone()) == profiles.get_current();
+            println!("[订阅更新] 是否为当前使用的订阅: {}", is_current);
+            is_current
        }
        None => true,
    };

    if should_update {
-        update_core_config().await?;
+        println!("[订阅更新] 更新内核配置");
+        match CoreManager::global().update_config().await {
+            Ok(_) => {
+                println!("[订阅更新] 更新成功");
+                handle::Handle::refresh_clash();
+            }
+            Err(err) => {
+                println!("[订阅更新] 更新失败: {}", err);
+                handle::Handle::notice_message("set_config::error", format!("{err}"));
+                log::error!(target: "app", "{err}");
+            }
+        }
    }

    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(app_handle: &AppHandle) {
+pub fn copy_clash_env() {
+    // 从环境变量获取IP地址，默认127.0.0.1
+    let clash_verge_rev_ip = env::var("CLASH_VERGE_REV_IP").unwrap_or_else(|_| "127.0.0.1".to_string());
+    
+    let app_handle = handle::Handle::global().app_handle().unwrap();
    let port = { Config::verge().latest().verge_mixed_port.unwrap_or(7897) };
-    let http_proxy = format!("http://127.0.0.1:{}", port);
-    let socks5_proxy = format!("socks5://127.0.0.1:{}", port);
+    let http_proxy = format!("http://{clash_verge_rev_ip}:{}", port);
+    let socks5_proxy = format!("socks5://{clash_verge_rev_ip}:{}", port);

    let sh =
        format!("export https_proxy={http_proxy} http_proxy={http_proxy} all_proxy={socks5_proxy}");
    let cmd: String = format!("set http_proxy={http_proxy}\r\nset https_proxy={http_proxy}");
    let ps: String = format!("$env:HTTP_PROXY=\"{http_proxy}\"; $env:HTTPS_PROXY=\"{http_proxy}\"");
+    let nu: String =
+        format!("load-env {{ http_proxy: \"{http_proxy}\", https_proxy: \"{http_proxy}\" }}");

-    let mut cliboard = app_handle.clipboard_manager();
-
+    let cliboard = app_handle.clipboard();
    let env_type = { Config::verge().latest().env_type.clone() };
    let env_type = match env_type {
        Some(env_type) => env_type,
@@ -352,6 +504,7 @@ pub fn copy_clash_env(app_handle: &AppHandle) {
        "bash" => cliboard.write_text(sh).unwrap_or_default(),
        "cmd" => cliboard.write_text(cmd).unwrap_or_default(),
        "powershell" => cliboard.write_text(ps).unwrap_or_default(),
+        "nushell" => cliboard.write_text(nu).unwrap_or_default(),
        _ => log::error!(target: "app", "copy_clash_env: Invalid env type! {env_type}"),
    };
 }
@@ -402,3 +555,76 @@ pub async fn test_delay(url: String) -> Result<u32> {
        }
    }
 }
+
+pub async fn create_backup_and_upload_webdav() -> Result<()> {
+    let (file_name, temp_file_path) = backup::create_backup().map_err(|err| {
+        log::error!(target: "app", "Failed to create backup: {:#?}", err);
+        err
+    })?;
+
+    if let Err(err) = backup::WebDavClient::global()
+        .upload(temp_file_path.clone(), file_name)
+        .await
+    {
+        log::error!(target: "app", "Failed to upload to WebDAV: {:#?}", err);
+        return Err(err);
+    }
+
+    if let Err(err) = std::fs::remove_file(&temp_file_path) {
+        log::warn!(target: "app", "Failed to remove temp file: {:#?}", err);
+    }
+
+    Ok(())
+}
+
+pub async fn list_wevdav_backup() -> Result<Vec<ListFile>> {
+    backup::WebDavClient::global().list().await.map_err(|err| {
+        log::error!(target: "app", "Failed to list WebDAV backup files: {:#?}", err);
+        err
+    })
+}
+
+pub async fn delete_webdav_backup(filename: String) -> Result<()> {
+    backup::WebDavClient::global()
+        .delete(filename)
+        .await
+        .map_err(|err| {
+            log::error!(target: "app", "Failed to delete WebDAV backup file: {:#?}", err);
+            err
+        })
+}
+
+pub async fn restore_webdav_backup(filename: String) -> Result<()> {
+    let verge = Config::verge();
+    let verge_data = verge.data().clone();
+    let webdav_url = verge_data.webdav_url.clone();
+    let webdav_username = verge_data.webdav_username.clone();
+    let webdav_password = verge_data.webdav_password.clone();
+
+    let backup_storage_path = app_home_dir().unwrap().join(&filename);
+    backup::WebDavClient::global()
+        .download(filename, backup_storage_path.clone())
+        .await
+        .map_err(|err| {
+            log::error!(target: "app", "Failed to download WebDAV backup file: {:#?}", err);
+            err
+        })?;
+
+    // extract zip file
+    let mut zip = zip::ZipArchive::new(fs::File::open(backup_storage_path.clone())?)?;
+    zip.extract(app_home_dir()?)?;
+
+    log_err!(
+        patch_verge(IVerge {
+            webdav_url,
+            webdav_username,
+            webdav_password,
+            ..IVerge::default()
+        },
+        false)
+        .await
+    );
+    // 最后删除临时文件
+    fs::remove_file(backup_storage_path)?;
+    Ok(())
+}
@@ -0,0 +1,207 @@
+mod cmds;
+mod config;
+mod core;
+mod enhance;
+mod feat;
+mod utils;
+use crate::core::hotkey;
+use crate::utils::{resolve, resolve::resolve_scheme, server};
+use config::Config;
+use tauri_plugin_autostart::MacosLauncher;
+use tauri_plugin_deep_link::DeepLinkExt;
+
+pub fn run() {
+    // 单例检测
+    let app_exists: bool = tauri::async_runtime::block_on(async move {
+        if server::check_singleton().await.is_err() {
+            println!("app exists");
+            true
+        } else {
+            false
+        }
+    });
+    if app_exists {
+        return;
+    }
+
+    #[cfg(target_os = "linux")]
+    std::env::set_var("WEBKIT_DISABLE_DMABUF_RENDERER", "1");
+
+    #[cfg(debug_assertions)]
+    let devtools = tauri_plugin_devtools::init();
+
+    #[allow(unused_mut)]
+    let mut builder = tauri::Builder::default()
+        .plugin(tauri_plugin_autostart::init(
+            MacosLauncher::LaunchAgent,
+            None,
+        ))
+        .plugin(tauri_plugin_window_state::Builder::new().build())
+        .plugin(tauri_plugin_updater::Builder::new().build())
+        .plugin(tauri_plugin_clipboard_manager::init())
+        .plugin(tauri_plugin_process::init())
+        .plugin(tauri_plugin_global_shortcut::Builder::new().build())
+        .plugin(tauri_plugin_notification::init())
+        .plugin(tauri_plugin_fs::init())
+        .plugin(tauri_plugin_dialog::init())
+        .plugin(tauri_plugin_shell::init())
+        .plugin(tauri_plugin_deep_link::init())
+        .plugin(tauri_plugin_window_state::Builder::default().build())
+        .setup(|app| {
+            #[cfg(any(target_os = "linux", all(debug_assertions, windows)))]
+            {
+                use tauri_plugin_deep_link::DeepLinkExt;
+                log_err!(app.deep_link().register_all());
+            }
+
+            app.deep_link().on_open_url(|event| {
+                tauri::async_runtime::spawn(async move {
+                    if let Some(url) = event.urls().first() {
+                        log_err!(resolve_scheme(url.to_string()).await);
+                    }
+                });
+            });
+
+            tauri::async_runtime::block_on(async move {
+                resolve::resolve_setup(app).await;
+            });
+
+            Ok(())
+        })
+        .invoke_handler(tauri::generate_handler![
+            // common
+            cmds::get_sys_proxy,
+            cmds::get_auto_proxy,
+            cmds::open_app_dir,
+            cmds::open_logs_dir,
+            cmds::open_web_url,
+            cmds::open_core_dir,
+            cmds::get_portable_flag,
+            cmds::get_network_interfaces,
+            cmds::restart_core,
+            cmds::restart_app,
+            // clash
+            cmds::get_clash_info,
+            cmds::patch_clash_config,
+            cmds::patch_clash_mode,
+            cmds::change_clash_core,
+            cmds::get_runtime_config,
+            cmds::get_runtime_yaml,
+            cmds::get_runtime_exists,
+            cmds::get_runtime_logs,
+            cmds::uwp::invoke_uwp_tool,
+            cmds::copy_clash_env,
+            // verge
+            cmds::get_verge_config,
+            cmds::patch_verge_config,
+            cmds::test_delay,
+            cmds::get_app_dir,
+            cmds::copy_icon_file,
+            cmds::download_icon_cache,
+            cmds::open_devtools,
+            cmds::exit_app,
+            cmds::get_network_interfaces_info,
+            // profile
+            cmds::get_profiles,
+            cmds::enhance_profiles,
+            cmds::patch_profiles_config,
+            cmds::view_profile,
+            cmds::patch_profile,
+            cmds::create_profile,
+            cmds::import_profile,
+            cmds::reorder_profile,
+            cmds::update_profile,
+            cmds::delete_profile,
+            cmds::read_profile_file,
+            cmds::save_profile_file,
+            // script validation
+            cmds::script_validate_notice,
+            cmds::validate_script_file,
+            // clash api
+            cmds::clash_api_get_proxy_delay,
+            // backup
+            cmds::create_webdav_backup,
+            cmds::save_webdav_config,
+            cmds::list_webdav_backup,
+            cmds::delete_webdav_backup,
+            cmds::restore_webdav_backup,
+        ]);
+
+    #[cfg(debug_assertions)]
+    {
+        builder = builder.plugin(devtools);
+    }
+
+    let app = builder
+        .build(tauri::generate_context!())
+        .expect("error while running tauri application");
+
+    app.run(|_, e| match e {
+        tauri::RunEvent::ExitRequested { api, code, .. } => {
+            if code.is_none() {
+                api.prevent_exit();
+            }
+        }
+        tauri::RunEvent::WindowEvent { label, event, .. } => {
+            if label == "main" {
+                match event {
+                    tauri::WindowEvent::CloseRequested { api, .. } => {
+                        if core::handle::Handle::global().is_exiting() {
+                            return;
+                        }
+                        println!("closing window...");
+                        api.prevent_close();
+                        let window = core::handle::Handle::global().get_window().unwrap();
+                        let _ = window.hide();
+                    }
+                    tauri::WindowEvent::Focused(true) => {
+                        #[cfg(target_os = "macos")]
+                        {
+                            log_err!(hotkey::Hotkey::global().register("CMD+Q", "quit"));
+                        }
+
+                        #[cfg(not(target_os = "macos"))]
+                        {
+                            log_err!(hotkey::Hotkey::global().register("Control+Q", "quit"));
+                        };
+                        {   
+                            let is_enable_global_hotkey = Config::verge().latest().enable_global_hotkey.unwrap_or(true);
+                            if !is_enable_global_hotkey {
+                                log_err!(hotkey::Hotkey::global().init())
+                            }
+                        }
+                    }
+                    tauri::WindowEvent::Focused(false) => {
+                        #[cfg(target_os = "macos")]
+                        {
+                            log_err!(hotkey::Hotkey::global().unregister("CMD+Q"));
+                        }
+                        #[cfg(not(target_os = "macos"))]
+                        {
+                            log_err!(hotkey::Hotkey::global().unregister("Control+Q"));
+                        };
+                        {   
+                            let is_enable_global_hotkey = Config::verge().latest().enable_global_hotkey.unwrap_or(true);
+                            if !is_enable_global_hotkey {
+                                log_err!(hotkey::Hotkey::global().reset())
+                            }
+                        }
+                    }
+                    tauri::WindowEvent::Destroyed => {
+                        #[cfg(target_os = "macos")]
+                        {
+                            log_err!(hotkey::Hotkey::global().unregister("CMD+Q"));
+                        }
+
+                        #[cfg(not(target_os = "macos"))]
+                        {
+                            log_err!(hotkey::Hotkey::global().unregister("Control+Q"));
+                        };
+                    }
+                    _ => {}
+                }
+            }
+        }
+        _ => {}
+    });
+}
@@ -1,149 +1,4 @@
-#![cfg_attr(
-    all(not(debug_assertions), target_os = "windows"),
-    windows_subsystem = "windows"
-)]
-
-mod cmds;
-mod config;
-mod core;
-mod enhance;
-mod feat;
-mod utils;
-
-use crate::utils::{init, resolve, server};
-use tauri::{api, SystemTray};
-
-fn main() -> std::io::Result<()> {
-    // 单例检测
-    let app_exists: bool = tauri::async_runtime::block_on(async move {
-        if server::check_singleton().await.is_err() {
-            println!("app exists");
-            true
-        } else {
-            false
-        }
-    });
-    if app_exists {
-        return Ok(());
-    }
-
-    #[cfg(target_os = "linux")]
-    std::env::set_var("WEBKIT_DISABLE_DMABUF_RENDERER", "1");
-
-    crate::log_err!(init::init_config());
-
-    #[allow(unused_mut)]
-    let mut builder = tauri::Builder::default()
-        .system_tray(SystemTray::new())
-        .setup(|app| {
-            tauri::async_runtime::block_on(async move {
-                resolve::resolve_setup(app).await;
-            });
-            Ok(())
-        })
-        .on_system_tray_event(core::tray::Tray::on_system_tray_event)
-        .invoke_handler(tauri::generate_handler![
-            // common
-            cmds::get_sys_proxy,
-            cmds::get_auto_proxy,
-            cmds::open_app_dir,
-            cmds::open_logs_dir,
-            cmds::open_web_url,
-            cmds::open_core_dir,
-            cmds::get_portable_flag,
-            // 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,
-            cmds::uwp::invoke_uwp_tool,
-            // verge
-            cmds::get_verge_config,
-            cmds::patch_verge_config,
-            cmds::test_delay,
-            cmds::get_app_dir,
-            cmds::copy_icon_file,
-            cmds::download_icon_cache,
-            cmds::open_devtools,
-            cmds::exit_app,
-            // 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::reorder_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")]
-    {
-        use tauri::{Menu, MenuItem, Submenu};
-
-        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::Updater(tauri::UpdaterEvent::Downloaded) => {
-            resolve::resolve_reset();
-            api::process::kill_children();
-        }
-        tauri::RunEvent::WindowEvent { label, event, .. } => {
-            if label == "main" {
-                match event {
-                    tauri::WindowEvent::Destroyed => {
-                        let _ = resolve::save_window_size_position(app_handle, true);
-                    }
-                    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(())
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+fn main() {
+    app_lib::run();
 }
@@ -1,22 +1,25 @@
 use crate::core::handle;
 use anyhow::Result;
 use once_cell::sync::OnceCell;
+use std::fs;
 use std::path::PathBuf;
-use tauri::{
-    api::path::{data_dir, resource_dir},
-    Env,
-};
+use tauri::Manager;

 #[cfg(not(feature = "verge-dev"))]
 pub static APP_ID: &str = "io.github.clash-verge-rev.clash-verge-rev";
+#[cfg(not(feature = "verge-dev"))]
+pub static BACKUP_DIR: &str = "clash-verge-rev-backup";
+
 #[cfg(feature = "verge-dev")]
 pub static APP_ID: &str = "io.github.clash-verge-rev.clash-verge-rev.dev";
+#[cfg(feature = "verge-dev")]
+pub static BACKUP_DIR: &str = "clash-verge-rev-backup-dev";

 pub static PORTABLE_FLAG: OnceCell<bool> = OnceCell::new();

-static CLASH_CONFIG: &str = "config.yaml";
-static VERGE_CONFIG: &str = "verge.yaml";
-static PROFILE_YAML: &str = "profiles.yaml";
+pub static CLASH_CONFIG: &str = "config.yaml";
+pub static VERGE_CONFIG: &str = "verge.yaml";
+pub static PROFILE_YAML: &str = "profiles.yaml";

 /// init portable flag
 pub fn init_portable_flag() -> Result<()> {
@@ -47,23 +50,27 @@ pub fn app_home_dir() -> Result<PathBuf> {
            .ok_or(anyhow::anyhow!("failed to get the portable app dir"))?;
        return Ok(PathBuf::from(app_dir).join(".config").join(APP_ID));
    }
+    let app_handle = handle::Handle::global().app_handle().unwrap();

-    Ok(data_dir()
-        .ok_or(anyhow::anyhow!("failed to get app home dir"))?
-        .join(APP_ID))
+    match app_handle.path().data_dir() {
+        Ok(dir) => Ok(dir.join(APP_ID)),
+        Err(e) => {
+            log::error!(target:"app", "Failed to get the app home directory: {}", e);
+            Err(anyhow::anyhow!("Failed to get the app homedirectory"))
+        }
+    }
 }

 /// get the resources dir
 pub fn app_resources_dir() -> Result<PathBuf> {
-    let handle = handle::Handle::global();
-    let app_handle = handle.app_handle.lock();
-    if let Some(app_handle) = app_handle.as_ref() {
-        let res_dir = resource_dir(app_handle.package_info(), &Env::default())
-            .ok_or(anyhow::anyhow!("failed to get the resource dir"))?
-            .join("resources");
-        return Ok(res_dir);
-    };
-    Err(anyhow::anyhow!("failed to get the resource dir"))
+    let app_handle = handle::Handle::global().app_handle().unwrap();
+    match app_handle.path().resource_dir() {
+        Ok(dir) => Ok(dir.join("resources")),
+        Err(e) => {
+            log::error!(target:"app", "Failed to get the resource directory: {}", e);
+            Err(anyhow::anyhow!("Failed to get the resource directory"))
+        }
+    }
 }

 /// profiles dir
@@ -88,7 +95,7 @@ pub fn profiles_path() -> Result<PathBuf> {
    Ok(app_home_dir()?.join(PROFILE_YAML))
 }

-#[cfg(not(target_os = "windows"))]
+#[cfg(target_os = "macos")]
 pub fn service_path() -> Result<PathBuf> {
    Ok(app_resources_dir()?.join("clash-verge-service"))
 }
@@ -119,3 +126,27 @@ pub fn path_to_str(path: &PathBuf) -> Result<&str> {
        .ok_or(anyhow::anyhow!("failed to get path from {:?}", path))?;
    Ok(path_str)
 }
+
+pub fn get_encryption_key() -> Result<Vec<u8>> {
+    let app_dir = app_home_dir()?;
+    let key_path = app_dir.join(".encryption_key");
+
+    if key_path.exists() {
+        // Read existing key
+        fs::read(&key_path).map_err(|e| anyhow::anyhow!("Failed to read encryption key: {}", e))
+    } else {
+        // Generate and save new key
+        let mut key = vec![0u8; 32];
+        getrandom::getrandom(&mut key)?;
+
+        // Ensure directory exists
+        if let Some(parent) = key_path.parent() {
+            fs::create_dir_all(parent)
+                .map_err(|e| anyhow::anyhow!("Failed to create key directory: {}", e))?;
+        }
+        // Save key
+        fs::write(&key_path, &key)
+            .map_err(|e| anyhow::anyhow!("Failed to save encryption key: {}", e))?;
+        Ok(key)
+    }
+}
@@ -0,0 +1,40 @@
+use crate::log_err;
+use anyhow;
+use std::{
+    backtrace::{Backtrace, BacktraceStatus},
+    thread,
+};
+
+pub fn redirect_panic_to_log() {
+    std::panic::set_hook(Box::new(move |panic_info| {
+        let thread = thread::current();
+        let thread_name = thread.name().unwrap_or("<unnamed>");
+        let payload = panic_info.payload();
+
+        let payload = if let Some(s) = payload.downcast_ref::<&str>() {
+            &**s
+        } else if let Some(s) = payload.downcast_ref::<String>() {
+            s
+        } else {
+            &format!("{:?}", payload)
+        };
+
+        let location = panic_info
+            .location()
+            .map(|l| l.to_string())
+            .unwrap_or("unknown location".to_string());
+
+        let backtrace = Backtrace::capture();
+        let backtrace = if backtrace.status() == BacktraceStatus::Captured {
+            &format!("stack backtrace:\n{}", backtrace)
+        } else {
+            "note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace"
+        };
+
+        let err: Result<(), anyhow::Error> = Err(anyhow::anyhow!(format!(
+            "thread '{}' panicked at {}:\n{}\n{}",
+            thread_name, location, payload, backtrace
+        )));
+        log_err!(err);
+    }));
+}
@@ -4,10 +4,6 @@ use nanoid::nanoid;
 use serde::{de::DeserializeOwned, Serialize};
 use serde_yaml::{Mapping, Value};
 use std::{fs, path::PathBuf, str::FromStr};
-use tauri::{
-    api::shell::{open, Program},
-    Manager,
-};

 /// read data from yaml as struct T
 pub fn read_yaml<T: DeserializeOwned>(path: &PathBuf) -> Result<T> {
@@ -102,25 +98,44 @@ pub fn get_last_part_and_decode(url: &str) -> Option<String> {
 }

 /// open file
-/// use vscode by default
-pub fn open_file(app: tauri::AppHandle, path: PathBuf) -> Result<()> {
-    #[cfg(target_os = "macos")]
-    let code = "Visual Studio Code";
-    #[cfg(not(target_os = "macos"))]
-    let code = "code";
-
-    let _ = match Program::from_str(code) {
-        Ok(code) => open(&app.shell_scope(), path.to_string_lossy(), Some(code)),
-        Err(err) => {
-            log::error!(target: "app", "Can't find VScode `{err}`");
-            // default open
-            open(&app.shell_scope(), path.to_string_lossy(), None)
-        }
-    };
-
+pub fn open_file(_: tauri::AppHandle, path: PathBuf) -> Result<()> {
+    open::that_detached(path.as_os_str())?;
    Ok(())
 }

+#[cfg(target_os = "macos")]
+pub fn is_monochrome_image_from_bytes(data: &[u8]) -> anyhow::Result<bool> {
+    let img = image::load_from_memory(data)?;
+    let rgb_img = img.to_rgb8();
+
+    for pixel in rgb_img.pixels() {
+        if pixel[0] != pixel[1] || pixel[1] != pixel[2] {
+            return Ok(false);
+        }
+    }
+    Ok(true)
+}
+
+#[cfg(target_os = "linux")]
+pub fn linux_elevator() -> String {
+    use std::process::Command;
+    match Command::new("which").arg("pkexec").output() {
+        Ok(output) => {
+            if !output.stdout.is_empty() {
+                // Convert the output to a string slice
+                if let Ok(path) = std::str::from_utf8(&output.stdout) {
+                    path.trim().to_string()
+                } else {
+                    "sudo".to_string()
+                }
+            } else {
+                "sudo".to_string()
+            }
+        }
+        Err(_) => "sudo".to_string(),
+    }
+}
+
 #[macro_export]
 macro_rules! error {
    ($result: expr) => {
@@ -175,22 +190,47 @@ macro_rules! ret_err {
    };
 }

-#[test]
-fn test_parse_value() {
-    let test_1 = "upload=111; download=2222; total=3333; expire=444";
-    let test_2 = "attachment; filename=Clash.yaml";
+#[macro_export]
+macro_rules! t {
+    ($en:expr, $zh:expr, $use_zh:expr) => {
+        if $use_zh {
+            $zh
+        } else {
+            $en
+        }
+    };
+}

-    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")
-    );
+/// 将字节数转换为可读的流量字符串
+/// 支持 B/s、KB/s、MB/s、GB/s 的自动转换
+///
+/// # Examples
+/// ```
+/// assert_eq!(format_bytes_speed(1000), "1000B/s");
+/// assert_eq!(format_bytes_speed(1024), "1.0KB/s");
+/// assert_eq!(format_bytes_speed(1024 * 1024), "1.0MB/s");
+/// ```
+#[cfg(target_os = "macos")]
+pub fn format_bytes_speed(speed: u64) -> String {
+    if speed < 1024 {
+        format!("{}B/s", speed)
+    } else if speed < 1024 * 1024 {
+        format!("{:.1}KB/s", speed as f64 / 1024.0)
+    } else if speed < 1024 * 1024 * 1024 {
+        format!("{:.1}MB/s", speed as f64 / 1024.0 / 1024.0)
+    } else {
+        format!("{:.1}GB/s", speed as f64 / 1024.0 / 1024.0 / 1024.0)
+    }
+}

-    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);
+#[cfg(target_os = "macos")]
+#[test]
+fn test_format_bytes_speed() {
+    assert_eq!(format_bytes_speed(0), "0B/s");
+    assert_eq!(format_bytes_speed(1023), "1023B/s");
+    assert_eq!(format_bytes_speed(1024), "1.0KB/s");
+    assert_eq!(format_bytes_speed(1024 * 1024), "1.0MB/s");
+    assert_eq!(format_bytes_speed(1024 * 1024 * 1024), "1.0GB/s");
+    assert_eq!(format_bytes_speed(1024 * 500), "500.0KB/s");
+    assert_eq!(format_bytes_speed(1024 * 1024 * 2), "2.0MB/s");
 }
@@ -0,0 +1,88 @@
+use crate::config::Config;
+use crate::utils::dirs;
+use once_cell::sync::Lazy;
+use serde_json::Value;
+use std::{collections::HashMap, fs, path::PathBuf};
+use sys_locale;
+
+const DEFAULT_LANGUAGE: &str = "zh";
+
+fn get_locales_dir() -> Option<PathBuf> {
+    dirs::app_resources_dir()
+        .map(|resource_path| resource_path.join("locales"))
+        .ok()
+}
+
+pub fn get_supported_languages() -> Vec<String> {
+    let mut languages = Vec::new();
+
+    if let Some(locales_dir) = get_locales_dir() {
+        if let Ok(entries) = fs::read_dir(locales_dir) {
+            for entry in entries.flatten() {
+                if let Some(file_name) = entry.file_name().to_str() {
+                    if let Some(lang) = file_name.strip_suffix(".json") {
+                        languages.push(lang.to_string());
+                    }
+                }
+            }
+        }
+    }
+
+    if languages.is_empty() {
+        languages.push(DEFAULT_LANGUAGE.to_string());
+    }
+    languages
+}
+
+static TRANSLATIONS: Lazy<HashMap<String, Value>> = Lazy::new(|| {
+    let mut translations = HashMap::new();
+
+    if let Some(locales_dir) = get_locales_dir() {
+        for lang in get_supported_languages() {
+            let file_path = locales_dir.join(format!("{}.json", lang));
+            if let Ok(content) = fs::read_to_string(file_path) {
+                if let Ok(json) = serde_json::from_str(&content) {
+                    translations.insert(lang.to_string(), json);
+                }
+            }
+        }
+    }
+    translations
+});
+
+fn get_system_language() -> String {
+    sys_locale::get_locale()
+        .map(|locale| locale.to_lowercase())
+        .and_then(|locale| locale.split(['_', '-']).next().map(String::from))
+        .filter(|lang| get_supported_languages().contains(lang))
+        .unwrap_or_else(|| DEFAULT_LANGUAGE.to_string())
+}
+
+pub fn t(key: &str) -> String {
+    let current_lang = Config::verge()
+        .latest()
+        .language
+        .as_deref()
+        .map(String::from)
+        .unwrap_or_else(get_system_language);
+
+    if let Some(text) = TRANSLATIONS
+        .get(&current_lang)
+        .and_then(|trans| trans.get(key))
+        .and_then(|val| val.as_str())
+    {
+        return text.to_string();
+    }
+
+    if current_lang != DEFAULT_LANGUAGE {
+        if let Some(text) = TRANSLATIONS
+            .get(DEFAULT_LANGUAGE)
+            .and_then(|trans| trans.get(key))
+            .and_then(|val| val.as_str())
+        {
+            return text.to_string();
+        }
+    }
+
+    key.to_string()
+}
@@ -1,4 +1,5 @@
 use crate::config::*;
+use crate::core::handle;
 use crate::utils::{dirs, help};
 use anyhow::Result;
 use chrono::{Local, TimeZone};
@@ -10,7 +11,7 @@ use log4rs::encode::pattern::PatternEncoder;
 use std::fs::{self, DirEntry};
 use std::path::PathBuf;
 use std::str::FromStr;
-use tauri::api::process::Command;
+use tauri_plugin_shell::ShellExt;

 /// initialize this instance's log file
 fn init_log() -> Result<()> {
@@ -43,21 +44,9 @@ fn init_log() -> Result<()> {

    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"]);
-        }
+    logger_builder = logger_builder.appenders(["file"]);
+    if log_more {
+        root_builder = root_builder.appenders(["file"]);
    }

    let (config, _) = log4rs::config::Config::builder()
@@ -191,18 +180,19 @@ pub fn init_config() -> Result<()> {
 /// after tauri setup
 pub fn init_resources() -> Result<()> {
    let app_dir = dirs::app_home_dir()?;
+    let test_dir = app_dir.join("test");
    let res_dir = dirs::app_resources_dir()?;

    if !app_dir.exists() {
        let _ = fs::create_dir_all(&app_dir);
    }
+    if !test_dir.exists() {
+        let _ = fs::create_dir_all(&test_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"];
-    #[cfg(not(target_os = "windows"))]
    let file_list = ["Country.mmdb", "geoip.dat", "geosite.dat"];

    // copy the resource file
@@ -210,18 +200,23 @@ pub fn init_resources() -> Result<()> {
    for file in file_list.iter() {
        let src_path = res_dir.join(file);
        let dest_path = app_dir.join(file);
+        let test_dest_path = test_dir.join(file);
+        log::debug!(target: "app", "src_path: {src_path:?}, dest_path: {dest_path:?}");

-        let handle_copy = || {
-            match fs::copy(&src_path, &dest_path) {
+        let handle_copy = |dest: &PathBuf| {
+            match fs::copy(&src_path, dest) {
                Ok(_) => log::debug!(target: "app", "resources copied '{file}'"),
                Err(err) => {
-                    log::error!(target: "app", "failed to copy resources '{file}', {err}")
+                    log::error!(target: "app", "failed to copy resources '{file}' to '{dest:?}', {err}")
                }
            };
        };

+        if src_path.exists() && !test_dest_path.exists() {
+            handle_copy(&test_dest_path);
+        }
        if src_path.exists() && !dest_path.exists() {
-            handle_copy();
+            handle_copy(&dest_path);
            continue;
        }

@@ -231,14 +226,14 @@ pub fn init_resources() -> Result<()> {
        match (src_modified, dest_modified) {
            (Ok(src_modified), Ok(dest_modified)) => {
                if src_modified > dest_modified {
-                    handle_copy();
+                    handle_copy(&dest_path);
                } else {
                    log::debug!(target: "app", "skipping resource copy '{file}'");
                }
            }
            _ => {
                log::debug!(target: "app", "failed to get modified '{file}'");
-                handle_copy();
+                handle_copy(&dest_path);
            }
        };
    }
@@ -288,43 +283,45 @@ pub fn init_scheme() -> Result<()> {
    Ok(())
 }

-pub fn startup_script() -> Result<()> {
-    let path = {
+pub async fn startup_script() -> Result<()> {
+    let app_handle = handle::Handle::global().app_handle().unwrap();
+
+    let script_path = {
        let verge = Config::verge();
        let verge = verge.latest();
        verge.startup_script.clone().unwrap_or("".to_string())
    };

-    if !path.is_empty() {
-        let mut shell = "";
-        if path.ends_with(".sh") {
-            shell = "bash";
-        }
-        if path.ends_with(".ps1") {
-            shell = "powershell";
-        }
-        if path.ends_with(".bat") {
-            shell = "powershell";
-        }
-        if shell.is_empty() {
-            return Err(anyhow::anyhow!("unsupported script: {path}"));
-        }
-        let current_dir = PathBuf::from(path.clone());
-        if !current_dir.exists() {
-            return Err(anyhow::anyhow!("script not found: {path}"));
-        }
-        let current_dir = current_dir.parent();
-        match current_dir {
-            Some(dir) => {
-                let _ = Command::new(shell)
-                    .current_dir(dir.to_path_buf())
-                    .args([path])
-                    .output()?;
-            }
-            None => {
-                let _ = Command::new(shell).args([path]).output()?;
-            }
-        }
+    if script_path.is_empty() {
+        return Ok(());
    }
+
+    let shell_type = if script_path.ends_with(".sh") {
+        "bash"
+    } else if script_path.ends_with(".ps1") || script_path.ends_with(".bat") {
+        "powershell"
+    } else {
+        return Err(anyhow::anyhow!(
+            "unsupported script extension: {}",
+            script_path
+        ));
+    };
+
+    let script_dir = PathBuf::from(&script_path);
+    if !script_dir.exists() {
+        return Err(anyhow::anyhow!("script not found: {}", script_path));
+    }
+
+    let parent_dir = script_dir.parent();
+    let working_dir = parent_dir.unwrap_or(script_dir.as_ref());
+
+    app_handle
+        .shell()
+        .command(shell_type)
+        .current_dir(working_dir)
+        .args(&[script_path])
+        .output()
+        .await?;
+
    Ok(())
 }
@@ -1,7 +1,8 @@
 pub mod dirs;
+pub mod error;
 pub mod help;
 pub mod init;
 pub mod resolve;
 pub mod server;
 pub mod tmpl;
-pub mod unix_helper;
+pub mod i18n;
@@ -1,14 +1,18 @@
-use crate::cmds::import_profile;
 use crate::config::IVerge;
-use crate::{config::Config, core::*, utils::init, utils::server};
-use crate::{log_err, trace_err};
-use anyhow::Result;
+use crate::utils::error;
+use crate::{config::Config, config::PrfItem, core::*, utils::init, utils::server};
+use crate::{log_err, wrap_err};
+use anyhow::{bail, Result};
 use once_cell::sync::OnceCell;
+use percent_encoding::percent_decode_str;
 use serde_yaml::Mapping;
 use std::net::TcpListener;
-use tauri::api::notification;
-use tauri::{App, AppHandle, Manager};
-use window_shadows::set_shadow;
+use tauri::{App, Manager};
+
+use url::Url;
+//#[cfg(not(target_os = "linux"))]
+// use window_shadows::set_shadow;
+use tauri_plugin_notification::NotificationExt;

 pub static VERSION: OnceCell<String> = OnceCell::new();

@@ -31,231 +35,348 @@ pub fn find_unused_port() -> Result<u16> {

 /// handle something when start app
 pub async fn resolve_setup(app: &mut App) {
+    error::redirect_panic_to_log();
    #[cfg(target_os = "macos")]
    app.set_activation_policy(tauri::ActivationPolicy::Accessory);
    let version = app.package_info().version.to_string();
+
    handle::Handle::global().init(app.app_handle());
    VERSION.get_or_init(|| version.clone());

+    log_err!(init::init_config());
    log_err!(init::init_resources());
    log_err!(init::init_scheme());
-    log_err!(init::startup_script());
+    log_err!(init::startup_script().await);
    // 处理随机端口
-    let enable_random_port = Config::verge().latest().enable_random_port.unwrap_or(false);
-
-    let mut port = Config::verge()
-        .latest()
-        .verge_mixed_port
-        .unwrap_or(Config::clash().data().get_mixed_port());
-
-    if enable_random_port {
-        port = find_unused_port().unwrap_or(
-            Config::verge()
-                .latest()
-                .verge_mixed_port
-                .unwrap_or(Config::clash().data().get_mixed_port()),
-        );
-    }
-
-    Config::verge().data().patch_config(IVerge {
-        verge_mixed_port: Some(port),
-        ..IVerge::default()
-    });
-    let _ = Config::verge().data().save_file();
-    let mut mapping = Mapping::new();
-    mapping.insert("mixed-port".into(), port.into());
-    Config::clash().data().patch_config(mapping);
-    let _ = Config::clash().data().save_config();
-
+    log_err!(resolve_random_port_config());
    // 启动核心
-    log::trace!("init config");
-
+    log::trace!(target:"app", "init config");
    log_err!(Config::init_config().await);

-    log::trace!("launch core");
-    log_err!(CoreManager::global().init());
+    if service::check_service().await.is_err() {
+        match service::reinstall_service().await {
+            Ok(_) => {
+                log::info!(target:"app", "install service susccess.");
+                #[cfg(not(target_os = "macos"))]
+                std::thread::sleep(std::time::Duration::from_millis(1000));
+                #[cfg(target_os = "macos")]
+                {
+                    let mut service_runing = false;
+                    for _ in 0..40 {
+                        if service::check_service().await.is_ok() {
+                            service_runing = true;
+                            break;
+                        } else {
+                            log::warn!(target: "app", "service not runing, sleep 500ms and check again.");
+                            std::thread::sleep(std::time::Duration::from_millis(500));
+                        }
+                    }
+                    if !service_runing {
+                        log::error!(target: "app", "service not runing. exit");
+                        app.app_handle().exit(-2);
+                    }
+                }
+            }
+            Err(e) => {
+                log::error!(target: "app", "{e:?}");
+                app.app_handle().exit(-1);
+            }
+        }
+    }
+
+    log::trace!(target: "app", "launch core");
+    log_err!(CoreManager::global().init().await);

    // setup a simple http server for singleton
-    log::trace!("launch embed server");
-    server::embed_server(app.app_handle());
+    log::trace!(target: "app", "launch embed server");
+    server::embed_server();

-    log::trace!("init system tray");
-    log_err!(tray::Tray::update_systray(&app.app_handle()));
+    log::trace!(target: "app", "init system tray");
+    log_err!(tray::Tray::global().init());
+    log_err!(tray::Tray::global().create_systray());
+
+    log_err!(sysopt::Sysopt::global().update_sysproxy().await);
+    log_err!(sysopt::Sysopt::global().init_guard_sysproxy());
+
+    // 初始化热键
+    log::trace!(target: "app", "init hotkeys");
+    log_err!(hotkey::Hotkey::global().init());

    let silent_start = { Config::verge().data().enable_silent_start };
    if !silent_start.unwrap_or(false) {
-        create_window(&app.app_handle());
+        create_window();
    }

-    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!(tray::Tray::global().update_part());
    log_err!(timer::Timer::global().init());
-
-    let argvs: Vec<String> = std::env::args().collect();
-    if argvs.len() > 1 {
-        let param = argvs[1].as_str();
-        if param.starts_with("clash:") {
-            log_err!(resolve_scheme(argvs[1].to_owned()).await);
-        }
-    }
 }

 /// reset system proxy
 pub fn resolve_reset() {
-    log_err!(sysopt::Sysopt::global().reset_sysproxy());
    tauri::async_runtime::block_on(async move {
+        #[cfg(target_os = "macos")]
+        tray::Tray::global().unsubscribe_traffic();
+
+        log_err!(sysopt::Sysopt::global().reset_sysproxy().await);
        log_err!(CoreManager::global().stop_core().await);
-        log_err!(service::unset_dns_by_service().await);
+        #[cfg(target_os = "macos")]
+        restore_public_dns().await;
    });
 }

 /// create main window
-pub fn create_window(app_handle: &AppHandle) {
-    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");
+pub fn create_window() {
+    println!("Starting to create window");
+    log::info!(target: "app", "Starting to create window");
+
+    let app_handle = handle::Handle::global().app_handle().unwrap();
+
+    if let Some(window) = handle::Handle::global().get_window() {
+        println!("Found existing window, trying to show it");
+        log::info!(target: "app", "Found existing window, trying to show it");
+
+        if window.is_minimized().unwrap_or(false) {
+            println!("Window is minimized, unminimizing");
+            log::info!(target: "app", "Window is minimized, unminimizing");
+            let _ = window.unminimize();
+        }
+        let _ = window.show();
+        let _ = window.set_focus();
        return;
    }

-    let mut builder = tauri::window::WindowBuilder::new(
-        app_handle,
+    println!("Creating new window");
+    log::info!(target: "app", "Creating new window");
+
+    #[cfg(target_os = "windows")]
+    let window = tauri::WebviewWindowBuilder::new(
+                &app_handle,
+                "main".to_string(),
+                tauri::WebviewUrl::App("index.html".into()),
+            )
+            .title("Clash Verge")
+            .inner_size(890.0, 700.0)
+            .min_inner_size(620.0, 550.0)
+            .decorations(false)
+            .maximizable(true)
+            .additional_browser_args("--enable-features=msWebView2EnableDraggableRegions --disable-features=OverscrollHistoryNavigation,msExperimentalScrolling")
+            .transparent(true)
+            .shadow(true)
+            .build();
+
+    #[cfg(target_os = "macos")]
+    let window = tauri::WebviewWindowBuilder::new(
+        &app_handle,
        "main".to_string(),
-        tauri::WindowUrl::App("index.html".into()),
+        tauri::WebviewUrl::App("index.html".into()),
+    )
+    .decorations(true)
+    .hidden_title(true)
+    .title_bar_style(tauri::TitleBarStyle::Overlay)
+    .inner_size(890.0, 700.0)
+    .min_inner_size(620.0, 550.0)
+    .build();
+
+    #[cfg(target_os = "linux")]
+    let window = tauri::WebviewWindowBuilder::new(
+        &app_handle,
+        "main".to_string(),
+        tauri::WebviewUrl::App("index.html".into()),
    )
    .title("Clash Verge")
-    .visible(false)
-    .fullscreen(false)
-    .min_inner_size(600.0, 520.0);
-
-    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")]
-    let window = builder
-        .decorations(false)
-        .additional_browser_args("--enable-features=msWebView2EnableDraggableRegions --disable-features=OverscrollHistoryNavigation,msExperimentalScrolling")
-        .transparent(true)
-        .visible(false)
-        .build();
-    #[cfg(target_os = "macos")]
-    let window = builder
-        .decorations(true)
-        .hidden_title(true)
-        .title_bar_style(tauri::TitleBarStyle::Overlay)
-        .build();
-    #[cfg(target_os = "linux")]
-    let window = builder.decorations(false).transparent(true).build();
+    .decorations(false)
+    .inner_size(890.0, 700.0)
+    .min_inner_size(620.0, 550.0)
+    .transparent(true)
+    .build();

    match window {
-        Ok(win) => {
-            let is_maximized = Config::verge()
-                .latest()
-                .window_is_maximized
-                .unwrap_or(false);
-            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) as i32
-                    || pos.y < -200
-                    || pos.y > (size.height - 200) as i32
-                {
-                    center = true;
-                }
-                Ok(center)
-            })();
-            if center.unwrap_or(true) {
-                trace_err!(win.center(), "set win center");
-            }
-
-            #[cfg(not(target_os = "linux"))]
-            trace_err!(set_shadow(&win, true), "set win shadow");
-            if is_maximized {
-                trace_err!(win.maximize(), "set win maximize");
-            }
+        Ok(window) => {
+            println!("Window created successfully, attempting to show");
+            log::info!(target: "app", "Window created successfully, attempting to show");
+            let _ = window.show();
+            let _ = window.set_focus();
+            
+            // 设置窗口状态监控，实时保存窗口位置和大小
+            crate::feat::setup_window_state_monitor(&app_handle);
        }
-        Err(_) => {
-            log::error!("failed to create window");
+        Err(e) => {
+            println!("Failed to create window: {:?}", e);
+            log::error!(target: "app", "Failed to create window: {:?}", e);
        }
    }
 }

-/// save window size and position
-pub fn save_window_size_position(app_handle: &AppHandle, save_to_file: bool) -> Result<()> {
-    let verge = Config::verge();
-    let mut verge = verge.latest();
-
-    if save_to_file {
-        verge.save_file()?;
-    }
-
-    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 is_maximized = win.is_maximized()?;
-    verge.window_is_maximized = Some(is_maximized);
-    if !is_maximized && size.width >= 600.0 && size.height >= 520.0 {
-        verge.window_size_position = Some(vec![size.width, size.height, pos.x, pos.y]);
-    }
-    Ok(())
-}
-
 pub async fn resolve_scheme(param: String) -> Result<()> {
-    let url = param
-        .trim_start_matches("clash://install-config/?url=")
-        .trim_start_matches("clash://install-config?url=");
-    match import_profile(url.to_string(), None).await {
-        Ok(_) => {
-            notification::Notification::new(crate::utils::dirs::APP_ID)
-                .title("Clash Verge")
-                .body("Import profile success")
-                .show()
-                .unwrap();
-        }
+    log::info!(target:"app", "received deep link: {}", param);
+
+    let app_handle = handle::Handle::global().app_handle().unwrap();
+
+    let param_str = if param.starts_with("[") && param.len() > 4 {
+        param
+            .get(2..param.len() - 2)
+            .ok_or_else(|| anyhow::anyhow!("Invalid string slice boundaries"))?
+    } else {
+        param.as_str()
+    };
+
+    // 解析 URL
+    let link_parsed = match Url::parse(param_str) {
+        Ok(url) => url,
        Err(e) => {
-            notification::Notification::new(crate::utils::dirs::APP_ID)
-                .title("Clash Verge")
-                .body(format!("Import profile failed: {e}"))
-                .show()
-                .unwrap();
-            log::error!("Import profile failed: {e}");
+            bail!("failed to parse deep link: {:?}, param: {:?}", e, param);
+        }
+    };
+
+    if link_parsed.scheme() == "clash" || link_parsed.scheme() == "clash-verge" {
+        let name = link_parsed
+            .query_pairs()
+            .find(|(key, _)| key == "name")
+            .map(|(_, value)| value.into_owned());
+
+        let encode_url = link_parsed
+            .query_pairs()
+            .find(|(key, _)| key == "url")
+            .map(|(_, value)| value.into_owned());
+
+        match encode_url {
+            Some(url) => {
+                let url = percent_decode_str(url.as_ref())
+                    .decode_utf8_lossy()
+                    .to_string();
+
+                create_window();
+                match PrfItem::from_url(url.as_ref(), name, None, None).await {
+                    Ok(item) => {
+                        let uid = item.uid.clone().unwrap();
+                        let _ = wrap_err!(Config::profiles().data().append_item(item));
+                        handle::Handle::notice_message("import_sub_url::ok", uid);
+
+                        app_handle
+                            .notification()
+                            .builder()
+                            .title("Clash Verge")
+                            .body("Import profile success")
+                            .show()
+                            .unwrap();
+                    }
+                    Err(e) => {
+                        handle::Handle::notice_message("import_sub_url::error", e.to_string());
+                        app_handle
+                            .notification()
+                            .builder()
+                            .title("Clash Verge")
+                            .body(format!("Import profile failed: {e}"))
+                            .show()
+                            .unwrap();
+                    }
+                }
+            }
+            None => bail!("failed to get profile url"),
        }
    }
+
    Ok(())
 }
+
+fn resolve_random_port_config() -> Result<()> {
+    let verge_config = Config::verge();
+    let clash_config = Config::clash();
+    let enable_random_port = verge_config.latest().enable_random_port.unwrap_or(false);
+
+    let default_port = verge_config
+        .latest()
+        .verge_mixed_port
+        .unwrap_or(clash_config.data().get_mixed_port());
+
+    let port = if enable_random_port {
+        find_unused_port().unwrap_or(default_port)
+    } else {
+        default_port
+    };
+
+    verge_config.data().patch_config(IVerge {
+        verge_mixed_port: Some(port),
+        ..IVerge::default()
+    });
+    verge_config.data().save_file()?;
+
+    let mut mapping = Mapping::new();
+    mapping.insert("mixed-port".into(), port.into());
+    clash_config.data().patch_config(mapping);
+    clash_config.data().save_config()?;
+    Ok(())
+}
+
+#[cfg(target_os = "macos")]
+pub async fn set_public_dns(dns_server: String) {
+    use crate::core::handle;
+    use crate::utils::dirs;
+    use tauri_plugin_shell::ShellExt;
+    let app_handle = handle::Handle::global().app_handle().unwrap();
+
+    log::info!(target: "app", "try to set system dns");
+    let resource_dir = dirs::app_resources_dir().unwrap();
+    let script = resource_dir.join("set_dns.sh");
+    if !script.exists() {
+        log::error!(target: "app", "set_dns.sh not found");
+        return;
+    }
+    let script = script.to_string_lossy().into_owned();
+    match app_handle
+        .shell()
+        .command("bash")
+        .args([script, dns_server])
+        .current_dir(resource_dir)
+        .status()
+        .await
+    {
+        Ok(status) => {
+            if status.success() {
+                log::info!(target: "app", "set system dns successfully");
+            } else {
+                let code = status.code().unwrap_or(-1);
+                log::error!(target: "app", "set system dns failed: {code}");
+            }
+        }
+        Err(err) => {
+            log::error!(target: "app", "set system dns failed: {err}");
+        }
+    }
+}
+
+#[cfg(target_os = "macos")]
+pub async fn restore_public_dns() {
+    use crate::core::handle;
+    use crate::utils::dirs;
+    use tauri_plugin_shell::ShellExt;
+    let app_handle = handle::Handle::global().app_handle().unwrap();
+    log::info!(target: "app", "try to unset system dns");
+    let resource_dir = dirs::app_resources_dir().unwrap();
+    let script = resource_dir.join("unset_dns.sh");
+    if !script.exists() {
+        log::error!(target: "app", "unset_dns.sh not found");
+        return;
+    }
+    let script = script.to_string_lossy().into_owned();
+    match app_handle
+        .shell()
+        .command("bash")
+        .args([script])
+        .current_dir(resource_dir)
+        .status()
+        .await
+    {
+        Ok(status) => {
+            if status.success() {
+                log::info!(target: "app", "unset system dns successfully");
+            } else {
+                let code = status.code().unwrap_or(-1);
+                log::error!(target: "app", "unset system dns failed: {code}");
+            }
+        }
+        Err(err) => {
+            log::error!(target: "app", "unset system dns failed: {err}");
+        }
+    }
+}
@@ -1,14 +1,11 @@
 extern crate warp;

 use super::resolve;
-use crate::{
-    config::{Config, IVerge, DEFAULT_PAC},
-    log_err,
-};
+use crate::config::{Config, IVerge, DEFAULT_PAC};
+use crate::log_err;
 use anyhow::{bail, Result};
 use port_scanner::local_port_available;
 use std::convert::Infallible;
-use tauri::AppHandle;
 use warp::Filter;

 #[derive(serde::Deserialize, Debug)]
@@ -19,36 +16,24 @@ struct QueryParam {
 /// check whether there is already exists
 pub async fn check_singleton() -> Result<()> {
    let port = IVerge::get_singleton_port();
-
    if !local_port_available(port) {
-        let resp = reqwest::get(format!("http://127.0.0.1:{port}/commands/ping"))
-            .await?
-            .text()
-            .await?;
-
-        if &resp == "ok" {
-            let argvs: Vec<String> = std::env::args().collect();
-            if argvs.len() > 1 {
+        let argvs: Vec<String> = std::env::args().collect();
+        if argvs.len() > 1 {
+            #[cfg(not(target_os = "macos"))]
+            {
                let param = argvs[1].as_str();
                if param.starts_with("clash:") {
-                    reqwest::get(format!(
+                    let _ = reqwest::get(format!(
                        "http://127.0.0.1:{port}/commands/scheme?param={param}"
                    ))
-                    .await?
-                    .text()
-                    .await?;
+                    .await;
                }
-            } else {
-                reqwest::get(format!("http://127.0.0.1:{port}/commands/visible"))
-                    .await?
-                    .text()
-                    .await?;
            }
-            bail!("app exists");
+        } else {
+            let _ = reqwest::get(format!("http://127.0.0.1:{port}/commands/visible")).await;
        }
-
        log::error!("failed to setup singleton listen server");
-        Ok(())
+        bail!("app exists");
    } else {
        Ok(())
    }
@@ -56,14 +41,12 @@ pub async fn check_singleton() -> Result<()> {

 /// The embed server only be used to implement singleton process
 /// maybe it can be used as pac server later
-pub fn embed_server(app_handle: AppHandle) {
+pub fn embed_server() {
    let port = IVerge::get_singleton_port();

    tauri::async_runtime::spawn(async move {
-        let ping = warp::path!("commands" / "ping").map(move || "ok");
-
        let visible = warp::path!("commands" / "visible").map(move || {
-            resolve::create_window(&app_handle);
+            resolve::create_window();
            "ok"
        });

@@ -83,15 +66,15 @@ pub fn embed_server(app_handle: AppHandle) {
                .body(content)
                .unwrap_or_default()
        });
-        let scheme = warp::path!("commands" / "scheme")
-            .and(warp::query::<QueryParam>())
-            .and_then(scheme_handler);
-
        async fn scheme_handler(query: QueryParam) -> Result<impl warp::Reply, Infallible> {
            log_err!(resolve::resolve_scheme(query.param).await);
            Ok("ok")
        }
-        let commands = ping.or(visible).or(pac).or(scheme);
+
+        let scheme = warp::path!("commands" / "scheme")
+            .and(warp::query::<QueryParam>())
+            .and_then(scheme_handler);
+        let commands = visible.or(scheme).or(pac);
        warp::serve(commands).run(([127, 0, 0, 1], port)).await;
    });
 }
@@ -27,7 +27,7 @@ pub const ITEM_MERGE_EMPTY: &str = "# Profile Enhancement Merge Template for Cla
 /// enhanced profile
 pub const ITEM_SCRIPT: &str = "// Define main function (script entry)

-function main(config) {
+function main(config, profileName) {
  return config;
 }
 ";
@@ -1,14 +0,0 @@
-#[cfg(target_os = "linux")]
-pub fn linux_elevator() -> &'static str {
-    use std::process::Command;
-    match Command::new("which").arg("pkexec").output() {
-        Ok(output) => {
-            if output.stdout.is_empty() {
-                "sudo"
-            } else {
-                "pkexec"
-            }
-        }
-        Err(_) => "sudo",
-    }
-}
@@ -1,82 +1,57 @@
 {
-  "$schema": "../node_modules/@tauri-apps/cli/schema.json",
-  "package": {
-    "productName": "Clash Verge",
-    "version": "1.7.2"
+  "$schema": "../node_modules/@tauri-apps/cli/config.schema.json",
+  "bundle": {
+    "active": true,
+    "longDescription": "Clash Verge Rev",
+    "icon": [
+      "icons/32x32.png",
+      "icons/128x128.png",
+      "icons/128x128@2x.png",
+      "icons/icon.icns",
+      "icons/icon.ico"
+    ],
+    "resources": ["resources", "resources/locales/*"],
+    "publisher": "Clash Verge Rev",
+    "externalBin": ["sidecar/verge-mihomo", "sidecar/verge-mihomo-alpha"],
+    "copyright": "GNU General Public License v3.0",
+    "category": "DeveloperTool",
+    "shortDescription": "Clash Verge Rev",
+    "createUpdaterArtifacts": true
  },
  "build": {
-    "distDir": "../dist",
-    "devPath": "http://localhost:3000/",
+    "beforeBuildCommand": "pnpm run web:build",
+    "frontendDist": "../dist",
    "beforeDevCommand": "pnpm run web:dev",
-    "beforeBuildCommand": "pnpm run web:build"
+    "devUrl": "http://localhost:3000/"
  },
-  "tauri": {
-    "bundle": {
-      "active": true,
-      "identifier": "io.github.clash-verge-rev.clash-verge-rev",
-      "icon": [
-        "icons/32x32.png",
-        "icons/128x128.png",
-        "icons/128x128@2x.png",
-        "icons/icon.icns",
-        "icons/icon.ico"
-      ],
-      "resources": ["resources"],
-      "publisher": "Clash Verge Rev",
-      "externalBin": ["sidecar/verge-mihomo", "sidecar/verge-mihomo-alpha"],
-      "copyright": "GNU General Public License v3.0",
-      "category": "DeveloperTool",
-      "shortDescription": "A Clash Meta GUI based on tauri.",
-      "longDescription": "A Clash Meta GUI based on tauri."
-    },
+  "productName": "Clash Verge",
+  "version": "2.1.2",
+  "identifier": "io.github.clash-verge-rev.clash-verge-rev",
+  "plugins": {
    "updater": {
-      "active": true,
+      "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IEQyOEMyRjBCQkVGOUJEREYKUldUZnZmbStDeStNMHU5Mmo1N24xQXZwSVRYbXA2NUpzZE5oVzlqeS9Bc0t6RVV4MmtwVjBZaHgK",
      "endpoints": [
-        "https://mirror.ghproxy.com/https://github.com/clash-verge-rev/clash-verge-rev/releases/download/updater/update-proxy.json",
+        "https://download.clashverge.dev/https://github.com/clash-verge-rev/clash-verge-rev/releases/download/updater/update-proxy.json",
        "https://github.com/clash-verge-rev/clash-verge-rev/releases/download/updater/update.json"
      ],
-      "dialog": false,
-      "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IEQyOEMyRjBCQkVGOUJEREYKUldUZnZmbStDeStNMHU5Mmo1N24xQXZwSVRYbXA2NUpzZE5oVzlqeS9Bc0t6RVV4MmtwVjBZaHgK"
-    },
-    "allowlist": {
-      "shell": {
-        "all": true
-      },
-      "window": {
-        "all": true
-      },
-      "process": {
-        "all": true
-      },
-      "globalShortcut": {
-        "all": true
-      },
-      "clipboard": {
-        "all": true
-      },
-      "notification": {
-        "all": true
-      },
-      "dialog": {
-        "all": false,
-        "open": true
-      },
-      "protocol": {
-        "asset": true,
-        "assetScope": ["$APPDATA/**", "$RESOURCE/../**", "**"]
-      },
-      "path": {
-        "all": true
-      },
-      "fs": {
-        "exists": true,
-        "readFile": true,
-        "scope": ["$APPDATA/**", "$RESOURCE/../**", "**"]
+      "windows": {
+        "installMode": "basicUi"
      }
    },
-    "windows": [],
+    "deep-link": {
+      "desktop": {
+        "schemes": ["clash", "clash-verge"]
+      }
+    }
+  },
+  "app": {
    "security": {
-      "csp": "default-src blob: data: filesystem: ws: wss: http: https: tauri: asset: 'unsafe-eval' 'unsafe-inline' 'self';"
+      "capabilities": ["desktop-capability", "migrated"],
+      "assetProtocol": {
+        "scope": ["$APPDATA/**", "$RESOURCE/../**", "**"],
+        "enable": true
+      },
+      "csp": null
    }
  }
 }
@@ -1,26 +1,39 @@
 {
-  "$schema": "../node_modules/@tauri-apps/cli/schema.json",
-  "tauri": {
-    "systemTray": {
-      "iconPath": "icons/tray-icon.ico"
-    },
-    "bundle": {
-      "identifier": "io.github.clash-verge-rev.clash-verge-rev",
-      "targets": ["deb", "rpm"],
+  "$schema": "../node_modules/@tauri-apps/cli/config.schema.json",
+  "identifier": "io.github.clash-verge-rev.clash-verge-rev",
+  "bundle": {
+    "targets": ["deb", "rpm"],
+    "linux": {
      "deb": {
        "depends": ["openssl"],
-        "desktopTemplate": "./template/clash-verge.desktop",
+        "desktopTemplate": "./packages/linux/clash-verge.desktop",
        "provides": ["clash-verge"],
        "conflicts": ["clash-verge"],
-        "replaces": ["clash-verge"]
+        "replaces": ["clash-verge"],
+        "postInstallScript": "./packages/linux/post-install.sh",
+        "preRemoveScript": "./packages/linux/pre-remove.sh"
      },
      "rpm": {
        "depends": ["openssl"],
-        "desktopTemplate": "./template/clash-verge.desktop",
+        "desktopTemplate": "./packages/linux/clash-verge.desktop",
        "provides": ["clash-verge"],
        "conflicts": ["clash-verge"],
-        "obsoletes": ["clash-verge"]
+        "obsoletes": ["clash-verge"],
+        "postInstallScript": "./packages/linux/post-install.sh",
+        "preRemoveScript": "./packages/linux/pre-remove.sh"
      }
+    },
+    "externalBin": [
+      "./resources/clash-verge-service",
+      "./resources/install-service",
+      "./resources/uninstall-service",
+      "./sidecar/verge-mihomo",
+      "./sidecar/verge-mihomo-alpha"
+    ]
+  },
+  "app": {
+    "trayIcon": {
+      "iconPath": "icons/tray-icon.ico"
    }
  }
 }
@@ -1,20 +1,14 @@
 {
-  "$schema": "../node_modules/@tauri-apps/cli/schema.json",
-  "tauri": {
-    "systemTray": {
-      "iconPath": "icons/tray-icon-mono.ico",
-      "iconAsTemplate": true
-    },
-    "bundle": {
-      "identifier": "io.github.clash-verge-rev.clash-verge-rev",
-      "targets": ["app", "dmg", "updater"],
-      "macOS": {
-        "frameworks": [],
-        "minimumSystemVersion": "10.15",
-        "exceptionDomain": "",
-        "signingIdentity": null,
-        "entitlements": null
-      },
+  "$schema": "../node_modules/@tauri-apps/cli/config.schema.json",
+  "identifier": "io.github.clash-verge-rev.clash-verge-rev",
+  "bundle": {
+    "targets": ["app", "dmg"],
+    "macOS": {
+      "frameworks": [],
+      "minimumSystemVersion": "10.15",
+      "exceptionDomain": "",
+      "signingIdentity": null,
+      "entitlements": "packages/macos/entitlements.plist",
      "dmg": {
        "background": "images/background.png",
        "appPosition": {
@@ -35,5 +29,11 @@
        }
      }
    }
+  },
+  "app": {
+    "trayIcon": {
+      "iconPath": "icons/tray-icon-mono.ico",
+      "iconAsTemplate": true
+    }
  }
 }
@@ -1,29 +1,31 @@
 {
-  "$schema": "../node_modules/@tauri-apps/cli/schema.json",
-  "tauri": {
-    "systemTray": {
-      "iconPath": "icons/tray-icon.ico"
-    },
-    "bundle": {
-      "identifier": "io.github.clash-verge-rev.clash-verge-rev",
-      "targets": ["nsis", "updater"],
-      "windows": {
-        "certificateThumbprint": null,
-        "digestAlgorithm": "sha256",
-        "timestampUrl": "",
-        "webviewInstallMode": {
-          "type": "embedBootstrapper",
-          "silent": true
-        },
-        "nsis": {
-          "displayLanguageSelector": true,
-          "installerIcon": "icons/icon.ico",
-          "languages": ["SimpChinese", "English"],
-          "license": "../LICENSE",
-          "installMode": "perMachine",
-          "template": "./template/installer.nsi"
-        }
+  "$schema": "../node_modules/@tauri-apps/cli/config.schema.json",
+  "identifier": "io.github.clash-verge-rev.clash-verge-rev",
+  "bundle": {
+    "targets": ["nsis"],
+    "windows": {
+      "certificateThumbprint": null,
+      "digestAlgorithm": "sha256",
+      "timestampUrl": "",
+      "webviewInstallMode": {
+        "type": "embedBootstrapper",
+        "silent": true
+      },
+      "nsis": {
+        "displayLanguageSelector": true,
+        "installerIcon": "icons/icon.ico",
+        "languages": ["SimpChinese", "English"],
+        "installMode": "perMachine",
+        "template": "./packages/windows/installer.nsi"
      }
    }
+  },
+  "app": {
+    "trayIcon": {
+      "iconPath": "icons/tray-icon.ico",
+      "iconAsTemplate": true,
+      "showMenuOnLeftClick": false
+    },
+    "windows": []
  }
 }
@@ -1,38 +1,40 @@
 {
-  "$schema": "../node_modules/@tauri-apps/cli/schema.json",
-  "tauri": {
-    "systemTray": {
-      "iconPath": "icons/tray-icon.ico"
-    },
-    "bundle": {
-      "identifier": "io.github.clash-verge-rev.clash-verge-rev",
-      "targets": ["nsis", "updater"],
-      "windows": {
-        "certificateThumbprint": null,
-        "digestAlgorithm": "sha256",
-        "timestampUrl": "",
-        "webviewInstallMode": {
-          "type": "fixedRuntime",
-          "path": "./Microsoft.WebView2.FixedVersionRuntime.109.0.1518.78.arm64/"
-        },
-        "nsis": {
-          "displayLanguageSelector": true,
-          "installerIcon": "icons/icon.ico",
-          "languages": ["SimpChinese", "English"],
-          "license": "../LICENSE",
-          "installMode": "perMachine",
-          "template": "./template/installer.nsi"
-        }
+  "$schema": "../node_modules/@tauri-apps/cli/config.schema.json",
+  "identifier": "io.github.clash-verge-rev.clash-verge-rev",
+  "bundle": {
+    "targets": ["nsis"],
+    "windows": {
+      "certificateThumbprint": null,
+      "digestAlgorithm": "sha256",
+      "timestampUrl": "",
+      "webviewInstallMode": {
+        "type": "fixedRuntime",
+        "path": "./Microsoft.WebView2.FixedVersionRuntime.109.0.1518.78.arm64/"
+      },
+      "nsis": {
+        "displayLanguageSelector": true,
+        "installerIcon": "icons/icon.ico",
+        "languages": ["SimpChinese", "English"],
+        "installMode": "perMachine",
+        "template": "./packages/windows/installer.nsi"
      }
-    },
+    }
+  },
+  "plugins": {
    "updater": {
      "active": true,
      "dialog": false,
      "endpoints": [
-        "https://mirror.ghproxy.com/https://github.com/clash-verge-rev/clash-verge-rev/releases/download/updater/update-fixed-webview2-proxy.json",
+        "https://download.clashverge.dev/https://github.com/clash-verge-rev/clash-verge-rev/releases/download/updater/update-fixed-webview2-proxy.json",
        "https://github.com/clash-verge-rev/clash-verge-rev/releases/download/updater/update-fixed-webview2.json"
      ],
      "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IEQyOEMyRjBCQkVGOUJEREYKUldUZnZmbStDeStNMHU5Mmo1N24xQXZwSVRYbXA2NUpzZE5oVzlqeS9Bc0t6RVV4MmtwVjBZaHgK"
    }
+  },
+  "app": {
+    "trayIcon": {
+      "iconPath": "icons/tray-icon.ico",
+      "iconAsTemplate": true
+    }
  }
 }
@@ -1,38 +1,40 @@
 {
-  "$schema": "../node_modules/@tauri-apps/cli/schema.json",
-  "tauri": {
-    "systemTray": {
-      "iconPath": "icons/tray-icon.ico"
-    },
-    "bundle": {
-      "identifier": "io.github.clash-verge-rev.clash-verge-rev",
-      "targets": ["nsis", "updater"],
-      "windows": {
-        "certificateThumbprint": null,
-        "digestAlgorithm": "sha256",
-        "timestampUrl": "",
-        "webviewInstallMode": {
-          "type": "fixedRuntime",
-          "path": "./Microsoft.WebView2.FixedVersionRuntime.109.0.1518.78.x64/"
-        },
-        "nsis": {
-          "displayLanguageSelector": true,
-          "installerIcon": "icons/icon.ico",
-          "languages": ["SimpChinese", "English"],
-          "license": "../LICENSE",
-          "installMode": "perMachine",
-          "template": "./template/installer.nsi"
-        }
+  "$schema": "../node_modules/@tauri-apps/cli/config.schema.json",
+  "identifier": "io.github.clash-verge-rev.clash-verge-rev",
+  "bundle": {
+    "targets": ["nsis"],
+    "windows": {
+      "certificateThumbprint": null,
+      "digestAlgorithm": "sha256",
+      "timestampUrl": "",
+      "webviewInstallMode": {
+        "type": "fixedRuntime",
+        "path": "./Microsoft.WebView2.FixedVersionRuntime.109.0.1518.78.x64/"
+      },
+      "nsis": {
+        "displayLanguageSelector": true,
+        "installerIcon": "icons/icon.ico",
+        "languages": ["SimpChinese", "English"],
+        "installMode": "perMachine",
+        "template": "./packages/windows/installer.nsi"
      }
-    },
+    }
+  },
+  "plugins": {
    "updater": {
      "active": true,
      "dialog": false,
      "endpoints": [
-        "https://mirror.ghproxy.com/https://github.com/clash-verge-rev/clash-verge-rev/releases/download/updater/update-fixed-webview2-proxy.json",
+        "https://download.clashverge.dev/https://github.com/clash-verge-rev/clash-verge-rev/releases/download/updater/update-fixed-webview2-proxy.json",
        "https://github.com/clash-verge-rev/clash-verge-rev/releases/download/updater/update-fixed-webview2.json"
      ],
      "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IEQyOEMyRjBCQkVGOUJEREYKUldUZnZmbStDeStNMHU5Mmo1N24xQXZwSVRYbXA2NUpzZE5oVzlqeS9Bc0t6RVV4MmtwVjBZaHgK"
    }
+  },
+  "app": {
+    "trayIcon": {
+      "iconPath": "icons/tray-icon.ico",
+      "iconAsTemplate": true
+    }
  }
 }
@@ -1,38 +1,40 @@
 {
-  "$schema": "../node_modules/@tauri-apps/cli/schema.json",
-  "tauri": {
-    "systemTray": {
-      "iconPath": "icons/tray-icon.ico"
-    },
-    "bundle": {
-      "identifier": "io.github.clash-verge-rev.clash-verge-rev",
-      "targets": ["nsis", "updater"],
-      "windows": {
-        "certificateThumbprint": null,
-        "digestAlgorithm": "sha256",
-        "timestampUrl": "",
-        "webviewInstallMode": {
-          "type": "fixedRuntime",
-          "path": "./Microsoft.WebView2.FixedVersionRuntime.109.0.1518.78.x86/"
-        },
-        "nsis": {
-          "displayLanguageSelector": true,
-          "installerIcon": "icons/icon.ico",
-          "languages": ["SimpChinese", "English"],
-          "license": "../LICENSE",
-          "installMode": "perMachine",
-          "template": "./template/installer.nsi"
-        }
+  "$schema": "../node_modules/@tauri-apps/cli/config.schema.json",
+  "identifier": "io.github.clash-verge-rev.clash-verge-rev",
+  "bundle": {
+    "targets": ["nsis"],
+    "windows": {
+      "certificateThumbprint": null,
+      "digestAlgorithm": "sha256",
+      "timestampUrl": "",
+      "webviewInstallMode": {
+        "type": "fixedRuntime",
+        "path": "./Microsoft.WebView2.FixedVersionRuntime.109.0.1518.78.x86/"
+      },
+      "nsis": {
+        "displayLanguageSelector": true,
+        "installerIcon": "icons/icon.ico",
+        "languages": ["SimpChinese", "English"],
+        "installMode": "perMachine",
+        "template": "./packages/windows/installer.nsi"
      }
-    },
+    }
+  },
+  "plugins": {
    "updater": {
      "active": true,
      "dialog": false,
      "endpoints": [
-        "https://mirror.ghproxy.com/https://github.com/clash-verge-rev/clash-verge-rev/releases/download/updater/update-fixed-webview2-proxy.json",
+        "https://download.clashverge.dev/https://github.com/clash-verge-rev/clash-verge-rev/releases/download/updater/update-fixed-webview2-proxy.json",
        "https://github.com/clash-verge-rev/clash-verge-rev/releases/download/updater/update-fixed-webview2.json"
      ],
      "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IEQyOEMyRjBCQkVGOUJEREYKUldUZnZmbStDeStNMHU5Mmo1N24xQXZwSVRYbXA2NUpzZE5oVzlqeS9Bc0t6RVV4MmtwVjBZaHgK"
    }
+  },
+  "app": {
+    "trayIcon": {
+      "iconPath": "icons/tray-icon.ico",
+      "iconAsTemplate": true
+    }
  }
 }
@@ -1,3 +1,7 @@
+@use "./layout.scss";
+@use "./page.scss";
+@use "./font.scss";
+
 body {
  margin: 0;
  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", "Roboto", "Oxygen",
@@ -43,10 +47,6 @@ body {
  overflow: hidden;
 }

-@import "./layout.scss";
-@import "./page.scss";
-@import "./font.scss";
-
 // @media (prefers-color-scheme: dark) {
 //   :root {
 //     background-color: rgba(18, 18, 18, 1);
@@ -111,7 +111,7 @@
      position: absolute;
      top: 0;
      left: 0;
-      right: 2px;
+      right: 1px;
      bottom: 0px;
    }
  }
@@ -146,8 +146,14 @@
    .layout__left {
      padding-top: 24px;
    }
+
    .layout__right .the-content {
      top: 24px;
    }
+
+    .layout__left .the-newbtn {
+      right: 9px;
+      top: 2px;
+    }
  }
 }
@@ -10,7 +10,7 @@ type Props = {
 };

 export const BaseFieldset: React.FC<Props> = (props: Props) => {
-  const Fieldset = styled(Box)(() => ({
+  const Fieldset = styled(Box)<{ component?: string }>(() => ({
    position: "relative",
    border: "1px solid #bbb",
    borderRadius: "5px",
@@ -0,0 +1,33 @@
+import React from "react";
+import { Box, CircularProgress } from "@mui/material";
+
+export interface BaseLoadingOverlayProps {
+  isLoading: boolean;
+}
+
+export const BaseLoadingOverlay: React.FC<BaseLoadingOverlayProps> = ({
+  isLoading,
+}) => {
+  if (!isLoading) return null;
+
+  return (
+    <Box
+      sx={{
+        position: "absolute",
+        top: 0,
+        left: 0,
+        right: 0,
+        bottom: 0,
+        display: "flex",
+        justifyContent: "center",
+        alignItems: "center",
+        backgroundColor: "rgba(255, 255, 255, 0.7)",
+        zIndex: 1000,
+      }}
+    >
+      <CircularProgress />
+    </Box>
+  );
+};
+
+export default BaseLoadingOverlay;
@@ -1,9 +1,14 @@
 import { createRoot } from "react-dom/client";
 import { ReactNode, useState, useEffect } from "react";
 import { Box, IconButton, Slide, Snackbar, Typography } from "@mui/material";
-import { Close, CheckCircleRounded, ErrorRounded } from "@mui/icons-material";
+import {
+  CloseRounded,
+  CheckCircleRounded,
+  ErrorRounded,
+} from "@mui/icons-material";
 import { useVerge } from "@/hooks/use-verge";
-import { appWindow } from "@tauri-apps/api/window";
+import { getCurrentWebviewWindow } from "@tauri-apps/api/webviewWindow";
+const appWindow = getCurrentWebviewWindow();
 interface InnerProps {
  type: string;
  duration?: number;
@@ -13,7 +18,7 @@ interface InnerProps {
 }

 const NoticeInner = (props: InnerProps) => {
-  const { type, message, duration = 1500, onClose } = props;
+  const { type, message, duration, onClose } = props;
  const [visible, setVisible] = useState(true);
  const [isDark, setIsDark] = useState(false);
  const { verge } = useVerge();
@@ -38,7 +43,7 @@ const NoticeInner = (props: InnerProps) => {

    appWindow.theme().then((m) => m && setIsDark(m === "dark"));
    const unlisten = appWindow.onThemeChanged((e) =>
-      setIsDark(e.payload === "dark")
+      setIsDark(e.payload === "dark"),
    );

    return () => {
@@ -67,7 +72,7 @@ const NoticeInner = (props: InnerProps) => {
    <Snackbar
      open={visible}
      anchorOrigin={{ vertical: "top", horizontal: "right" }}
-      autoHideDuration={duration}
+      autoHideDuration={duration === -1 ? null : duration || 1500}
      onClose={onAutoClose}
      message={msgElement}
      sx={{
@@ -81,7 +86,7 @@ const NoticeInner = (props: InnerProps) => {
      transitionDuration={200}
      action={
        <IconButton size="small" color="inherit" onClick={onBtnClose}>
-          <Close fontSize="inherit" />
+          <CloseRounded fontSize="inherit" />
        </IconButton>
      }
    />
@@ -100,25 +105,55 @@ let parent: HTMLDivElement = null!;

 // @ts-ignore
 export const Notice: NoticeInstance = (props) => {
+  const { type, message, duration } = props;
+
+  // 验证必要的参数
+  if (!message) {
+    return;
+  }
+
  if (!parent) {
    parent = document.createElement("div");
+    parent.setAttribute("id", "notice-container"); // 添加 id 便于调试
    document.body.appendChild(parent);
  }

  const container = document.createElement("div");
  parent.appendChild(container);
+
  const root = createRoot(container);

  const onUnmount = () => {
    root.unmount();
-    if (parent) setTimeout(() => parent.removeChild(container), 500);
+    if (parent && container.parentNode === parent) {
+      setTimeout(() => {
+        parent.removeChild(container);
+      }, 500);
+    }
  };

-  root.render(<NoticeInner {...props} onClose={onUnmount} />);
+  root.render(
+    <NoticeInner
+      type={type}
+      message={message}
+      duration={duration || 1500}
+      onClose={onUnmount}
+    />,
+  );
 };

 (["info", "error", "success"] as const).forEach((type) => {
-  Notice[type] = (message, duration) => {
-    setTimeout(() => Notice({ type, message, duration }), 0);
+  Notice[type] = (message: ReactNode, duration?: number) => {
+    // 确保消息不为空
+    if (!message) {
+      return;
+    }
+
+    Notice({
+      type,
+      message,
+      // 错误类型通知显示 8 秒，其他类型默认 1.5 秒
+      duration: type === "error" ? 8000 : duration || 1500,
+    });
  };
 });
@@ -1,7 +1,7 @@
 import React, { ReactNode } from "react";
 import { Typography } from "@mui/material";
 import { BaseErrorBoundary } from "./base-error-boundary";
-import { useCustomTheme } from "@/components/layout/use-custom-theme";
+import { useTheme } from "@mui/material/styles";

 interface Props {
  title?: React.ReactNode; // the page title
@@ -13,7 +13,7 @@ interface Props {

 export const BasePage: React.FC<Props> = (props) => {
  const { title, header, contentStyle, full, children } = props;
-  const { theme } = useCustomTheme();
+  const theme = useTheme();

  const isDark = theme.palette.mode === "dark";

@@ -1,37 +1,49 @@
 import { Box, SvgIcon, TextField, styled } from "@mui/material";
 import Tooltip from "@mui/material/Tooltip";
-import { ChangeEvent, useEffect, useRef, useState } from "react";
+import { ChangeEvent, useEffect, useRef, useState, useMemo } from "react";

 import { useTranslation } from "react-i18next";
 import matchCaseIcon from "@/assets/image/component/match_case.svg?react";
 import matchWholeWordIcon from "@/assets/image/component/match_whole_word.svg?react";
 import useRegularExpressionIcon from "@/assets/image/component/use_regular_expression.svg?react";

+export type SearchState = {
+  text: string;
+  matchCase: boolean;
+  matchWholeWord: boolean;
+  useRegularExpression: boolean;
+};
+
 type SearchProps = {
  placeholder?: string;
  matchCase?: boolean;
  matchWholeWord?: boolean;
  useRegularExpression?: boolean;
-  onSearch: (
-    match: (content: string) => boolean,
-    state: {
-      text: string;
-      matchCase: boolean;
-      matchWholeWord: boolean;
-      useRegularExpression: boolean;
-    }
-  ) => void;
+  onSearch: (match: (content: string) => boolean, state: SearchState) => void;
 };

-export const BaseSearchBox = styled((props: SearchProps) => {
+const StyledTextField = styled(TextField)(({ theme }) => ({
+  "& .MuiInputBase-root": {
+    background: theme.palette.mode === "light" ? "#fff" : undefined,
+    paddingRight: "4px",
+  },
+  "& .MuiInputBase-root svg[aria-label='active'] path": {
+    fill: theme.palette.primary.light,
+  },
+  "& .MuiInputBase-root svg[aria-label='inactive'] path": {
+    fill: "#A7A7A7",
+  },
+}));
+
+export const BaseSearchBox = (props: SearchProps) => {
  const { t } = useTranslation();
  const inputRef = useRef<HTMLInputElement>(null);
-  const [matchCase, setMatchCase] = useState(props.matchCase ?? true);
+  const [matchCase, setMatchCase] = useState(props.matchCase ?? false);
  const [matchWholeWord, setMatchWholeWord] = useState(
-    props.matchWholeWord ?? false
+    props.matchWholeWord ?? false,
  );
  const [useRegularExpression, setUseRegularExpression] = useState(
-    props.useRegularExpression ?? false
+    props.useRegularExpression ?? false,
  );
  const [errorMessage, setErrorMessage] = useState("");

@@ -44,59 +56,59 @@ export const BaseSearchBox = styled((props: SearchProps) => {
    inheritViewBox: true,
  };

-  useEffect(() => {
-    if (!inputRef.current) return;
-
-    onChange({
-      target: inputRef.current,
-    } as ChangeEvent<HTMLInputElement>);
-  }, [matchCase, matchWholeWord, useRegularExpression]);
-
-  const onChange = (e: ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => {
-    props.onSearch(
-      (content) => doSearch([content], e.target?.value ?? "").length > 0,
-      {
-        text: e.target?.value ?? "",
-        matchCase,
-        matchWholeWord,
-        useRegularExpression,
-      }
-    );
-  };
-
-  const doSearch = (searchList: string[], searchItem: string) => {
-    setErrorMessage("");
-    return searchList.filter((item) => {
+  const createMatcher = useMemo(() => {
+    return (searchText: string) => {
      try {
-        let searchItemCopy = searchItem;
-        if (!matchCase) {
-          item = item.toLowerCase();
-          searchItemCopy = searchItemCopy.toLowerCase();
-        }
-        if (matchWholeWord) {
-          const regex = new RegExp(`\\b${searchItemCopy}\\b`);
+        return (content: string) => {
+          if (!searchText) return true;
+
+          let item = !matchCase ? content.toLowerCase() : content;
+          let searchItem = !matchCase ? searchText.toLowerCase() : searchText;
+
          if (useRegularExpression) {
-            const regexWithOptions = new RegExp(searchItemCopy);
-            return regexWithOptions.test(item) && regex.test(item);
-          } else {
-            return regex.test(item);
+            return new RegExp(searchItem).test(item);
          }
-        } else if (useRegularExpression) {
-          const regex = new RegExp(searchItemCopy);
-          return regex.test(item);
-        } else {
-          return item.includes(searchItemCopy);
-        }
+
+          if (matchWholeWord) {
+            return new RegExp(`\\b${searchItem}\\b`).test(item);
+          }
+
+          return item.includes(searchItem);
+        };
      } catch (err) {
        setErrorMessage(`${err}`);
+        return () => true;
      }
+    };
+  }, [matchCase, matchWholeWord, useRegularExpression]);
+
+  useEffect(() => {
+    if (!inputRef.current) return;
+    const value = inputRef.current.value;
+    setErrorMessage("");
+    props.onSearch(createMatcher(value), {
+      text: value,
+      matchCase,
+      matchWholeWord,
+      useRegularExpression,
+    });
+  }, [matchCase, matchWholeWord, useRegularExpression, createMatcher]);
+
+  const onChange = (e: ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => {
+    const value = e.target?.value ?? "";
+    setErrorMessage("");
+    props.onSearch(createMatcher(value), {
+      text: value,
+      matchCase,
+      matchWholeWord,
+      useRegularExpression,
    });
  };

  return (
    <Tooltip title={errorMessage} placement="bottom-start">
-      <TextField
-        autoComplete="off"
+      <StyledTextField
+        autoComplete="new-password"
        inputRef={inputRef}
        hiddenLabel
        fullWidth
@@ -116,9 +128,7 @@ export const BaseSearchBox = styled((props: SearchProps) => {
                    component={matchCaseIcon}
                    {...iconStyle}
                    aria-label={matchCase ? "active" : "inactive"}
-                    onClick={() => {
-                      setMatchCase(!matchCase);
-                    }}
+                    onClick={() => setMatchCase(!matchCase)}
                  />
                </div>
              </Tooltip>
@@ -128,9 +138,7 @@ export const BaseSearchBox = styled((props: SearchProps) => {
                    component={matchWholeWordIcon}
                    {...iconStyle}
                    aria-label={matchWholeWord ? "active" : "inactive"}
-                    onClick={() => {
-                      setMatchWholeWord(!matchWholeWord);
-                    }}
+                    onClick={() => setMatchWholeWord(!matchWholeWord)}
                  />
                </div>
              </Tooltip>
@@ -140,28 +148,16 @@ export const BaseSearchBox = styled((props: SearchProps) => {
                    component={useRegularExpressionIcon}
                    aria-label={useRegularExpression ? "active" : "inactive"}
                    {...iconStyle}
-                    onClick={() => {
-                      setUseRegularExpression(!useRegularExpression);
-                    }}
+                    onClick={() =>
+                      setUseRegularExpression(!useRegularExpression)
+                    }
                  />{" "}
                </div>
              </Tooltip>
            </Box>
          ),
        }}
-        {...props}
      />
    </Tooltip>
  );
-})(({ theme }) => ({
-  "& .MuiInputBase-root": {
-    background: theme.palette.mode === "light" ? "#fff" : undefined,
-    "padding-right": "4px",
-  },
-  "& .MuiInputBase-root svg[aria-label='active'] path": {
-    fill: theme.palette.primary.light,
-  },
-  "& .MuiInputBase-root svg[aria-label='inactive'] path": {
-    fill: "#A7A7A7",
-  },
-}));
+};
@@ -4,7 +4,7 @@ export const BaseStyledSelect = styled((props: SelectProps<string>) => {
  return (
    <Select
      size="small"
-      autoComplete="off"
+      autoComplete="new-password"
      sx={{
        width: 120,
        height: 33.375,
@@ -6,7 +6,7 @@ export const BaseStyledTextField = styled((props: TextFieldProps) => {

  return (
    <TextField
-      autoComplete="off"
+      autoComplete="new-password"
      hiddenLabel
      fullWidth
      size="small"
--- a/Show More
+++ b/Show More