Release 1.7.2

#1300

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,56 @@
+name: 问题反馈 / Bug report
+title: "[BUG] "
+description: 反馈你遇到的问题 / Report the issue you are experiencing
+labels: ["bug"]
+
+body:
+  - type: markdown
+    attributes:
+      value: |
+        ## 在提交问题之前，请确认以下事项：
+        1. 请 **确保** 您已经查阅了 [Clash Verge Rev 官方文档](https://clash-verge-rev.github.io/guide/term.html)  以及 [常见问题](https://clash-verge-rev.github.io/faq/windows.html)
+        2. 请 **确保** [已有的问题](https://github.com/clash-verge-rev/clash-verge-rev/issues?q=is%3Aissue) 中没有人提交过相似issue，否则请在已有的issue下进行讨论
+        3. 请 **务必** 给issue填写一个简洁明了的标题，以便他人快速检索
+        4. 请 **务必** 先下载 [Alpha](https://github.com/clash-verge-rev/clash-verge-rev/releases/tag/alpha) 版本测试，确保问题依然存在
+        5. 请 **务必** 按照模板规范详细描述问题，否则issue将会被关闭
+        ## Before submitting the issue, please make sure of the following checklist:
+        1. Please make sure you have read the [Clash Verge Rev official documentation](https://clash-verge-rev.github.io/guide/term.html) and [FAQ](https://clash-verge-rev.github.io/faq/windows.html)
+        2. Please make sure there is no similar issue in the [existing issues](https://github.com/clash-verge-rev/clash-verge-rev/issues?q=is%3Aissue), otherwise please discuss under the existing issue
+        3. Please be sure to fill in a concise and clear title for the issue so that others can quickly search
+        4. Please be sure to download the [Alpha](https://github.com/clash-verge-rev/clash-verge-rev/releases/tag/alpha) version for testing to ensure that the problem still exists
+        5. Please describe the problem in detail according to the template specification, otherwise the issue will be closed
+
+  - type: textarea
+    id: description
+    attributes:
+      label: 问题描述 / Describe the bug
+      description: 详细清晰地描述你遇到的问题 / A clear and concise description of what the bug is
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: 复现步骤 / To Reproduce
+      description: 请提供复现问题的步骤 / Steps to reproduce the behavior
+    validations:
+      required: true
+  - type: dropdown
+    attributes:
+      label: 操作系统 / OS
+      options:
+        - Windows
+        - Linux
+        - MacOS
+    validations:
+      required: true
+  - type: input
+    attributes:
+      label: 操作系统版本 / OS Version
+      description: 请提供你的操作系统版本，Linux请额外提供桌面环境及窗口系统 / Please provide your OS version, for Linux, please also provide the desktop environment and window system
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: 日志 / Log
+      description: 请提供完整或相关部分的Debug日志 / Please provide the complete or relevant part of the Debug log
+    validations:
+      required: true

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,4 @@
+contact_links:
+  - name: 讨论交流 / Communication
+    url: https://t.me/clash_verge_rev
+    about: 在 Telegram 群组中与其他用户讨论交流 / Communicate with other users in the Telegram group

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,35 @@
+name: 功能请求 / Feature request
+title: "[Feature] "
+description: 提出你的功能请求 / Propose your feature request
+labels: ["enhancement"]
+
+body:
+  - type: markdown
+    attributes:
+      value: |
+        ## 在提交问题之前，请确认以下事项：
+        1. 请 **确保** 您已经查阅了 [Clash Verge Rev 官方文档](https://clash-verge-rev.github.io/guide/term.html) 确认软件不存在类似的功能
+        2. 请 **确保** [已有的问题](https://github.com/clash-verge-rev/clash-verge-rev/issues?q=is%3Aissue) 中没有人提交过相似issue，否则请在已有的issue下进行讨论
+        3. 请 **务必** 给issue填写一个简洁明了的标题，以便他人快速检索
+        4. 请 **务必** 先下载 [Alpha](https://github.com/clash-verge-rev/clash-verge-rev/releases/tag/alpha) 版本测试，确保该功能还未实现
+        5. 请 **务必** 按照模板规范详细描述问题，否则issue将会被关闭
+        ## Before submitting the issue, please make sure of the following checklist:
+        1. Please make sure you have read the [Clash Verge Rev official documentation](https://clash-verge-rev.github.io/guide/term.html) to confirm that the software does not have similar functions
+        2. Please make sure there is no similar issue in the [existing issues](https://github.com/clash-verge-rev/clash-verge-rev/issues?q=is%3Aissue), otherwise please discuss under the existing issue
+        3. Please be sure to fill in a concise and clear title for the issue so that others can quickly search
+        4. Please be sure to download the [Alpha](https://github.com/clash-verge-rev/clash-verge-rev/releases/tag/alpha) version for testing to ensure that the function has not been implemented
+        5. Please describe the problem in detail according to the template specification, otherwise the issue will be closed
+
+  - type: textarea
+    id: description
+    attributes:
+      label: 功能描述 / Feature description
+      description: 详细清晰地描述你的功能请求 / A clear and concise description of what the feature is
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: 使用场景 / Use case
+      description: 请描述你的功能请求的使用场景 / Please describe the use case of your feature request
+    validations:
+      required: true

.github/build-for-linux/Dockerfile

@@ -0,0 +1,4 @@
+FROM rust:buster
+COPY entrypoint.sh /entrypoint.sh
+RUN chmod a+x /entrypoint.sh
+ENTRYPOINT ["/entrypoint.sh"] 

.github/build-for-linux/action.yml

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

.github/build-for-linux/build.sh

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

.github/build-for-linux/entrypoint.sh

@@ -0,0 +1,53 @@
+#!/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

.github/workflows/alpha.yml

@@ -1,87 +1,288 @@
-name: Alpha CI
+name: Alpha Build
 
 on:
   workflow_dispatch:
-    inputs:
-      debug:
-        type: boolean
-        default: false
-
+  push:
+    branches: [main]
+    tags-ignore: [updater, alpha]
+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:
-  release:
+  alpha:
     strategy:
       fail-fast: false
       matrix:
-        os: [windows-latest, ubuntu-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    if: startsWith(github.repository, 'zzzgydi')
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v2
+        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
 
-      - name: Install Rust
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          profile: minimal
-          override: true
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      - name: Install Rust Stable
+        uses: dtolnay/rust-toolchain@1.77.0
+
+      - 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@v1
+        uses: actions/setup-node@v4
         with:
-          node-version: 16
+          node-version: "20"
 
-      - name: Install Dependencies (ubuntu only)
-        if: matrix.os == 'ubuntu-latest'
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libgtk-3-dev webkit2gtk-4.0 libappindicator3-dev librsvg2-dev patchelf
-
-      - name: Get yarn cache dir path
-        id: yarn-cache-dir-path
-        run: echo "::set-output name=dir::$(yarn cache dir)"
-
-      - name: Yarn Cache
-        uses: actions/cache@v2
-        id: yarn-cache
+      - uses: pnpm/action-setup@v4
+        name: Install pnpm
         with:
-          path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
-          key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-yarn-
+          run_install: false
 
-      - name: Yarn install and check
+      - name: Pnpm install and check
         run: |
-          yarn install --network-timeout 1000000
-          yarn run check
+          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_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_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:
+          tagName: alpha
+          releaseName: "Clash Verge Rev Alpha"
+          releaseBody: "More new features are now supported."
+          releaseDraft: false
+          prerelease: true
+          tauriScript: pnpm
+          args: --target ${{ matrix.target }}
+
+      - name: Portable Bundle
+        if: matrix.os == 'windows-latest'
+        run: pnpm portable ${{ matrix.target }} --alpha
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  alpha-for-linux:
+    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
+            target: aarch64-unknown-linux-gnu
+          - os: ubuntu-latest
+            target: armv7-unknown-linux-gnueabihf
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      - name: Build for Linux
+        uses: ./.github/build-for-linux
+        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 }}
+
+      - 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
+        with:
+          tag_name: alpha
+          name: "Clash Verge Rev Alpha"
+          body: "More new features are now supported."
+          prerelease: true
+          token: ${{ secrets.GITHUB_TOKEN }}
+          files: |
+            src-tauri/target/${{ matrix.target }}/release/bundle/deb/*.deb
+            src-tauri/target/${{ matrix.target }}/release/bundle/rpm/*.rpm
+
+  alpha-for-fixed-webview2:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - 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
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      - 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: Download WebView2 Runtime
+        run: |
+          invoke-webrequest -uri https://github.com/westinyang/WebView2RuntimeArchive/releases/download/109.0.1518.78/Microsoft.WebView2.FixedVersionRuntime.109.0.1518.78.${{ matrix.arch }}.cab -outfile Microsoft.WebView2.FixedVersionRuntime.109.0.1518.78.${{ matrix.arch }}.cab
+          Expand .\Microsoft.WebView2.FixedVersionRuntime.109.0.1518.78.${{ matrix.arch }}.cab -F:* ./src-tauri
+          Remove-Item .\src-tauri\tauri.windows.conf.json
+          Rename-Item .\src-tauri\webview2.${{ matrix.arch }}.json tauri.windows.conf.json
+
+      - name: Tauri build
+        id: 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 }}
         with:
-          tagName: alpha
-          releaseName: "Clash Verge Alpha"
-          releaseBody: "Alpha Version (include debug)"
-          releaseDraft: false
-          includeDebug: ${{ github.event.inputs.debug }}
+          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'
+
+      - name: Upload Release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: alpha
+          name: "Clash Verge Rev Alpha"
+          body: "More new features are now supported."
           prerelease: true
+          token: ${{ secrets.GITHUB_TOKEN }}
+          files: src-tauri/target/${{ matrix.target }}/release/bundle/nsis/*setup*
 
       - name: Portable Bundle
-        if: matrix.os == 'windows-latest'
-        run: |
-          yarn run portable
+        run: pnpm portable-fixed-webview2 ${{ matrix.target }} --alpha
         env:
-          TAG_NAME: alpha
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  update_tag:
+    name: Update tag
+    runs-on: ubuntu-latest
+    needs: [alpha, alpha-for-linux, alpha-for-fixed-webview2]
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set Env
+        run: |
+          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 }}
+
+      - run: |
+          cat > release.txt << 'EOF'
+          ## 我应该下载哪个版本？
+
+          ### MacOS (提示文件损坏或开发者无法验证请查看下面FAQ)
+          - 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 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时使用)
+          - 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)
+
+          Created at  ${{ env.BUILDTIME }}.
+          EOF
+
+      - name: Upload Release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: alpha
+          name: "Clash Verge Rev Alpha"
+          body_path: release.txt
+          prerelease: true
+          token: ${{ secrets.GITHUB_TOKEN }}
+          generate_release_notes: true

.github/workflows/ci.yml

@@ -1,122 +0,0 @@
-name: Release CI
-
-on:
-  push:
-    tags:
-      - v**
-
-env:
-  CARGO_INCREMENTAL: 0
-  RUST_BACKTRACE: short
-
-jobs:
-  release:
-    strategy:
-      matrix:
-        os: [windows-latest, ubuntu-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    if: |
-      startsWith(github.repository, 'zzzgydi') &&
-      startsWith(github.ref, 'refs/tags/v')
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v2
-
-      - name: Install Rust
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          profile: minimal
-          override: true
-
-      - name: Rust Cache
-        uses: Swatinem/rust-cache@v2
-        with:
-          workspaces: src-tauri
-
-      - name: Install Node
-        uses: actions/setup-node@v1
-        with:
-          node-version: 16
-
-      - name: Install Dependencies (ubuntu only)
-        if: startsWith(matrix.os, 'ubuntu-')
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libgtk-3-dev webkit2gtk-4.0 libappindicator3-dev librsvg2-dev patchelf
-
-      - name: Get yarn cache dir path
-        id: yarn-cache-dir-path
-        run: echo "::set-output name=dir::$(yarn cache dir)"
-
-      - name: Yarn Cache
-        uses: actions/cache@v2
-        id: yarn-cache
-        with:
-          path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
-          key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-yarn-
-
-      - name: Yarn install and check
-        run: |
-          yarn install --network-timeout 1000000
-          yarn run check
-
-      - name: Tauri build
-        uses: tauri-apps/tauri-action@v0
-        # enable cache even though failed
-        # continue-on-error: true
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
-          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
-        with:
-          tagName: v__VERSION__
-          releaseName: "Clash Verge v__VERSION__"
-          releaseBody: "More new features are now supported."
-          releaseDraft: false
-          prerelease: true
-
-      - name: Portable Bundle
-        if: matrix.os == 'windows-latest'
-        # rebuild with env settings
-        run: |
-          yarn build
-          yarn run portable
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
-          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
-          VITE_WIN_PORTABLE: 1
-
-  release-update:
-    needs: release
-    runs-on: macos-latest
-    if: |
-      startsWith(github.repository, 'zzzgydi') &&
-      startsWith(github.ref, 'refs/tags/v')
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v2
-
-      - name: Get yarn cache dir path
-        id: yarn-cache-dir-path
-        run: echo "::set-output name=dir::$(yarn cache dir)"
-
-      - name: Yarn Cache
-        uses: actions/cache@v2
-        id: yarn-cache
-        with:
-          path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
-          key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-yarn-
-
-      - name: Yarn install
-        run: yarn install
-
-      - name: Release updater file
-        run: yarn run updater
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/compatible.yml

@@ -1,102 +0,0 @@
-name: Compatible CI
-
-on:
-  workflow_dispatch:
-  push:
-    tags:
-      - v**
-
-env:
-  CARGO_INCREMENTAL: 0
-  RUST_BACKTRACE: short
-
-jobs:
-  build:
-    strategy:
-      fail-fast: false
-      matrix:
-        targets:
-          - tag: macOS-10.15
-            os: macos-10.15
-          - tag: Ubuntu18
-            os: ubuntu-18.04
-          - tag: Ubuntu22
-            os: ubuntu-22.04
-
-    runs-on: ${{ matrix.targets.os }}
-    if: startsWith(github.repository, 'zzzgydi')
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v2
-
-      - name: Install Rust
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          profile: minimal
-          override: true
-
-      - name: Rust Cache
-        uses: Swatinem/rust-cache@v2
-        with:
-          workspaces: src-tauri
-
-      - name: Install Node
-        uses: actions/setup-node@v1
-        with:
-          node-version: 16
-
-      # - name: Install Dependencies (ubuntu18 only)
-      #   if: matrix.targets.os == 'ubuntu-18.04'
-      #   run: |
-      #     sudo apt-get update
-      #     sudo apt-get install -y libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libappindicator3-dev librsvg2-dev libayatana-appindicator3-dev
-
-      - name: Install Dependencies (ubuntu22 only)
-        if: startsWith(matrix.targets.os, 'ubuntu-')
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libgtk-3-dev webkit2gtk-4.0 libappindicator3-dev librsvg2-dev patchelf
-
-      - name: Get yarn cache dir path
-        id: yarn-cache-dir-path
-        run: echo "::set-output name=dir::$(yarn cache dir)"
-
-      - name: Yarn Cache
-        uses: actions/cache@v2
-        id: yarn-cache
-        with:
-          path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
-          key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-yarn-
-
-      - name: Yarn install and check
-        run: |
-          yarn install --network-timeout 1000000
-          yarn run check
-
-      - name: Tauri build
-        uses: tauri-apps/tauri-action@v0
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
-          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
-        with:
-          tagName: ${{ matrix.targets.tag }}
-          releaseName: "Compatible For ${{ matrix.targets.tag }}"
-          releaseBody: "More new features are now supported."
-          releaseDraft: false
-          prerelease: false
-
-      # - name: Portable Bundle
-      #   if: matrix.os == 'windows-latest'
-      #   # rebuild with env settings
-      #   run: |
-      #     yarn build
-      #     yarn run portable
-      #   env:
-      #     GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      #     TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
-      #     TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
-      #     VITE_WIN_PORTABLE: 1

.github/workflows/release.yml

@@ -0,0 +1,258 @@
+name: Release Build
+
+on:
+  workflow_dispatch:
+permissions: write-all
+env:
+  CARGO_INCREMENTAL: 0
+  RUST_BACKTRACE: short
+
+jobs:
+  release:
+    strategy:
+      fail-fast: false
+      matrix:
+        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
+
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      - name: Install Rust Stable
+        uses: dtolnay/rust-toolchain@1.77.0
+
+      - 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: "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_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_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:
+          tagName: v__VERSION__
+          releaseName: "Clash Verge Rev v__VERSION__"
+          releaseBody: "More new features are now supported."
+          tauriScript: pnpm
+          args: --target ${{ matrix.target }}
+
+      - name: Portable Bundle
+        if: matrix.os == 'windows-latest'
+        run: pnpm portable ${{ matrix.target }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  release-for-linux:
+    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
+            target: aarch64-unknown-linux-gnu
+          - os: ubuntu-latest
+            target: armv7-unknown-linux-gnueabihf
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      - name: Build for Linux
+        uses: ./.github/build-for-linux
+        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 }}
+
+      - 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: Upload Release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: v${{env.VERSION}}
+          name: "Clash Verge Rev v${{env.VERSION}}"
+          body: "More new features are now supported."
+          token: ${{ secrets.GITHUB_TOKEN }}
+          files: |
+            src-tauri/target/${{ matrix.target }}/release/bundle/deb/*.deb
+            src-tauri/target/${{ matrix.target }}/release/bundle/rpm/*.rpm
+
+  release-for-fixed-webview2:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - 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
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      - name: Add Rust Target
+        run: rustup target add ${{ matrix.target }}
+
+      - name: Rust Cache
+        uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: src-tauri
+
+      - 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: Download WebView2 Runtime
+        run: |
+          invoke-webrequest -uri https://github.com/westinyang/WebView2RuntimeArchive/releases/download/109.0.1518.78/Microsoft.WebView2.FixedVersionRuntime.109.0.1518.78.${{ matrix.arch }}.cab -outfile Microsoft.WebView2.FixedVersionRuntime.109.0.1518.78.${{ matrix.arch }}.cab
+          Expand .\Microsoft.WebView2.FixedVersionRuntime.109.0.1518.78.${{ matrix.arch }}.cab -F:* ./src-tauri
+          Remove-Item .\src-tauri\tauri.windows.conf.json
+          Rename-Item .\src-tauri\webview2.${{ matrix.arch }}.json tauri.windows.conf.json
+
+      - name: Tauri build
+        id: 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 }}
+        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'
+
+      - name: Upload Release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: v${{steps.build.outputs.appVersion}}
+          name: "Clash Verge Rev v${{steps.build.outputs.appVersion}}"
+          body: "More new features are now supported."
+          token: ${{ secrets.GITHUB_TOKEN }}
+          files: src-tauri/target/${{ matrix.target }}/release/bundle/nsis/*setup*
+
+      - name: Portable Bundle
+        run: pnpm portable-fixed-webview2 ${{ matrix.target }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  release-update:
+    runs-on: ubuntu-latest
+    needs: [release, release-for-linux]
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - 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
+        run: pnpm i
+
+      - name: Release updater file
+        run: pnpm updater
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  release-update-for-fixed-webview2:
+    runs-on: ubuntu-latest
+    needs: [release-for-fixed-webview2]
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - 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
+        run: pnpm i
+
+      - name: Release updater file
+        run: pnpm updater-fixed-webview2
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/test.yml

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

.github/workflows/updater.yml

@@ -1,32 +1,52 @@
 name: Updater CI
 
 on: workflow_dispatch
-
+permissions: write-all
 jobs:
   release-update:
-    runs-on: macos-latest
-    if: startsWith(github.repository, 'zzzgydi')
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
-      - name: Get yarn cache dir path
-        id: yarn-cache-dir-path
-        run: echo "::set-output name=dir::$(yarn cache dir)"
-
-      - name: Yarn Cache
-        uses: actions/cache@v2
-        id: yarn-cache
+      - name: Install Node
+        uses: actions/setup-node@v4
         with:
-          path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
-          key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-yarn-
+          node-version: "20"
 
-      - name: Yarn install
-        run: yarn install
+      - uses: pnpm/action-setup@v4
+        name: Install pnpm
+        with:
+          run_install: false
+
+      - name: Pnpm install
+        run: pnpm i
 
       - name: Release updater file
-        run: yarn run updater
+        run: pnpm updater
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  release-update-for-fixed-webview2:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - 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
+        run: pnpm i
+
+      - name: Release updater file
+        run: pnpm updater-fixed-webview2
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -1,4 +1,5 @@
 node_modules
+.pnpm-store
 .DS_Store
 dist
 dist-ssr
@@ -6,3 +7,4 @@ dist-ssr
 update.json
 scripts/_env.sh
 .vscode
+.tool-versions

.husky/pre-commit

@@ -1,4 +1,4 @@
 #!/bin/sh
 . "$(dirname "$0")/_/husky.sh"
 
-yarn pretty-quick --staged
+pnpm pretty-quick --staged

.tool-versions

@@ -0,0 +1 @@
+nodejs 21.7.1

CONTRIBUTING.md

@@ -0,0 +1,67 @@
+# CONTRIBUTING
+
+Thank you for your interest in contributing to Clash Verge Rev! This document provides guidelines and instructions to help you set up your development environment and start contributing.
+
+## Development Setup
+
+Before you start contributing to the project, you need to set up your development environment. Here are the steps you need to follow:
+
+### Prerequisites
+
+1. **Install Rust and Node.js**: Our project requires both Rust and Node.js. Please follow the instructions provided [here](https://tauri.app/v1/guides/getting-started/prerequisites) to install them on your system.
+
+### Setup for Windows Users
+
+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:
+
+```shell
+pnpm i
+```
+
+### Download the Clash Binary
+
+You have two options for downloading the clash binary:
+
+- Automatically download it via the provided script:
+  ```shell
+  pnpm run check
+  # Use '--force' to force update to the latest version
+  # pnpm run check --force
+  ```
+- Manually download it from the [Clash Meta release](https://github.com/MetaCubeX/Clash.Meta/releases). After downloading, rename the binary according to the [Tauri configuration](https://tauri.app/v1/api/config#bundleconfig.externalbin).
+
+### Run the Development Server
+
+To run the development server, use the following command:
+
+```shell
+pnpm dev
+# If an app instance already exists, use a different command
+pnpm dev:diff
+```
+
+### Build the Project
+
+If you want to build the project, use:
+
+```shell
+pnpm build
+```
+
+## Contributing Your Changes
+
+Once you have made your changes:
+
+1. Fork the repository.
+2. Create a new branch for your feature or bug fix.
+3. Commit your changes with clear and concise commit messages.
+4. Push your branch to your fork and submit a pull request to our repository.
+
+We appreciate your contributions and look forward to your active participation in our project!

README.md

@@ -1,97 +1,82 @@
 <h1 align="center">
-  <img src="./src/assets/image/logo.png" alt="Clash" width="128" />
+  <img src="./src-tauri/icons/icon.png" alt="Clash" width="128" />
   <br>
-  Clash Verge
+  Continuation of <a href="https://github.com/zzzgydi/clash-verge">Clash Verge</a>
   <br>
 </h1>
 
 <h3 align="center">
-A <a href="https://github.com/Dreamacro/clash">Clash</a> GUI based on <a href="https://github.com/tauri-apps/tauri">tauri</a>.
+A Clash Meta GUI based on <a href="https://github.com/tauri-apps/tauri">Tauri</a>.
 </h3>
 
-## Features
+## Preview
 
-- Full `clash` config supported, Partial `clash premium` config supported.
-- Profiles management and enhancement (by yaml and Javascript). [Doc](https://github.com/zzzgydi/clash-verge/wiki/%E4%BD%BF%E7%94%A8%E6%8C%87%E5%8D%97)
-- Simple UI and supports custom theme color.
-- Built-in support [Clash.Meta](https://github.com/MetaCubeX/Clash.Meta) core.
-- System proxy setting and guard.
+| Dark                             | Light                             |
+| -------------------------------- | --------------------------------- |
+| ![预览](./docs/preview_dark.png) | ![预览](./docs/preview_light.png) |
 
 ## Install
 
-Download from [release](https://github.com/zzzgydi/clash-verge/releases). Supports Windows x64, Linux x86_64 and macOS 11+
+请到发布页面下载对应的安装包：[Release page](https://github.com/clash-verge-rev/clash-verge-rev/releases)<br>
+Go to the [release page](https://github.com/clash-verge-rev/clash-verge-rev/releases) to download the corresponding installation package<br>
+Supports Windows (x64/x86), Linux (x64/arm64) and macOS 10.15+ (intel/apple).
 
-Or you can build it yourself. Supports Windows, Linux and macOS 10.15+
+### 安装说明和常见问题，请到[文档页](https://clash-verge-rev.github.io/)查看：[Doc](https://clash-verge-rev.github.io/)
 
-Notes: If you could not start the app on Windows, please check that you have [Webview2](https://developer.microsoft.com/en-us/microsoft-edge/webview2/#download-section) installed.
+---
+
+### TG Group: [@clash_verge_rev](https://t.me/clash_verge_rev)
+
+## Promotion
+
+[狗狗加速 —— 技术流机场 Doggygo VPN](https://狗狗加速.com)
+
+- 高性能海外机场，免费试用，优惠套餐，解锁流媒体，全球首家支持 Hysteria 协议。
+- 使用 Clash Verge 专属邀请链接注册送 3 天，每天 1G 流量免费试用：https://verge.狗狗加速.com/#/register?code=oaxsAGo6
+- Clash Verge 专属 8 折优惠码: verge20 (仅有 500 份)
+- 优惠套餐每月仅需 15.8 元，160G 流量，年付 8 折
+- 海外团队，无跑路风险，高达 50% 返佣
+- 集群负载均衡设计，高速专线(兼容老客户端)，极低延迟，无视晚高峰，4K 秒开
+- 全球首家 Hysteria 协议机场，现已上线更快的 `Hysteria2` 协议(Clash Verge 客户端最佳搭配)
+- 解锁流媒体及 ChatGPT
+- 官网：https://狗狗加速.com
+
+## 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.
+
+### FAQ
+
+Refer to [Doc FAQ Page](https://clash-verge-rev.github.io/faq/windows.html)
 
 ## Development
 
-You should install Rust and Nodejs, see [here](https://tauri.studio/docs/getting-started/prerequisites) for more details. Then install Nodejs packages.
+See [CONTRIBUTING.md](./CONTRIBUTING.md) for more details.
+
+To run the development server, execute the following commands after all prerequisites for **Tauri** are installed:
 
 ```shell
-yarn install
+pnpm i
+pnpm run check
+pnpm dev
 ```
 
-Then download the clash binary... Or you can download it from [clash premium release](https://github.com/Dreamacro/clash/releases/tag/premium) and rename it according to [tauri config](https://tauri.studio/docs/api/config/#tauri.bundle.externalBin).
-
-```shell
-yarn run check
-```
-
-Then run
-
-```shell
-yarn dev
-```
-
-Or you can build it
-
-```shell
-yarn build
-```
-
-## Todos
-
-> This keng is a little big...
-
-## Screenshots
-
-<div align="center">
-  <img src="./docs/demo1.png" alt="demo1" width="32%" />
-  <img src="./docs/demo2.png" alt="demo2" width="32%" />
-  <img src="./docs/demo3.png" alt="demo3" width="32%" />
-  <img src="./docs/demo4.png" alt="demo4" width="32%" />
-  <img src="./docs/demo5.png" alt="demo5" width="32%" />
-  <img src="./docs/demo6.png" alt="demo6" width="32%" />
-</div>
-
-### Custom Theme
-
-<div align="center">
-  <img src="./docs/color1.png" alt="demo1" width="16%" />
-  <img src="./docs/color2.png" alt="demo2" width="16%" />
-  <img src="./docs/color3.png" alt="demo3" width="16%" />
-  <img src="./docs/color4.png" alt="demo4" width="16%" />
-  <img src="./docs/color5.png" alt="demo5" width="16%" />
-  <img src="./docs/color6.png" alt="demo6" width="16%" />
-</div>
-
-## Disclaimer
-
-This is a learning project for Rust practice.
-
 ## Contributions
 
 Issue and PR welcome!
 
 ## Acknowledgement
 
-Clash Verge was based on or inspired by these projects and so on:
+Clash Verge rev was based on or inspired by these projects and so on:
 
+- [zzzgydi/clash-verge](https://github.com/zzzgydi/clash-verge): A Clash GUI based on tauri. Supports Windows, macOS and Linux.
 - [tauri-apps/tauri](https://github.com/tauri-apps/tauri): Build smaller, faster, and more secure desktop applications with a web frontend.
 - [Dreamacro/clash](https://github.com/Dreamacro/clash): A rule-based tunnel in Go.
-- [MetaCubeX/Clash.Meta](https://github.com/MetaCubeX/Clash.Meta): A rule-based tunnel in Go.
+- [MetaCubeX/mihomo](https://github.com/MetaCubeX/mihomo): A rule-based tunnel in Go.
 - [Fndroid/clash_for_windows_pkg](https://github.com/Fndroid/clash_for_windows_pkg): A Windows/macOS GUI based on Clash.
 - [vitejs/vite](https://github.com/vitejs/vite): Next generation frontend tooling. It's fast!
 

UPDATELOG.md

@@ -1,3 +1,804 @@
+## v1.7.2
+
+### Break Changes
+
+- 更新后请务必重新导入所有订阅，包括 Remote 和 Local
+- 此版本重构了 Merge/Script，更新前请先备份好自定义 Merge 和 Script（更新并不会删除配置文件，但是旧版 Merge 和 Script 在更新后无法从前端访问，备份以防万一）
+- Merge 改名为 `扩展配置`，分为 `全局扩展配置` 和 `订阅扩展配置`，全局扩展配置对所有订阅生效，订阅扩展配置只对关联的订阅生效
+- Script 改名为 `扩展脚本`，同样分为 `全局扩展脚本` 和 `订阅扩展脚本`
+- 订阅扩展配置在订阅右键菜单里进入
+- 执行优先级为： 全局扩展配置 -> 全局扩展脚本 -> 订阅扩展配置 ->订阅扩展脚本
+- 扩展配置删除了 `prepend/append` 能力，请使用 右键订阅 -> `编辑规则`/`编辑节点`/`编辑代理组` 来代替
+- MacOS 用户更新后请重新安装服务模式
+
+### Features
+
+- 升级内核到 1.18.6
+- 移除内核授权，改为服务模式实现
+- 自动填充本地订阅名称
+- 添加重大更新处理逻辑
+- 订阅单独指定扩展配置/脚本（需要重新导入订阅）
+- 添加可视化规则编辑器（需要重新导入订阅）
+- 编辑器新增工具栏按钮（格式化、最大化/最小化）
+- WEBUI 使用最新版 metacubex，并解决无法自动登陆问问题
+- 禁用部分 Webview2 快捷键
+- 热键配置新增连接符 + 号
+- 新增部分悬浮提示按钮，用于解释说明
+- 当日志等级为`Debug`时（更改需重启软件生效），支持点击内存主动内存回收（绿色文字）
+- 设置页面右上角新增 TG 频道链接
+- 各种细节优化和界面性能优化
+
+### Bugs Fixes
+
+- 修复代理绕过格式检查
+- 通过进程名称关闭进程
+- 退出软件时恢复 DNS 设置
+- 修复创建本地订阅时更新间隔无法保存
+- 连接页面列宽无法调整
+
+---
+
+## v1.7.1
+
+### Break Changes
+
+- 更新后请务必重新导入所有订阅，包括 Remote 和 Local
+- 此版本重构了 Merge/Script，更新前请先备份好自定义 Merge 和 Script（更新并不会删除配置文件，但是旧版 Merge 和 Script 在更新后无法从前端访问，备份以防万一）
+- Merge 改名为 `扩展配置`，分为 `全局扩展配置` 和 `订阅扩展配置`，全局扩展配置对所有订阅生效，订阅扩展配置只对关联的订阅生效
+- Script 改名为 `扩展脚本`，同样分为 `全局扩展脚本` 和 `订阅扩展脚本`
+- 订阅扩展配置在订阅右键菜单里进入
+- 执行优先级为： 全局扩展配置 -> 全局扩展脚本 -> 订阅扩展配置 ->订阅扩展脚本
+- 扩展配置删除了 `prepend/append` 能力，请使用 右键订阅 -> `编辑规则`/`编辑节点`/`编辑代理组` 来代替
+- MacOS 用户更新后请重新安装服务模式
+
+### Features
+
+- 升级内核到 1.18.6
+- 移除内核授权，改为服务模式实现
+- 自动填充本地订阅名称
+- 添加重大更新处理逻辑
+- 订阅单独指定扩展配置/脚本（需要重新导入订阅）
+- 添加可视化规则编辑器（需要重新导入订阅）
+- 编辑器新增工具栏按钮（格式化、最大化/最小化）
+- WEBUI 使用最新版 metacubex，并解决无法自动登陆问问题
+- 禁用部分 Webview2 快捷键
+- 热键配置新增连接符 + 号
+- 新增部分悬浮提示按钮，用于解释说明
+- 当日志等级为`Debug`时（更改需重启软件生效），支持点击内存主动内存回收（绿色文字）
+- 设置页面右上角新增 TG 频道链接
+- 各种细节优化和界面性能优化
+
+### Bugs Fixes
+
+- 修复代理绕过格式检查
+- 通过进程名称关闭进程
+- 退出软件时恢复 DNS 设置
+- 修复创建本地订阅时更新间隔无法保存
+- 连接页面列宽无法调整
+
+---
+
+## v1.7.0
+
+### Break Changes
+
+- 此版本重构了 Merge/Script，更新前请先备份好自定义 Merge 和 Script（更新并不会删除配置文件，但是旧版 Merge 和 Script 在更新后无法从前端访问，备份以防万一）
+- Merge 改名为 `扩展配置`，分为 `全局扩展配置` 和 `订阅扩展配置`，全局扩展配置对所有订阅生效，订阅扩展配置只对关联的订阅生效
+- Script 改名为 `扩展脚本`，同样分为 `全局扩展脚本` 和 `订阅扩展脚本`
+- 执行优先级为： 全局扩展配置 -> 全局扩展脚本 -> 订阅扩展配置 ->订阅扩展脚本
+- MacOS 用户更新后请重新安装服务模式
+
+### Features
+
+- 移除内核授权，改为服务模式实现
+- 自动填充本地订阅名称
+- 添加重大更新处理逻辑
+- 订阅单独指定扩展配置/脚本（需要重新导入订阅）
+- 添加可视化规则编辑器（需要重新导入订阅）
+- 编辑器新增工具栏按钮（格式化、最大化/最小化）
+- WEBUI 使用最新版 metacubex，并解决无法自动登陆问问题
+- 禁用部分 Webview2 快捷键
+- 热键配置新增连接符 + 号
+- 新增部分悬浮提示按钮，用于解释说明
+- 当日志等级为`Debug`时（更改需重启软件生效），支持点击内存主动内存回收（绿色文字）
+- 设置页面右上角新增 TG 频道链接
+
+### Bugs Fixes
+
+- 修复代理绕过格式检查
+- 通过进程名称关闭进程
+- 退出软件时恢复 DNS 设置
+- 修复创建本地订阅时更新间隔无法保存
+- 连接页面列宽无法调整
+
+---
+
+## v1.6.6
+
+### Features
+
+- MacOS 应用签名
+- 删除 AppImage
+- 应用更新对话框添加下载按钮
+- 设置系统代理绕过时保留默认值
+- 系统代理绕过设置输入格式检查
+
+### Bugs Fixes
+
+- MacOS 代理组图标无法显示
+- RPM 包依赖缺失
+
+---
+
+## v1.6.5
+
+### Features
+
+- 添加 RPM 包支持
+- 优化细节
+
+### Bugs Fixes
+
+- MacOS 10.15 编辑器空白的问题
+- MacOS 低版本启动白屏的问题
+
+---
+
+## v1.6.4
+
+### Features
+
+- 系统代理支持 PAC 模式
+- 允许关闭不使用的端口
+- 使用新的应用图标
+- MacOS 支持切换托盘图标单色/彩色模式
+- CSS 注入支持通过编辑器编辑
+- 优化代理组列表性能
+- 优化流量图显性能
+- 支持波斯语
+
+### Bugs Fixes
+
+- Kill 内核后 Tun 开启缓慢的问题
+- 代理绕过为空时使用默认值
+- 无法读取剪切板内容
+- Windows 下覆盖安装无法内核占用问题
+
+---
+
+## v1.6.2
+
+### Features
+
+- 支持本地文件拖拽导入
+- 重新支持 32 位 CPU
+- 新增内置 Webview2 版本
+- 优化 Merge 逻辑，支持深度合并
+- 删除 Merge 配置中的 append/prepend-provider 字段
+- 支持更新稳定版内核
+
+### Bugs Fixes
+
+- MacOS DNS 还原失败
+- CMD 环境变量格式错误
+- Linux 下与 N 卡的兼容性问题
+- 修改 Tun 设置不立即生效
+
+---
+
+## v1.6.1
+
+### Features
+
+- 鼠标悬浮显示当前订阅的名称 [#938](https://github.com/clash-verge-rev/clash-verge-rev/pull/938)
+- 日志过滤支持正则表达式 [#959](https://github.com/clash-verge-rev/clash-verge-rev/pull/959)
+- 更新 Clash 内核到 1.18.4
+
+### Bugs Fixes
+
+- 修复 Linux KDE 环境下系统代理无法开启的问题
+- 窗口最大化图标调整 [#924](https://github.com/clash-verge-rev/clash-verge-rev/pull/924)
+- 修改 MacOS 托盘点击行为(左键菜单，右键点击事件)
+- 修复 MacOS 服务模式安装失败的问题
+
+---
+
+## v1.6.0
+
+### Features
+
+- Meta(mihomo)内核回退 1.18.1（当前新版内核 hy2 协议有 bug，等修复后更新）
+- 多处界面细节调整 [#724](https://github.com/clash-verge-rev/clash-verge-rev/pull/724) [#799](https://github.com/clash-verge-rev/clash-verge-rev/pull/799) [#900](https://github.com/clash-verge-rev/clash-verge-rev/pull/900) [#901](https://github.com/clash-verge-rev/clash-verge-rev/pull/901)
+- Linux 下新增服务模式
+- 新增订阅卡片右键可以打开机场首页
+- url-test 支持手动选择、节点组 fixed 节点使用角标展示 [#840](https://github.com/clash-verge-rev/clash-verge-rev/pull/840)
+- Clash 配置、Merge 配置提供 JSON Schema 语法支持、连接界面调整 [#887](https://github.com/clash-verge-rev/clash-verge-rev/pull/887)
+- 修改 Merge 配置文件默认内容 [#889](https://github.com/clash-verge-rev/clash-verge-rev/pull/889)
+- 修改 tun 模式默认 mtu 为 1500，老版本升级，需在 tun 模式设置下“重置为默认值”。
+- 使用 npm 安装 meta-json-schema [#895](https://github.com/clash-verge-rev/clash-verge-rev/pull/895)
+- 更新部分翻译 [#904](https://github.com/clash-verge-rev/clash-verge-rev/pull/904)
+- 支持 ico 格式的任务栏图标
+
+### Bugs Fixes
+
+- 修复 Linux KDE 环境下系统代理无法开启的问题
+- 修复延迟检测动画问题
+- 窗口最大化图标调整 [#816](https://github.com/clash-verge-rev/clash-verge-rev/pull/816)
+- 修复 Windows 某些情况下无法安装服务模式 [#822](https://github.com/clash-verge-rev/clash-verge-rev/pull/822)
+- UI 细节修复 [#821](https://github.com/clash-verge-rev/clash-verge-rev/pull/821)
+- 修复使用默认编辑器打开配置文件
+- 修复内核文件在特定目录也可以更新的问题 [#857](https://github.com/clash-verge-rev/clash-verge-rev/pull/857)
+- 修复服务模式的安装目录问题
+- 修复删除配置文件的“更新间隔”出现的问题 [#907](https://github.com/clash-verge-rev/clash-verge-rev/issues/907)
+
+### 已知问题（历史遗留问题，暂未找到有效解决方案）
+
+- MacOS M 芯片下服务模式无法安装；临时解决方案：在内核 ⚙️ 下，手动授权，再打开 tun 模式。
+- MacOS 下如果删除过网络配置，会导致无法正常打开系统代理；临时解决方案：使用浏览器代理插件或手动配置系统代理。
+- Window 拨号连接下无法正确识别并打开系统代理；临时解决方案：使用浏览器代理插件或使用 tun 模式。
+
+---
+
+## v1.5.11
+
+### Features
+
+- Meta(mihomo)内核更新 1.18.2
+
+### Bugs Fixes
+
+- 升级图标无法点击的问题
+- 卸载时检查安装目录是否为空
+- 代理界面图标重合的问题
+
+---
+
+## v1.5.10
+
+### Features
+
+- 优化 Linux 托盘菜单显示
+- 添加透明代理端口设置
+- 删除订阅前确认
+
+### Bugs Fixes
+
+- 删除 MacOS 程序坞图标
+- Windows 下 service 日志没有清理
+- MacOS 无法开启系统代理
+
+---
+
+## v1.5.9
+
+### Features
+
+- 缓存代理组图标
+- 使用`boa_engine` 代替 `rquickjs`
+- 支持 Linux armv7
+
+### Bugs Fixes
+
+- Windows 首次安装无法点击
+- Windows 触摸屏无法拖动
+- 规则列表 `REJECT-DROP` 颜色
+- MacOS Dock 栏不显示图标
+- MacOS 自定义字体无效
+- 避免使用空 UA 拉取订阅
+
+---
+
+## v1.5.8
+
+### Features
+
+- 优化 UI 细节
+- Linux 绘制窗口圆角
+- 开放 DevTools
+
+### Bugs Fixes
+
+- 修复 MacOS 下开启 Tun 内核崩溃的问题
+
+---
+
+## v1.5.7
+
+### Features
+
+- 优化 UI 各种细节
+- 提供菜单栏图标样式切换选项(单色/彩色/禁用)
+- 添加自动检查更新开关
+- MacOS 开启 Tun 模式自动修改 DNS
+- 调整可拖动区域(尝试修复触摸屏无法拖动的问题)
+
+---
+
+## v1.5.6
+
+### Features
+
+- 全新专属 Verge rev UI 界面 (by @Amnesiash) 及细节调整
+- 提供允许无效证书的开关
+- 删除不必要的快捷键
+- Provider 更新添加动画
+- Merge 支持 Provider
+- 更换订阅框的粘贴按钮，删除默认的"Remote File" Profile 名称
+- 链接菜单添加节点显示
+
+### Bugs Fixes
+
+- Linux 下图片显示错误
+
+---
+
+## v1.5.4
+
+### Features
+
+- 支持自定义托盘图标
+- 支持禁用代理组图标
+- 代理组显示当前代理
+- 修改 `打开面板` 快捷键为`打开/关闭面板`
+
+---
+
+## v1.5.3
+
+### Features
+
+- Tun 设置添加重置按钮
+
+### Bugs Fixes
+
+- Tun 设置项显示错误的问题
+- 修改一些默认值
+- 启动时不更改启动项设置
+
+---
+
+## v1.5.2
+
+### Features
+
+- 支持自定义延迟测试超时时间
+- 优化 Tun 相关设置
+
+### Bugs Fixes
+
+- Merge 操作出错
+- 安装后重启服务
+- 修复管理员权限启动时开机启动失效的问题
+
+---
+
+## v1.5.1
+
+### Features
+
+- 保存窗口最大化状态
+- Proxy Provider 显示数量
+- 不再提供 32 位安装包（因为 32 位经常出现各种奇怪问题，比如 tun 模式无法开启；现在系统也几乎没有 32 位了）
+
+### Bugs Fixes
+
+- 优化设置项名称
+- 自定义 GLOBAL 代理组时代理组显示错误的问题
+
+---
+
+## v1.5.0
+
+### Features
+
+- 删除 Clash 字段过滤功能
+- 添加 socks 端口和 http 端口设置
+- 升级内核到 1.18.1
+
+### Bugs Fixes
+
+- 修复 32 位版本无法显示流量信息的问题
+
+---
+
+## v1.4.11
+
+### Break Changes
+
+- 此版本更改了 Windows 安装包安装模式，需要卸载后手动安装，否则无法安装到正确位置
+
+### Features
+
+- 优化了系统代理开启的代码，解决了稀有场景下代理开启卡顿的问题
+- 添加 MacOS 下的 debug 日志，以便日后调试稀有场景下 MacOS 下无法开启系统代理的问题
+- MacOS 关闭 GUI 时同步杀除后台 GUI [#306](https://github.com/clash-verge-rev/clash-verge-rev/issues/306)
+
+### Bugs Fixes
+
+- 解决自动更新时文件占用问题
+- 解决稀有场景下系统代理开启失败的问题
+- 删除冗余内核代码
+
+---
+
+## v1.4.10
+
+### Features
+
+- 设置中添加退出按钮
+- 支持自定义软件启动页
+- 在 Proxy Provider 页面展示订阅信息
+- 优化 Provider 支持
+
+### Bugs Fixes
+
+- 更改端口时立即重设系统代理
+- 网站测试超时错误
+
+---
+
+## v1.4.9
+
+### Features
+
+- 支持启动时运行脚本
+- 支持代理组显示图标
+- 新增测试页面
+
+### Bugs Fixes
+
+- 连接页面时间排序错误
+- 连接页面表格宽度优化
+
+---
+
+## v1.4.8
+
+### Features
+
+- 连接页面总流量显示
+
+### Bugs Fixes
+
+- 连接页面数据排序错误
+- 新建订阅时设置更新间隔无效
+- Windows 拨号网络无法设置系统代理
+- Windows 开启/关闭系统代理延迟(使用注册表即可)
+- 删除无效的背景模糊选项
+
+---
+
+## v1.4.7
+
+### Features
+
+- Windows 便携版禁用应用内更新
+- 支持代理组 Hidden 选项
+- 支持 URL Scheme(MacOS & Linux)
+
+---
+
+## v1.4.6
+
+### Features
+
+- 更新 Clash Meta(mihomo) 内核到 v1.18.0
+- 支持 URL Scheme(暂时仅支持 Windows)
+- 添加窗口置顶按钮
+- UI 优化调整
+
+### Bugs Fixes
+
+- 修复一些编译错误
+- 获取订阅名称错误
+- 订阅信息解析错误
+
+---
+
+## v1.4.5
+
+### Features
+
+- 更新 MacOS 托盘图标样式(@gxx2778 贡献)
+
+### Bugs Fixes
+
+- Windows 下更新时无法覆盖`clash-verge-service.exe`的问题(需要卸载重装一次服务，下次更新生效)
+- 窗口最大化按钮变化问题
+- 窗口尺寸保存错误问题
+- 复制环境变量类型无法切换问题
+- 某些情况下闪退的问题
+- 某些订阅无法导入的问题
+
+---
+
+## v1.4.4
+
+### Features
+
+- 支持 Windows aarch64(arm64) 版本
+- 支持一键更新 GeoData
+- 支持一键更新 Alpha 内核
+- MacOS 支持在系统代理时显示不同的托盘图标
+- Linux 支持在系统代理时显示不同的托盘图标
+- 优化复制环境变量逻辑
+
+### Bugs Fixes
+
+- 修改 PID 文件的路径
+
+### Performance
+
+- 优化创建窗口的速度
+
+---
+
+## v1.4.3
+
+### Break Changes
+
+- 更改配置文件路径到标准目录(可以保证卸载时没有残留)
+- 更改 appid 为 `io.github.clash-verge-rev.clash-verge-rev`
+- 建议卸载旧版本后再安装新版本，该版本安装后不会使用旧版配置文件，你可以手动将旧版配置文件迁移到新版配置文件目录下
+
+### Features
+
+- 移除页面切换动画
+- 更改 Tun 模式托盘图标颜色
+- Portable 版本默认使用当前目录作为配置文件目录
+- 禁用 Clash 字段过滤时隐藏 Clash 字段选项
+- 优化拖拽时光标样式
+
+### Bugs Fixes
+
+- 修复 windows 下更新时没有关闭内核导致的更新失败的问题
+- 修复打开文件报错的问题
+- 修复 url 导入时无法获取中文配置名称的问题
+- 修复 alpha 内核无法显示内存信息的问题
+
+---
+
+## v1.4.2
+
+### Features
+
+- update clash meta core to mihomo 1.17.0
+- support both clash meta stable release and prerelease-alpha release
+- fixed the problem of not being able to set the system proxy when there is a dial-up link on windows system [#833](https://github.com/zzzgydi/clash-verge/issues/833)
+- support new clash field
+- support random mixed port
+- add windows x86 and linux armv7 support
+- support disable tray click event
+- add download progress for updater
+- support drag to reorder the profile
+- embed emoji fonts
+- update depends
+- improve UI style
+
+---
+
+## v1.4.1
+
+### Features
+
+- update clash meta core to newest 虚空终端(2023.11.23)
+- delete clash core UI
+- improve UI
+- change Logo to original
+
+---
+
+## v1.4.0
+
+### Features
+
+- update clash meta core to newest 虚空终端
+- delete clash core, no longer maintain
+- merge Clash nyanpasu changes
+- remove delay display different color
+- use Meta Country.mmdb
+- update dependencies
+- small changes here and there
+
+---
+
+## v1.3.8
+
+### Features
+
+- update clash meta core
+- add default valid keys
+- adjust the delay display interval and color
+
+### Bug Fixes
+
+- fix connections page undefined exception
+
+---
+
+## v1.3.7
+
+### Features
+
+- update clash and clash meta core
+- profiles page add paste button
+- subscriptions url textfield use multi lines
+- set min window size
+- add check for updates buttons
+- add open dashboard to the hotkey list
+
+### Bug Fixes
+
+- fix profiles page undefined exception
+
+---
+
+## v1.3.6
+
+### Features
+
+- add russian translation
+- support to show connection detail
+- support clash meta memory usage display
+- support proxy provider update ui
+- update geo data file from meta repo
+- adjust setting page
+
+### Bug Fixes
+
+- center the window when it is out of screen
+- use `sudo` when `pkexec` not found (Linux)
+- reconnect websocket when window focus
+
+### Notes
+
+- The current version of the Linux installation package is built by Ubuntu 20.04 (Github Action).
+
+---
+
+## v1.3.5
+
+### Features
+
+- update clash core
+
+### Bug Fixes
+
+- fix blurry system tray icon (Windows)
+- fix v1.3.4 wintun.dll not found (Windows)
+- fix v1.3.4 clash core not found (macOS, Linux)
+
+---
+
+## v1.3.4
+
+### Features
+
+- update clash and clash meta core
+- optimize traffic graph high CPU usage when window hidden
+- use polkit to elevate permission (Linux)
+- support app log level setting
+- support copy environment variable
+- overwrite resource file according to file modified
+- save window size and position
+
+### Bug Fixes
+
+- remove fallback group select status
+- enable context menu on editable element (Windows)
+
+---
+
+## v1.3.3
+
+### Features
+
+- update clash and clash meta core
+- show tray icon variants in different system proxy status (Windows)
+- close all connections when mode changed
+
+### Bug Fixes
+
+- encode controller secret into uri
+- error boundary for each page
+
+---
+
+## v1.3.2
+
+### Features
+
+- update clash and clash meta core
+
+### Bug Fixes
+
+- fix import url issue
+- fix profile undefined issue
+
+---
+
+## v1.3.1
+
+### Features
+
+- update clash and clash meta core
+
+### Bug Fixes
+
+- fix open url issue
+- fix appimage path panic
+- fix grant root permission in macOS
+- fix linux system proxy default bypass
+
+---
+
+## v1.3.0
+
+### Features
+
+- update clash and clash meta
+- support opening dir on tray
+- support updating all profiles with one click
+- support granting root permission to clash core(Linux, macOS)
+- support enable/disable clash fields filter, feel free to experience the latest features of Clash Meta
+
+### Bug Fixes
+
+- deb add openssl depend(Linux)
+- fix the AppImage auto launch path(Linux)
+- fix get the default network service(macOS)
+- remove the esc key listener in macOS, cmd+w instead(macOS)
+- fix infinite retry when websocket error
+
+---
+
+## v1.2.3
+
+### Features
+
+- update clash
+- adjust macOS window style
+- profile supports UTF8 with BOM
+
+### Bug Fixes
+
+- fix selected proxy
+- fix error log
+
+---
+
+## v1.2.2
+
+### Features
+
+- update clash meta
+- recover clash core after panic
+- use system window decorations(Linux)
+
+### Bug Fixes
+
+- flush system proxy settings(Windows)
+- fix parse log panic
+- fix ui bug
+
+---
+
+## v1.2.1
+
+### Features
+
+- update clash version
+- proxy groups support multi columns
+- optimize ui
+
+### Bug Fixes
+
+- fix ui websocket connection
+- adjust delay check concurrency
+- avoid setting login item repeatedly(macOS)
+
+---
+
 ## v1.2.0
 
 ### Features

package.json

@@ -1,7 +1,7 @@
 {
   "name": "clash-verge",
-  "version": "1.2.0",
-  "license": "GPL-3.0",
+  "version": "1.7.2",
+  "license": "GPL-3.0-only",
   "scripts": {
     "dev": "tauri dev",
     "dev:diff": "tauri dev -f verge-dev",
@@ -10,62 +10,84 @@
     "web:dev": "vite",
     "web:build": "tsc && vite build",
     "web:serve": "vite preview",
-    "aarch": "node scripts/aarch.mjs",
     "check": "node scripts/check.mjs",
     "updater": "node scripts/updater.mjs",
-    "publish": "node scripts/publish.mjs",
+    "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"
   },
   "dependencies": {
-    "@emotion/react": "^11.10.5",
-    "@emotion/styled": "^11.10.5",
-    "@mui/icons-material": "^5.10.9",
-    "@mui/material": "^5.10.13",
-    "@mui/x-data-grid": "^5.17.11",
-    "@tauri-apps/api": "^1.2.0",
-    "ahooks": "^3.7.2",
-    "axios": "^1.1.3",
+    "@dnd-kit/core": "^6.1.0",
+    "@dnd-kit/sortable": "^8.0.0",
+    "@dnd-kit/utilities": "^3.2.2",
+    "@emotion/react": "^11.11.4",
+    "@emotion/styled": "^11.11.5",
+    "@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",
+    "@types/json-schema": "^7.0.15",
+    "ahooks": "^3.8.0",
+    "axios": "^1.7.2",
     "dayjs": "1.11.5",
-    "i18next": "^22.0.4",
-    "monaco-editor": "^0.34.1",
-    "react": "^17.0.2",
-    "react-dom": "^17.0.2",
+    "foxact": "^0.2.35",
+    "i18next": "^23.11.5",
+    "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",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
     "react-error-boundary": "^3.1.4",
-    "react-i18next": "^12.0.0",
-    "react-router-dom": "^6.4.3",
-    "react-virtuoso": "^3.1.3",
-    "recoil": "^0.7.6",
-    "snarkdown": "^2.0.0",
-    "swr": "^1.3.0"
+    "react-hook-form": "^7.52.1",
+    "react-i18next": "^13.5.0",
+    "react-markdown": "^9.0.1",
+    "react-monaco-editor": "^0.55.0",
+    "react-router-dom": "^6.24.0",
+    "react-transition-group": "^4.4.5",
+    "react-virtuoso": "^4.7.11",
+    "sockette": "^2.0.6",
+    "swr": "^2.2.5",
+    "tar": "^6.2.1",
+    "types-pac": "^1.0.2"
   },
   "devDependencies": {
-    "@actions/github": "^5.0.3",
-    "@tauri-apps/cli": "^1.2.0",
+    "@actions/github": "^5.1.1",
+    "@tauri-apps/cli": "^1.6.0",
     "@types/fs-extra": "^9.0.13",
-    "@types/js-cookie": "^3.0.2",
-    "@types/lodash": "^4.14.180",
-    "@types/react": "^17.0.0",
-    "@types/react-dom": "^17.0.0",
-    "@vitejs/plugin-react": "^2.0.1",
-    "adm-zip": "^0.5.9",
+    "@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",
     "cross-env": "^7.0.3",
-    "fs-extra": "^10.0.0",
+    "fs-extra": "^11.2.0",
     "https-proxy-agent": "^5.0.1",
-    "husky": "^7.0.0",
-    "node-fetch": "^3.2.6",
-    "prettier": "^2.7.1",
-    "pretty-quick": "^3.1.3",
-    "sass": "^1.54.0",
-    "typescript": "^4.7.4",
-    "vite": "^3.0.9",
+    "husky": "^7.0.4",
+    "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",
     "vite-plugin-monaco-editor": "^1.1.0",
-    "vite-plugin-svgr": "^2.2.1"
+    "vite-plugin-svgr": "^4.2.0"
   },
   "prettier": {
     "tabWidth": 2,
     "semi": true,
     "singleQuote": false,
     "endOfLine": "lf"
-  }
+  },
+  "packageManager": "pnpm@9.1.4"
 }

scripts/aarch.mjs

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

scripts/check.mjs

@@ -1,5 +1,6 @@
 import fs from "fs-extra";
 import zlib from "zlib";
+import tar from "tar";
 import path from "path";
 import AdmZip from "adm-zip";
 import fetch from "node-fetch";
@@ -10,59 +11,169 @@ const cwd = process.cwd();
 const TEMP_DIR = path.join(cwd, "node_modules/.verge");
 const FORCE = process.argv.includes("--force");
 
-const SIDECAR_HOST = execSync("rustc -vV")
-  .toString()
-  .match(/(?<=host: ).+(?=\s*)/g)[0];
-
-/* ======= clash ======= */
-const CLASH_URL_PREFIX =
-  "https://github.com/Dreamacro/clash/releases/download/premium/";
-const CLASH_LATEST_DATE = "2022.08.26";
-
-const CLASH_MAP = {
-  "win32-x64": "clash-windows-amd64",
-  "darwin-x64": "clash-darwin-amd64",
-  "darwin-arm64": "clash-darwin-arm64",
-  "linux-x64": "clash-linux-amd64",
-  "linux-arm64": "clash-linux-armv8",
+const PLATFORM_MAP = {
+  "x86_64-pc-windows-msvc": "win32",
+  "i686-pc-windows-msvc": "win32",
+  "aarch64-pc-windows-msvc": "win32",
+  "x86_64-apple-darwin": "darwin",
+  "aarch64-apple-darwin": "darwin",
+  "x86_64-unknown-linux-gnu": "linux",
+  "i686-unknown-linux-gnu": "linux",
+  "aarch64-unknown-linux-gnu": "linux",
+  "armv7-unknown-linux-gnueabihf": "linux",
+  "riscv64gc-unknown-linux-gnu": "linux",
+  "loongarch64-unknown-linux-gnu": "linux",
+};
+const ARCH_MAP = {
+  "x86_64-pc-windows-msvc": "x64",
+  "i686-pc-windows-msvc": "ia32",
+  "aarch64-pc-windows-msvc": "arm64",
+  "x86_64-apple-darwin": "x64",
+  "aarch64-apple-darwin": "arm64",
+  "x86_64-unknown-linux-gnu": "x64",
+  "i686-unknown-linux-gnu": "ia32",
+  "aarch64-unknown-linux-gnu": "arm64",
+  "armv7-unknown-linux-gnueabihf": "arm",
+  "riscv64gc-unknown-linux-gnu": "riscv64",
+  "loongarch64-unknown-linux-gnu": "loong64",
 };
 
-/* ======= clash meta ======= */
-const META_URL_PREFIX = `https://github.com/MetaCubeX/Clash.Meta/releases/download/`;
-const META_VERSION = "v1.13.2";
+const arg1 = process.argv.slice(2)[0];
+const arg2 = process.argv.slice(2)[1];
+const target = arg1 === "--force" ? arg2 : arg1;
+const { platform, arch } = target
+  ? { platform: PLATFORM_MAP[target], arch: ARCH_MAP[target] }
+  : process;
+
+const SIDECAR_HOST = target
+  ? target
+  : execSync("rustc -vV")
+      .toString()
+      .match(/(?<=host: ).+(?=\s*)/g)[0];
+
+/* ======= clash meta alpha======= */
+const META_ALPHA_VERSION_URL =
+  "https://github.com/MetaCubeX/mihomo/releases/download/Prerelease-Alpha/version.txt";
+const META_ALPHA_URL_PREFIX = `https://github.com/MetaCubeX/mihomo/releases/download/Prerelease-Alpha`;
+let META_ALPHA_VERSION;
+
+const META_ALPHA_MAP = {
+  "win32-x64": "mihomo-windows-amd64-compatible",
+  "win32-ia32": "mihomo-windows-386",
+  "win32-arm64": "mihomo-windows-arm64",
+  "darwin-x64": "mihomo-darwin-amd64-compatible",
+  "darwin-arm64": "mihomo-darwin-arm64",
+  "linux-x64": "mihomo-linux-amd64-compatible",
+  "linux-ia32": "mihomo-linux-386",
+  "linux-arm64": "mihomo-linux-arm64",
+  "linux-arm": "mihomo-linux-armv7",
+  "linux-riscv64": "mihomo-linux-riscv64",
+  "linux-loong64": "mihomo-linux-loong64",
+};
+
+// Fetch the latest alpha release version from the version.txt file
+async function getLatestAlphaVersion() {
+  const options = {};
+
+  const httpProxy =
+    process.env.HTTP_PROXY ||
+    process.env.http_proxy ||
+    process.env.HTTPS_PROXY ||
+    process.env.https_proxy;
+
+  if (httpProxy) {
+    options.agent = proxyAgent(httpProxy);
+  }
+  try {
+    const response = await fetch(META_ALPHA_VERSION_URL, {
+      ...options,
+      method: "GET",
+    });
+    let v = await response.text();
+    META_ALPHA_VERSION = v.trim(); // Trim to remove extra whitespaces
+    console.log(`Latest alpha version: ${META_ALPHA_VERSION}`);
+  } catch (error) {
+    console.error("Error fetching latest alpha version:", error.message);
+    process.exit(1);
+  }
+}
+
+/* ======= clash meta stable ======= */
+const META_VERSION_URL =
+  "https://github.com/MetaCubeX/mihomo/releases/latest/download/version.txt";
+const META_URL_PREFIX = `https://github.com/MetaCubeX/mihomo/releases/download`;
+let META_VERSION;
 
 const META_MAP = {
-  "win32-x64": "Clash.Meta-windows-amd64-compatible",
-  "darwin-x64": "Clash.Meta-darwin-amd64",
-  "darwin-arm64": "Clash.Meta-darwin-arm64",
-  "linux-x64": "Clash.Meta-linux-amd64-compatible",
-  "linux-arm64": "Clash.Meta-linux-arm64",
+  "win32-x64": "mihomo-windows-amd64-compatible",
+  "win32-ia32": "mihomo-windows-386",
+  "win32-arm64": "mihomo-windows-arm64",
+  "darwin-x64": "mihomo-darwin-amd64-compatible",
+  "darwin-arm64": "mihomo-darwin-arm64",
+  "linux-x64": "mihomo-linux-amd64-compatible",
+  "linux-ia32": "mihomo-linux-386",
+  "linux-arm64": "mihomo-linux-arm64",
+  "linux-arm": "mihomo-linux-armv7",
+  "linux-riscv64": "mihomo-linux-riscv64",
+  "linux-loong64": "mihomo-linux-loong64",
 };
 
-/**
+// Fetch the latest release version from the version.txt file
+async function getLatestReleaseVersion() {
+  const options = {};
+
+  const httpProxy =
+    process.env.HTTP_PROXY ||
+    process.env.http_proxy ||
+    process.env.HTTPS_PROXY ||
+    process.env.https_proxy;
+
+  if (httpProxy) {
+    options.agent = proxyAgent(httpProxy);
+  }
+  try {
+    const response = await fetch(META_VERSION_URL, {
+      ...options,
+      method: "GET",
+    });
+    let v = await response.text();
+    META_VERSION = v.trim(); // Trim to remove extra whitespaces
+    console.log(`Latest release version: ${META_VERSION}`);
+  } catch (error) {
+    console.error("Error fetching latest release version:", error.message);
+    process.exit(1);
+  }
+}
+
+/*
  * check available
  */
-
-const { platform, arch } = process;
-if (!CLASH_MAP[`${platform}-${arch}`]) {
-  throw new Error(`clash unsupport platform "${platform}-${arch}"`);
-}
 if (!META_MAP[`${platform}-${arch}`]) {
-  throw new Error(`clash meta unsupport platform "${platform}-${arch}"`);
+  throw new Error(
+    `clash meta alpha unsupported platform "${platform}-${arch}"`
+  );
 }
 
-function clash() {
-  const name = CLASH_MAP[`${platform}-${arch}`];
+if (!META_ALPHA_MAP[`${platform}-${arch}`]) {
+  throw new Error(
+    `clash meta alpha unsupported platform "${platform}-${arch}"`
+  );
+}
 
+/**
+ * core info
+ */
+function clashMetaAlpha() {
+  const name = META_ALPHA_MAP[`${platform}-${arch}`];
   const isWin = platform === "win32";
   const urlExt = isWin ? "zip" : "gz";
-  const downloadURL = `${CLASH_URL_PREFIX}${name}-${CLASH_LATEST_DATE}.${urlExt}`;
+  const downloadURL = `${META_ALPHA_URL_PREFIX}/${name}-${META_ALPHA_VERSION}.${urlExt}`;
   const exeFile = `${name}${isWin ? ".exe" : ""}`;
-  const zipFile = `${name}.${urlExt}`;
+  const zipFile = `${name}-${META_ALPHA_VERSION}.${urlExt}`;
 
   return {
-    name: "clash",
-    targetFile: `clash-${SIDECAR_HOST}${isWin ? ".exe" : ""}`,
+    name: "verge-mihomo-alpha",
+    targetFile: `verge-mihomo-alpha-${SIDECAR_HOST}${isWin ? ".exe" : ""}`,
     exeFile,
     zipFile,
     downloadURL,
@@ -73,19 +184,18 @@ function clashMeta() {
   const name = META_MAP[`${platform}-${arch}`];
   const isWin = platform === "win32";
   const urlExt = isWin ? "zip" : "gz";
-  const downloadURL = `${META_URL_PREFIX}${META_VERSION}/${name}-${META_VERSION}.${urlExt}`;
+  const downloadURL = `${META_URL_PREFIX}/${META_VERSION}/${name}-${META_VERSION}.${urlExt}`;
   const exeFile = `${name}${isWin ? ".exe" : ""}`;
   const zipFile = `${name}-${META_VERSION}.${urlExt}`;
 
   return {
-    name: "clash-meta",
-    targetFile: `clash-meta-${SIDECAR_HOST}${isWin ? ".exe" : ""}`,
+    name: "verge-mihomo",
+    targetFile: `verge-mihomo-${SIDECAR_HOST}${isWin ? ".exe" : ""}`,
     exeFile,
     zipFile,
     downloadURL,
   };
 }
-
 /**
  * download sidecar and rename
  */
@@ -103,75 +213,68 @@ async function resolveSidecar(binInfo) {
   const tempExe = path.join(tempDir, exeFile);
 
   await fs.mkdirp(tempDir);
-  if (!(await fs.pathExists(tempZip))) await downloadFile(downloadURL, tempZip);
+  try {
+    if (!(await fs.pathExists(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);
-    });
-    zip.extractAllTo(tempDir, true);
-    await fs.rename(tempExe, sidecarPath);
-    console.log(`[INFO]: ${name} unzip finished`);
-  } else {
-    // gz
-    const readStream = fs.createReadStream(tempZip);
-    const writeStream = fs.createWriteStream(sidecarPath);
-    readStream
-      .pipe(zlib.createGunzip())
-      .pipe(writeStream)
-      .on("finish", () => {
-        console.log(`[INFO]: ${name} gunzip finished`);
-        execSync(`chmod 755 ${sidecarPath}`);
-        console.log(`[INFO]: ${name} chmod binary finished`);
-      })
-      .on("error", (error) => {
-        console.error(`[ERROR]: ${name} gz failed`, error.message);
-        throw error;
+    if (zipFile.endsWith(".zip")) {
+      const zip = new AdmZip(tempZip);
+      zip.getEntries().forEach((entry) => {
+        console.log(`[DEBUG]: "${name}" entry name`, entry.entryName);
       });
+      zip.extractAllTo(tempDir, true);
+      await fs.rename(tempExe, sidecarPath);
+      console.log(`[INFO]: "${name}" unzip finished`);
+    } else if (zipFile.endsWith(".tgz")) {
+      // tgz
+      await fs.mkdirp(tempDir);
+      await tar.extract({
+        cwd: tempDir,
+        file: tempZip,
+        //strip: 1, // 可能需要根据实际的 .tgz 文件结构调整
+      });
+      const files = await fs.readdir(tempDir);
+      console.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}"`);
+        execSync(`chmod 755 ${sidecarPath}`);
+        console.log(`[INFO]: "${name}" chmod binary finished`);
+      } else {
+        throw new Error(`Expected file not found in ${tempDir}`);
+      }
+    } else {
+      // gz
+      const readStream = fs.createReadStream(tempZip);
+      const writeStream = fs.createWriteStream(sidecarPath);
+      await new Promise((resolve, reject) => {
+        const onError = (error) => {
+          console.error(`[ERROR]: "${name}" gz failed:`, error.message);
+          reject(error);
+        };
+        readStream
+          .pipe(zlib.createGunzip().on("error", onError))
+          .pipe(writeStream)
+          .on("finish", () => {
+            console.log(`[INFO]: "${name}" gunzip finished`);
+            execSync(`chmod 755 ${sidecarPath}`);
+            console.log(`[INFO]: "${name}" chmod binary finished`);
+            resolve();
+          })
+          .on("error", onError);
+      });
+    }
+  } catch (err) {
+    // 需要删除文件
+    await fs.remove(sidecarPath);
+    throw err;
+  } finally {
+    // delete temp dir
+    await fs.remove(tempDir);
   }
-
-  // delete temp dir
-  await fs.remove(tempDir);
-}
-
-/**
- * only Windows
- * get the wintun.dll (not required)
- */
-async function resolveWintun() {
-  const { platform } = process;
-
-  if (platform !== "win32") return;
-
-  const url = "https://www.wintun.net/builds/wintun-0.14.1.zip";
-
-  const tempDir = path.join(TEMP_DIR, "wintun");
-  const tempZip = path.join(tempDir, "wintun.zip");
-
-  const wintunPath = path.join(tempDir, "wintun/bin/amd64/wintun.dll");
-  const targetPath = path.join(cwd, "src-tauri/resources", "wintun.dll");
-
-  if (!FORCE && (await fs.pathExists(targetPath))) return;
-
-  await fs.mkdirp(tempDir);
-
-  if (!(await fs.pathExists(tempZip))) {
-    await downloadFile(url, tempZip);
-  }
-
-  // unzip
-  const zip = new AdmZip(tempZip);
-  zip.extractAllTo(tempDir, true);
-
-  if (!(await fs.pathExists(wintunPath))) {
-    throw new Error(`path not found "${wintunPath}"`);
-  }
-
-  await fs.rename(wintunPath, targetPath);
-  await fs.remove(tempDir);
-
-  console.log(`[INFO]: resolve wintun.dll finished`);
 }
 
 /**
@@ -218,66 +321,167 @@ async function downloadFile(url, path) {
   console.log(`[INFO]: download finished "${url}"`);
 }
 
+// SimpleSC.dll
+const resolvePlugin = async () => {
+  const url =
+    "https://nsis.sourceforge.io/mediawiki/images/e/ef/NSIS_Simple_Service_Plugin_Unicode_1.30.zip";
+
+  const tempDir = path.join(TEMP_DIR, "SimpleSC");
+  const tempZip = path.join(
+    tempDir,
+    "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;
+  try {
+    if (!(await fs.pathExists(tempZip))) {
+      await downloadFile(url, tempZip);
+    }
+    const zip = new AdmZip(tempZip);
+    zip.getEntries().forEach((entry) => {
+      console.log(`[DEBUG]: "SimpleSC" entry name`, entry.entryName);
+    });
+    zip.extractAllTo(tempDir, true);
+    await fs.copyFile(tempDll, pluginPath);
+    console.log(`[INFO]: "SimpleSC" unzip finished`);
+  } finally {
+    await fs.remove(tempDir);
+  }
+};
+
+// service chmod
+const resolveServicePermission = async () => {
+  const serviceExecutables = [
+    "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`);
+    }
+  }
+};
+
 /**
  * main
  */
-const SERVICE_URL =
-  "https://github.com/zzzgydi/clash-verge-service/releases/download/latest";
 
-const resolveService = () =>
+const SERVICE_URL = `https://github.com/clash-verge-rev/clash-verge-service/releases/download/${SIDECAR_HOST}`;
+
+const resolveService = () => {
+  let ext = platform === "win32" ? ".exe" : "";
   resolveResource({
-    file: "clash-verge-service.exe",
-    downloadURL: `${SERVICE_URL}/clash-verge-service.exe`,
+    file: "clash-verge-service" + ext,
+    downloadURL: `${SERVICE_URL}/clash-verge-service${ext}`,
   });
-const resolveInstall = () =>
+};
+
+const resolveInstall = () => {
+  let ext = platform === "win32" ? ".exe" : "";
   resolveResource({
-    file: "install-service.exe",
-    downloadURL: `${SERVICE_URL}/install-service.exe`,
+    file: "install-service" + ext,
+    downloadURL: `${SERVICE_URL}/install-service${ext}`,
   });
-const resolveUninstall = () =>
+};
+
+const resolveUninstall = () => {
+  let ext = platform === "win32" ? ".exe" : "";
   resolveResource({
-    file: "uninstall-service.exe",
-    downloadURL: `${SERVICE_URL}/uninstall-service.exe`,
+    file: "uninstall-service" + 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",
-    downloadURL: `https://github.com/Dreamacro/maxmind-geoip/releases/download/20221112/Country.mmdb`,
+    downloadURL: `https://github.com/MetaCubeX/meta-rules-dat/releases/download/latest/country.mmdb`,
   });
 const resolveGeosite = () =>
   resolveResource({
     file: "geosite.dat",
-    downloadURL: `https://github.com/Loyalsoldier/v2ray-rules-dat/releases/latest/download/geosite.dat`,
+    downloadURL: `https://github.com/MetaCubeX/meta-rules-dat/releases/download/latest/geosite.dat`,
   });
 const resolveGeoIP = () =>
   resolveResource({
     file: "geoip.dat",
-    downloadURL: `https://github.com/Loyalsoldier/geoip/releases/latest/download/geoip.dat`,
+    downloadURL: `https://github.com/MetaCubeX/meta-rules-dat/releases/download/latest/geoip.dat`,
+  });
+const resolveEnableLoopback = () =>
+  resolveResource({
+    file: "enableLoopback.exe",
+    downloadURL: `https://github.com/Kuingsmile/uwp-tool/releases/download/latest/enableLoopback.exe`,
   });
 
 const tasks = [
-  { name: "clash", func: () => resolveSidecar(clash()), retry: 5 },
-  { name: "clash-meta", func: () => resolveSidecar(clashMeta()), retry: 5 },
-  { name: "wintun", func: resolveWintun, retry: 5, winOnly: true },
-  { name: "service", func: resolveService, retry: 5, winOnly: true },
-  { name: "install", func: resolveInstall, retry: 5, winOnly: true },
-  { name: "uninstall", func: resolveUninstall, retry: 5, winOnly: true },
+  // { name: "clash", func: resolveClash, retry: 5 },
+  {
+    name: "verge-mihomo-alpha",
+    func: () =>
+      getLatestAlphaVersion().then(() => resolveSidecar(clashMetaAlpha())),
+    retry: 5,
+  },
+  {
+    name: "verge-mihomo",
+    func: () =>
+      getLatestReleaseVersion().then(() => resolveSidecar(clashMeta())),
+    retry: 5,
+  },
+  { name: "plugin", func: resolvePlugin, retry: 5, winOnly: true },
+  { 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 },
+  {
+    name: "enableLoopback",
+    func: resolveEnableLoopback,
+    retry: 5,
+    winOnly: true,
+  },
+  {
+    name: "service_chmod",
+    func: resolveServicePermission,
+    retry: 1,
+    unixOnly: true,
+  },
 ];
 
 async function runTask() {
   const task = tasks.shift();
   if (!task) return;
-  if (task.winOnly && process.platform !== "win32") return runTask();
+  if (task.winOnly && platform !== "win32") return runTask();
+  if (task.linuxOnly && platform !== "linux") return runTask();
+  if (task.unixOnly && platform === "win32") return runTask();
 
   for (let i = 0; i < task.retry; i++) {
     try {
       await task.func();
       break;
     } catch (err) {
-      console.error(`[ERROR]: task::${task.name} try ${i} == `, err.message);
+      console.error(`[ERROR]: task::${task.name} try ${i} ==`, err.message);
+      if (i === task.retry - 1) throw err;
     }
   }
   return runTask();

scripts/portable-fixed-webview2.mjs

@@ -0,0 +1,100 @@
+import fs from "fs-extra";
+import path from "path";
+import AdmZip from "adm-zip";
+import { createRequire } from "module";
+import { getOctokit, context } from "@actions/github";
+
+const target = process.argv.slice(2)[0];
+const alpha = process.argv.slice(2)[1];
+
+const ARCH_MAP = {
+  "x86_64-pc-windows-msvc": "x64",
+  "i686-pc-windows-msvc": "x86",
+  "aarch64-pc-windows-msvc": "arm64",
+};
+
+const PROCESS_MAP = {
+  x64: "x64",
+  ia32: "x86",
+  arm64: "arm64",
+};
+const arch = target ? ARCH_MAP[target] : PROCESS_MAP[process.arch];
+/// Script for ci
+/// 打包绿色版/便携版 (only Windows)
+async function resolvePortable() {
+  if (process.platform !== "win32") return;
+
+  const releaseDir = target
+    ? `./src-tauri/target/${target}/release`
+    : `./src-tauri/target/release`;
+
+  const configDir = path.join(releaseDir, ".config");
+
+  if (!(await fs.pathExists(releaseDir))) {
+    throw new Error("could not found the release dir");
+  }
+
+  await fs.mkdir(configDir);
+  await fs.createFile(path.join(configDir, "PORTABLE"));
+
+  const zip = new AdmZip();
+
+  zip.addLocalFile(path.join(releaseDir, "Clash Verge.exe"));
+  zip.addLocalFile(path.join(releaseDir, "verge-mihomo.exe"));
+  zip.addLocalFile(path.join(releaseDir, "verge-mihomo-alpha.exe"));
+  zip.addLocalFolder(path.join(releaseDir, "resources"), "resources");
+  zip.addLocalFolder(
+    path.join(
+      releaseDir,
+      `Microsoft.WebView2.FixedVersionRuntime.109.0.1518.78.${arch}`
+    ),
+    `Microsoft.WebView2.FixedVersionRuntime.109.0.1518.78.${arch}`
+  );
+  zip.addLocalFolder(configDir, ".config");
+
+  const require = createRequire(import.meta.url);
+  const packageJson = require("../package.json");
+  const { version } = packageJson;
+
+  const zipFile = `Clash.Verge_${version}_${arch}_fixed_webview2_portable.zip`;
+  zip.writeZip(zipFile);
+
+  console.log("[INFO]: create portable zip successfully");
+
+  // push release assets
+  if (process.env.GITHUB_TOKEN === undefined) {
+    throw new Error("GITHUB_TOKEN is required");
+  }
+
+  const options = { owner: context.repo.owner, repo: context.repo.repo };
+  const github = getOctokit(process.env.GITHUB_TOKEN);
+  const tag = alpha ? "alpha" : process.env.TAG_NAME || `v${version}`;
+  console.log("[INFO]: upload to ", tag);
+
+  const { data: release } = await github.rest.repos.getReleaseByTag({
+    ...options,
+    tag,
+  });
+
+  let assets = release.assets.filter((x) => {
+    return x.name === zipFile;
+  });
+  if (assets.length > 0) {
+    let id = assets[0].id;
+    await github.rest.repos.deleteReleaseAsset({
+      ...options,
+      asset_id: id,
+    });
+  }
+
+  console.log(release.name);
+
+  await github.rest.repos.uploadReleaseAsset({
+    ...options,
+    release_id: release.id,
+    name: zipFile,
+    data: zip.toBuffer(),
+  });
+}
+
+resolvePortable().catch(console.error);

scripts/portable.mjs

@@ -4,29 +4,51 @@ import AdmZip from "adm-zip";
 import { createRequire } from "module";
 import { getOctokit, context } from "@actions/github";
 
+const target = process.argv.slice(2)[0];
+const alpha = process.argv.slice(2)[1];
+
+const ARCH_MAP = {
+  "x86_64-pc-windows-msvc": "x64",
+  "i686-pc-windows-msvc": "x86",
+  "aarch64-pc-windows-msvc": "arm64",
+};
+
+const PROCESS_MAP = {
+  x64: "x64",
+  ia32: "x86",
+  arm64: "arm64",
+};
+const arch = target ? ARCH_MAP[target] : PROCESS_MAP[process.arch];
 /// Script for ci
 /// 打包绿色版/便携版 (only Windows)
 async function resolvePortable() {
   if (process.platform !== "win32") return;
 
-  const releaseDir = "./src-tauri/target/release";
+  const releaseDir = target
+    ? `./src-tauri/target/${target}/release`
+    : `./src-tauri/target/release`;
+  const configDir = path.join(releaseDir, ".config");
 
   if (!(await fs.pathExists(releaseDir))) {
     throw new Error("could not found the release dir");
   }
 
+  await fs.mkdir(configDir);
+  await fs.createFile(path.join(configDir, "PORTABLE"));
+
   const zip = new AdmZip();
 
   zip.addLocalFile(path.join(releaseDir, "Clash Verge.exe"));
-  zip.addLocalFile(path.join(releaseDir, "clash.exe"));
-  zip.addLocalFile(path.join(releaseDir, "clash-meta.exe"));
+  zip.addLocalFile(path.join(releaseDir, "verge-mihomo.exe"));
+  zip.addLocalFile(path.join(releaseDir, "verge-mihomo-alpha.exe"));
   zip.addLocalFolder(path.join(releaseDir, "resources"), "resources");
+  zip.addLocalFolder(configDir, ".config");
 
   const require = createRequire(import.meta.url);
   const packageJson = require("../package.json");
   const { version } = packageJson;
 
-  const zipFile = `Clash.Verge_${version}_x64_portable.zip`;
+  const zipFile = `Clash.Verge_${version}_${arch}_portable.zip`;
   zip.writeZip(zipFile);
 
   console.log("[INFO]: create portable zip successfully");
@@ -38,14 +60,25 @@ async function resolvePortable() {
 
   const options = { owner: context.repo.owner, repo: context.repo.repo };
   const github = getOctokit(process.env.GITHUB_TOKEN);
-
-  console.log("[INFO]: upload to ", process.env.TAG_NAME || `v${version}`);
+  const tag = alpha ? "alpha" : process.env.TAG_NAME || `v${version}`;
+  console.log("[INFO]: upload to ", tag);
 
   const { data: release } = await github.rest.repos.getReleaseByTag({
     ...options,
-    tag: process.env.TAG_NAME || `v${version}`,
+    tag,
   });
 
+  let assets = release.assets.filter((x) => {
+    return x.name === zipFile;
+  });
+  if (assets.length > 0) {
+    let id = assets[0].id;
+    await github.rest.repos.deleteReleaseAsset({
+      ...options,
+      asset_id: id,
+    });
+  }
+
   console.log(release.name);
 
   await github.rest.repos.uploadReleaseAsset({

scripts/publish.mjs

@@ -1,53 +0,0 @@
-import fs from "fs-extra";
-import { createRequire } from "module";
-import { execSync } from "child_process";
-import { resolveUpdateLog } from "./updatelog.mjs";
-
-const require = createRequire(import.meta.url);
-
-// publish
-async function resolvePublish() {
-  const flag = process.argv[2] ?? "patch";
-  const packageJson = require("../package.json");
-  const tauriJson = require("../src-tauri/tauri.conf.json");
-
-  let [a, b, c] = packageJson.version.split(".").map(Number);
-
-  if (flag === "major") {
-    a += 1;
-    b = 0;
-    c = 0;
-  } else if (flag === "minor") {
-    b += 1;
-    c = 0;
-  } else if (flag === "patch") {
-    c += 1;
-  } else throw new Error(`invalid flag "${flag}"`);
-
-  const nextVersion = `${a}.${b}.${c}`;
-  packageJson.version = nextVersion;
-  tauriJson.package.version = nextVersion;
-
-  // 发布更新前先写更新日志
-  const nextTag = `v${nextVersion}`;
-  await resolveUpdateLog(nextTag);
-
-  await fs.writeFile(
-    "./package.json",
-    JSON.stringify(packageJson, undefined, 2)
-  );
-  await fs.writeFile(
-    "./src-tauri/tauri.conf.json",
-    JSON.stringify(tauriJson, undefined, 2)
-  );
-
-  execSync("git add ./package.json");
-  execSync("git add ./src-tauri/tauri.conf.json");
-  execSync(`git commit -m "v${nextVersion}"`);
-  execSync(`git tag -a v${nextVersion} -m "v${nextVersion}"`);
-  execSync(`git push`);
-  execSync(`git push origin v${nextVersion}`);
-  console.log(`Publish Successfully...`);
-}
-
-resolvePublish();

scripts/updater-fixed-webview2.mjs

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

scripts/updater.mjs

@@ -43,9 +43,16 @@ async function resolveUpdater() {
       darwin: { signature: "", url: "" }, // compatible with older formats
       "darwin-aarch64": { signature: "", url: "" },
       "darwin-intel": { signature: "", url: "" },
+      "darwin-x86_64": { signature: "", url: "" },
       "linux-x86_64": { signature: "", url: "" },
+      "linux-x86": { signature: "", url: "" },
+      "linux-i686": { signature: "", url: "" },
+      "linux-aarch64": { signature: "", url: "" },
+      "linux-armv7": { signature: "", url: "" },
       "windows-x86_64": { signature: "", url: "" },
-      "windows-i686": { signature: "", url: "" }, // no supported
+      "windows-aarch64": { signature: "", url: "" },
+      "windows-x86": { signature: "", url: "" },
+      "windows-i686": { signature: "", url: "" },
     },
   };
 
@@ -53,49 +60,74 @@ async function resolveUpdater() {
     const { name, browser_download_url } = asset;
 
     // win64 url
-    if (name.endsWith(".msi.zip") && name.includes("en-US")) {
+    if (name.endsWith("x64-setup.nsis.zip")) {
       updateData.platforms.win64.url = browser_download_url;
       updateData.platforms["windows-x86_64"].url = browser_download_url;
     }
     // win64 signature
-    if (name.endsWith(".msi.zip.sig") && name.includes("en-US")) {
+    if (name.endsWith("x64-setup.nsis.zip.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")) {
+      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")) {
+      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")) {
+      updateData.platforms["windows-aarch64"].url = browser_download_url;
+    }
+    // win arm signature
+    if (name.endsWith("arm64-setup.nsis.zip.sig")) {
+      const sig = await getSignature(browser_download_url);
+      updateData.platforms["windows-aarch64"].signature = sig;
+    }
+
     // darwin url (intel)
     if (name.endsWith(".app.tar.gz") && !name.includes("aarch")) {
       updateData.platforms.darwin.url = browser_download_url;
       updateData.platforms["darwin-intel"].url = browser_download_url;
+      updateData.platforms["darwin-x86_64"].url = browser_download_url;
     }
     // darwin signature (intel)
     if (name.endsWith(".app.tar.gz.sig") && !name.includes("aarch")) {
       const sig = await getSignature(browser_download_url);
       updateData.platforms.darwin.signature = sig;
       updateData.platforms["darwin-intel"].signature = sig;
+      updateData.platforms["darwin-x86_64"].signature = sig;
     }
 
     // darwin url (aarch)
     if (name.endsWith("aarch64.app.tar.gz")) {
       updateData.platforms["darwin-aarch64"].url = browser_download_url;
+      // 使linux可以检查更新
+      updateData.platforms.linux.url = browser_download_url;
+      updateData.platforms["linux-x86_64"].url = browser_download_url;
+      updateData.platforms["linux-x86"].url = browser_download_url;
+      updateData.platforms["linux-i686"].url = browser_download_url;
+      updateData.platforms["linux-aarch64"].url = browser_download_url;
+      updateData.platforms["linux-armv7"].url = browser_download_url;
     }
     // darwin signature (aarch)
     if (name.endsWith("aarch64.app.tar.gz.sig")) {
       const sig = await getSignature(browser_download_url);
       updateData.platforms["darwin-aarch64"].signature = sig;
-    }
-
-    // linux url
-    if (name.endsWith(".AppImage.tar.gz")) {
-      updateData.platforms.linux.url = browser_download_url;
-      updateData.platforms["linux-x86_64"].url = browser_download_url;
-    }
-    // linux signature
-    if (name.endsWith(".AppImage.tar.gz.sig")) {
-      const sig = await getSignature(browser_download_url);
       updateData.platforms.linux.signature = sig;
       updateData.platforms["linux-x86_64"].signature = sig;
+      updateData.platforms["linux-x86"].url = browser_download_url;
+      updateData.platforms["linux-i686"].url = browser_download_url;
+      updateData.platforms["linux-aarch64"].signature = sig;
+      updateData.platforms["linux-armv7"].signature = sig;
     }
   });
 
@@ -117,10 +149,8 @@ async function resolveUpdater() {
 
   Object.entries(updateDataNew.platforms).forEach(([key, value]) => {
     if (value.url) {
-      updateDataNew.platforms[key].url = value.url.replace(
-        "https://github.com/",
-        "https://hub.fastgit.xyz/"
-      );
+      updateDataNew.platforms[key].url =
+        "https://mirror.ghproxy.com/" + value.url;
     } else {
       console.log(`[Error]: updateDataNew.platforms.${key} is null`);
     }

src-tauri/Cargo.toml

@@ -1,58 +1,56 @@
 [package]
 name = "clash-verge"
-version = "0.1.0"
+version = "1.7.2"
 description = "clash verge"
-authors = ["zzzgydi"]
-license = "GPL-3.0"
-repository = "https://github.com/zzzgydi/clash-verge.git"
+authors = ["zzzgydi", "wonfen", "MystiPanda"]
+license = "GPL-3.0-only"
+repository = "https://github.com/clash-verge-rev/clash-verge-rev.git"
 default-run = "clash-verge"
 edition = "2021"
 build = "build.rs"
 
 [build-dependencies]
-tauri-build = { version = "1", features = [] }
+tauri-build = { version="1", features = [] }
 
 [dependencies]
 warp = "0.3"
-which = "4.2.2"
 anyhow = "1.0"
-dirs = "4.0.0"
-open = "3.0.3"
-log = "0.4.14"
-ctrlc = "3.2.3"
-dunce = "1.0.2"
-log4rs = "1.0.0"
-nanoid = "0.4.0"
-chrono = "0.4.19"
-sysinfo = "0.26.2"
-sysproxy = "0.1"
-rquickjs = "0.1.7"
+dirs = "5.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"
 serde_json = "1.0"
 serde_yaml = "0.9"
-auto-launch = "0.4"
-once_cell = "1.14.0"
+once_cell = "1.19"
 port_scanner = "0.1.5"
-delay_timer = "0.11.1"
-parking_lot = "0.12.0"
+delay_timer = "0.11"
+parking_lot = "0.12"
+auto-launch = "0.5.0"
+percent-encoding = "2.3.1"
+window-shadows = { version = "0.2" }
 tokio = { version = "1", features = ["full"] }
 serde = { version = "1.0", features = ["derive"] }
-reqwest = { version = "0.11", features = ["json"] }
-tauri = { version = "1.1.1", features = ["global-shortcut-all", "process-all", "shell-all", "system-tray", "updater", "window-all"] }
-tauri-runtime-wry = { version = "0.12" }
-window-vibrancy = { version = "0.3.0" }
-window-shadows = { version = "0.2.0" }
-
+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"] }
 [target.'cfg(windows)'.dependencies]
-runas = "0.2.1"
+runas = "=1.2.0"
 deelevate = "0.2.0"
-winreg = { version = "0.10", features = ["transactions"] }
-windows-sys = { version = "0.36", features = ["Win32_System_LibraryLoader", "Win32_System_SystemInformation"] }
+winreg = "0.52.0"
+
+[target.'cfg(target_os = "linux")'.dependencies]
+users = "0.11.0"
+#openssl
 
 [features]
 default = ["custom-protocol"]
 custom-protocol = ["tauri/custom-protocol"]
 verge-dev = []
-debug-yml = []
 
 [profile.release]
 panic = "abort"

src-tauri/Info.plist

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

src-tauri/src/cmds.rs

@@ -2,14 +2,14 @@ use crate::{
     config::*,
     core::*,
     feat,
-    utils::{dirs, help},
+    utils::{dirs, help, resolve},
 };
 use crate::{ret_err, wrap_err};
 use anyhow::{Context, Result};
 use serde_yaml::Mapping;
 use std::collections::{HashMap, VecDeque};
-use sysproxy::Sysproxy;
-
+use sysproxy::{Autoproxy, Sysproxy};
+use tauri::{api, Manager};
 type CmdResult<T = ()> = Result<T, String>;
 
 #[tauri::command]
@@ -30,6 +30,11 @@ pub async fn import_profile(url: String, option: Option<PrfOption>) -> CmdResult
     wrap_err!(Config::profiles().data().append_item(item))
 }
 
+#[tauri::command]
+pub async fn reorder_profile(active_id: String, over_id: String) -> CmdResult {
+    wrap_err!(Config::profiles().data().reorder(active_id, over_id))
+}
+
 #[tauri::command]
 pub async fn create_profile(item: PrfItem, file_data: Option<String>) -> CmdResult {
     let item = wrap_err!(PrfItem::from(item, file_data).await)?;
@@ -60,6 +65,7 @@ pub async fn patch_profiles_config(profiles: IProfiles) -> CmdResult {
     match CoreManager::global().update_config().await {
         Ok(_) => {
             handle::Handle::refresh_clash();
+            let _ = handle::Handle::update_systray_part();
             Config::profiles().apply();
             wrap_err!(Config::profiles().data().save_file())?;
             Ok(())
@@ -80,7 +86,7 @@ pub fn patch_profile(index: String, profile: PrfItem) -> CmdResult {
 }
 
 #[tauri::command]
-pub fn view_profile(index: String) -> CmdResult {
+pub fn view_profile(app_handle: tauri::AppHandle, index: String) -> CmdResult {
     let file = {
         wrap_err!(Config::profiles().latest().get_item(&index))?
             .file
@@ -93,7 +99,7 @@ pub fn view_profile(index: String) -> CmdResult {
         ret_err!("the file not found");
     }
 
-    wrap_err!(help::open_file(path))
+    wrap_err!(help::open_file(app_handle, path))
 }
 
 #[tauri::command]
@@ -179,7 +185,6 @@ pub async fn restart_sidecar() -> CmdResult {
 #[tauri::command]
 pub fn get_sys_proxy() -> CmdResult<Mapping> {
     let current = wrap_err!(Sysproxy::get_system_proxy())?;
-
     let mut map = Mapping::new();
     map.insert("enable".into(), current.enable.into());
     map.insert(
@@ -191,6 +196,18 @@ pub fn get_sys_proxy() -> CmdResult<Mapping> {
     Ok(map)
 }
 
+/// get the system proxy
+#[tauri::command]
+pub fn get_auto_proxy() -> CmdResult<Mapping> {
+    let current = wrap_err!(Autoproxy::get_auto_proxy())?;
+
+    let mut map = Mapping::new();
+    map.insert("enable".into(), current.enable.into());
+    map.insert("url".into(), current.url.into());
+
+    Ok(map)
+}
+
 #[tauri::command]
 pub fn get_clash_logs() -> CmdResult<VecDeque<String>> {
     Ok(logger::Logger::global().get_log())
@@ -202,6 +219,13 @@ pub fn open_app_dir() -> CmdResult<()> {
     wrap_err!(open::that(app_dir))
 }
 
+#[tauri::command]
+pub fn open_core_dir() -> CmdResult<()> {
+    let core_dir = wrap_err!(tauri::utils::platform::current_exe())?;
+    let core_dir = core_dir.parent().ok_or("failed to get core dir")?;
+    wrap_err!(open::that(core_dir))
+}
+
 #[tauri::command]
 pub fn open_logs_dir() -> CmdResult<()> {
     let log_dir = wrap_err!(dirs::app_logs_dir())?;
@@ -214,40 +238,136 @@ pub fn open_web_url(url: String) -> CmdResult<()> {
 }
 
 #[cfg(windows)]
-pub mod service {
+pub mod uwp {
     use super::*;
-    use crate::core::win_service;
+    use crate::core::win_uwp;
 
     #[tauri::command]
-    pub async fn check_service() -> CmdResult<win_service::JsonResponse> {
-        wrap_err!(win_service::check_service().await)
+    pub async fn invoke_uwp_tool() -> CmdResult {
+        wrap_err!(win_uwp::invoke_uwptools().await)
+    }
+}
+
+#[tauri::command]
+pub async fn clash_api_get_proxy_delay(
+    name: String,
+    url: Option<String>,
+    timeout: i32,
+) -> CmdResult<clash_api::DelayRes> {
+    match clash_api::get_proxy_delay(name, url, timeout).await {
+        Ok(res) => Ok(res),
+        Err(err) => Err(err.to_string()),
+    }
+}
+
+#[tauri::command]
+pub fn get_portable_flag() -> CmdResult<bool> {
+    Ok(*dirs::PORTABLE_FLAG.get().unwrap_or(&false))
+}
+
+#[tauri::command]
+pub async fn test_delay(url: String) -> CmdResult<u32> {
+    Ok(feat::test_delay(url).await.unwrap_or(10000u32))
+}
+
+#[tauri::command]
+pub fn get_app_dir() -> CmdResult<String> {
+    let app_home_dir = wrap_err!(dirs::app_home_dir())?
+        .to_string_lossy()
+        .to_string();
+    Ok(app_home_dir)
+}
+
+#[tauri::command]
+pub async fn download_icon_cache(url: String, name: String) -> CmdResult<String> {
+    let icon_cache_dir = wrap_err!(dirs::app_home_dir())?.join("icons").join("cache");
+    let icon_path = icon_cache_dir.join(name);
+    if !icon_cache_dir.exists() {
+        let _ = std::fs::create_dir_all(&icon_cache_dir);
+    }
+    if !icon_path.exists() {
+        let response = wrap_err!(reqwest::get(url).await)?;
+
+        let mut file = wrap_err!(std::fs::File::create(&icon_path))?;
+
+        let content = wrap_err!(response.bytes().await)?;
+        wrap_err!(std::io::copy(&mut content.as_ref(), &mut file))?;
+    }
+    Ok(icon_path.to_string_lossy().to_string())
+}
+#[tauri::command]
+pub fn copy_icon_file(path: String, name: String) -> CmdResult<String> {
+    let file_path = std::path::Path::new(&path);
+    let icon_dir = wrap_err!(dirs::app_home_dir())?.join("icons");
+    if !icon_dir.exists() {
+        let _ = std::fs::create_dir_all(&icon_dir);
+    }
+    let ext = match file_path.extension() {
+        Some(e) => e.to_string_lossy().to_string(),
+        None => "ico".to_string(),
+    };
+
+    let png_dest_path = icon_dir.join(format!("{name}.png"));
+    let ico_dest_path = icon_dir.join(format!("{name}.ico"));
+    let dest_path = icon_dir.join(format!("{name}.{ext}"));
+    if file_path.exists() {
+        std::fs::remove_file(png_dest_path).unwrap_or_default();
+        std::fs::remove_file(ico_dest_path).unwrap_or_default();
+        match std::fs::copy(file_path, &dest_path) {
+            Ok(_) => Ok(dest_path.to_string_lossy().to_string()),
+            Err(err) => Err(err.to_string()),
+        }
+    } else {
+        Err("file not found".to_string())
+    }
+}
+
+#[tauri::command]
+pub fn open_devtools(app_handle: tauri::AppHandle) {
+    if let Some(window) = app_handle.get_window("main") {
+        if !window.is_devtools_open() {
+            window.open_devtools();
+        } else {
+            window.close_devtools();
+        }
+    }
+}
+
+#[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 mod service {
+    use super::*;
+    use crate::core::service;
+
+    #[tauri::command]
+    pub async fn check_service() -> CmdResult<service::JsonResponse> {
+        wrap_err!(service::check_service().await)
     }
 
     #[tauri::command]
     pub async fn install_service() -> CmdResult {
-        wrap_err!(win_service::install_service().await)
+        wrap_err!(service::install_service().await)
     }
 
     #[tauri::command]
     pub async fn uninstall_service() -> CmdResult {
-        wrap_err!(win_service::uninstall_service().await)
+        wrap_err!(service::uninstall_service().await)
     }
 }
 
 #[cfg(not(windows))]
-pub mod service {
+pub mod uwp {
     use super::*;
 
     #[tauri::command]
-    pub async fn check_service() -> CmdResult {
-        Ok(())
-    }
-    #[tauri::command]
-    pub async fn install_service() -> CmdResult {
-        Ok(())
-    }
-    #[tauri::command]
-    pub async fn uninstall_service() -> CmdResult {
+    pub async fn invoke_uwp_tool() -> CmdResult {
         Ok(())
     }
 }

src-tauri/src/config/clash.rs

@@ -12,33 +12,66 @@ pub struct IClashTemp(pub Mapping);
 
 impl IClashTemp {
     pub fn new() -> Self {
-        match dirs::clash_path().and_then(|path| help::read_merge_mapping(&path)) {
-            Ok(map) => Self(Self::guard(map)),
+        let template = Self::template();
+        match dirs::clash_path().and_then(|path| help::read_mapping(&path)) {
+            Ok(mut map) => {
+                template.0.keys().for_each(|key| {
+                    if !map.contains_key(key) {
+                        map.insert(key.clone(), template.0.get(key).unwrap().clone());
+                    }
+                });
+                Self(Self::guard(map))
+            }
             Err(err) => {
                 log::error!(target: "app", "{err}");
-                Self::template()
+                template
             }
         }
     }
 
     pub fn template() -> Self {
         let mut map = Mapping::new();
-
-        map.insert("mixed-port".into(), 7890.into());
+        let mut tun = Mapping::new();
+        tun.insert("stack".into(), "gvisor".into());
+        tun.insert("device".into(), "Mihomo".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")]
+        map.insert("tproxy-port".into(), 7896.into());
+        map.insert("mixed-port".into(), 7897.into());
+        map.insert("socks-port".into(), 7898.into());
+        map.insert("port".into(), 7899.into());
         map.insert("log-level".into(), "info".into());
         map.insert("allow-lan".into(), false.into());
         map.insert("mode".into(), "rule".into());
-        map.insert("external-controller".into(), "127.0.0.1:9090".into());
+        map.insert("external-controller".into(), "127.0.0.1:9097".into());
         map.insert("secret".into(), "".into());
+        map.insert("tun".into(), tun.into());
 
         Self(map)
     }
 
     fn guard(mut config: Mapping) -> Mapping {
-        let port = Self::guard_mixed_port(&config);
+        #[cfg(not(target_os = "windows"))]
+        let redir_port = Self::guard_redir_port(&config);
+        #[cfg(target_os = "linux")]
+        let tproxy_port = Self::guard_tproxy_port(&config);
+        let mixed_port = Self::guard_mixed_port(&config);
+        let socks_port = Self::guard_socks_port(&config);
+        let port = Self::guard_port(&config);
         let ctrl = Self::guard_server_ctrl(&config);
-
-        config.insert("mixed-port".into(), port.into());
+        #[cfg(not(target_os = "windows"))]
+        config.insert("redir-port".into(), redir_port.into());
+        #[cfg(target_os = "linux")]
+        config.insert("tproxy-port".into(), tproxy_port.into());
+        config.insert("mixed-port".into(), mixed_port.into());
+        config.insert("socks-port".into(), socks_port.into());
+        config.insert("port".into(), port.into());
         config.insert("external-controller".into(), ctrl.into());
         config
     }
@@ -61,12 +94,24 @@ impl IClashTemp {
         Self::guard_mixed_port(&self.0)
     }
 
+    #[allow(unused)]
+    pub fn get_socks_port(&self) -> u16 {
+        Self::guard_socks_port(&self.0)
+    }
+
+    #[allow(unused)]
+    pub fn get_port(&self) -> u16 {
+        Self::guard_port(&self.0)
+    }
+
     pub fn get_client_info(&self) -> ClashInfo {
         let config = &self.0;
 
         ClashInfo {
-            port: Self::guard_mixed_port(&config),
-            server: Self::guard_client_ctrl(&config),
+            mixed_port: Self::guard_mixed_port(config),
+            socks_port: Self::guard_socks_port(config),
+            port: Self::guard_port(config),
+            server: Self::guard_client_ctrl(config),
             secret: config.get("secret").and_then(|value| match value {
                 Value::String(val_str) => Some(val_str.clone()),
                 Value::Bool(val_bool) => Some(val_bool.to_string()),
@@ -75,6 +120,37 @@ impl IClashTemp {
             }),
         }
     }
+    #[cfg(not(target_os = "windows"))]
+    pub fn guard_redir_port(config: &Mapping) -> u16 {
+        let mut port = config
+            .get("redir-port")
+            .and_then(|value| match value {
+                Value::String(val_str) => val_str.parse().ok(),
+                Value::Number(val_num) => val_num.as_u64().map(|u| u as u16),
+                _ => None,
+            })
+            .unwrap_or(7895);
+        if port == 0 {
+            port = 7895;
+        }
+        port
+    }
+
+    #[cfg(target_os = "linux")]
+    pub fn guard_tproxy_port(config: &Mapping) -> u16 {
+        let mut port = config
+            .get("tproxy-port")
+            .and_then(|value| match value {
+                Value::String(val_str) => val_str.parse().ok(),
+                Value::Number(val_num) => val_num.as_u64().map(|u| u as u16),
+                _ => None,
+            })
+            .unwrap_or(7896);
+        if port == 0 {
+            port = 7896;
+        }
+        port
+    }
 
     pub fn guard_mixed_port(config: &Mapping) -> u16 {
         let mut port = config
@@ -84,9 +160,39 @@ impl IClashTemp {
                 Value::Number(val_num) => val_num.as_u64().map(|u| u as u16),
                 _ => None,
             })
-            .unwrap_or(7890);
+            .unwrap_or(7897);
         if port == 0 {
-            port = 7890;
+            port = 7897;
+        }
+        port
+    }
+
+    pub fn guard_socks_port(config: &Mapping) -> u16 {
+        let mut port = config
+            .get("socks-port")
+            .and_then(|value| match value {
+                Value::String(val_str) => val_str.parse().ok(),
+                Value::Number(val_num) => val_num.as_u64().map(|u| u as u16),
+                _ => None,
+            })
+            .unwrap_or(7898);
+        if port == 0 {
+            port = 7898;
+        }
+        port
+    }
+
+    pub fn guard_port(config: &Mapping) -> u16 {
+        let mut port = config
+            .get("port")
+            .and_then(|value| match value {
+                Value::String(val_str) => val_str.parse().ok(),
+                Value::Number(val_num) => val_num.as_u64().map(|u| u as u16),
+                _ => None,
+            })
+            .unwrap_or(7899);
+        if port == 0 {
+            port = 7899;
         }
         port
     }
@@ -98,7 +204,7 @@ impl IClashTemp {
                 Some(val_str) => {
                     let val_str = val_str.trim();
 
-                    let val = match val_str.starts_with(":") {
+                    let val = match val_str.starts_with(':') {
                         true => format!("127.0.0.1{val_str}"),
                         false => val_str.to_owned(),
                     };
@@ -109,7 +215,7 @@ impl IClashTemp {
                 }
                 None => None,
             })
-            .unwrap_or("127.0.0.1:9090".into())
+            .unwrap_or("127.0.0.1:9097".into())
     }
 
     pub fn guard_client_ctrl(config: &Mapping) -> String {
@@ -121,7 +227,7 @@ impl IClashTemp {
                 }
                 socket.to_string()
             }
-            Err(_) => "127.0.0.1:9090".into(),
+            Err(_) => "127.0.0.1:9097".into(),
         }
     }
 }
@@ -129,6 +235,8 @@ impl IClashTemp {
 #[derive(Default, Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
 pub struct ClashInfo {
     /// clash core port
+    pub mixed_port: u16,
+    pub socks_port: u16,
     pub port: u16,
     /// same as `external-controller`
     pub server: String,
@@ -148,7 +256,9 @@ fn test_clash_info() {
 
     fn get_result<S: Into<String>>(port: u16, server: S) -> ClashInfo {
         ClashInfo {
-            port,
+            mixed_port: port,
+            socks_port: 7898,
+            port: 7899,
             server: server.into(),
             secret: None,
         }
@@ -156,12 +266,12 @@ fn test_clash_info() {
 
     assert_eq!(
         IClashTemp(IClashTemp::guard(Mapping::new())).get_client_info(),
-        get_result(7890, "127.0.0.1:9090")
+        get_result(7897, "127.0.0.1:9097")
     );
 
-    assert_eq!(get_case("", ""), get_result(7890, "127.0.0.1:9090"));
+    assert_eq!(get_case("", ""), get_result(7897, "127.0.0.1:9097"));
 
-    assert_eq!(get_case(65537, ""), get_result(1, "127.0.0.1:9090"));
+    assert_eq!(get_case(65537, ""), get_result(1, "127.0.0.1:9097"));
 
     assert_eq!(
         get_case(8888, "127.0.0.1:8888"),
@@ -170,7 +280,7 @@ fn test_clash_info() {
 
     assert_eq!(
         get_case(8888, "   :98888 "),
-        get_result(8888, "127.0.0.1:9090")
+        get_result(8888, "127.0.0.1:9097")
     );
 
     assert_eq!(
@@ -195,7 +305,7 @@ fn test_clash_info() {
 
     assert_eq!(
         get_case(8888, "192.168.1.1:80800"),
-        get_result(8888, "127.0.0.1:9090")
+        get_result(8888, "127.0.0.1:9097")
     );
 }
 

src-tauri/src/config/config.rs

@@ -1,5 +1,6 @@
 use super::{Draft, IClashTemp, IProfiles, IRuntime, IVerge};
 use crate::{
+    config::PrfItem,
     enhance,
     utils::{dirs, help},
 };
@@ -45,9 +46,25 @@ impl Config {
         Self::global().runtime_config.clone()
     }
 
-    /// 初始化配置
-    pub fn init_config() -> Result<()> {
-        crate::log_err!(Self::generate());
+    /// 初始化订阅
+    pub async fn init_config() -> Result<()> {
+        if Self::profiles()
+            .data()
+            .get_item(&"Merge".to_string())
+            .is_err()
+        {
+            let merge_item = PrfItem::from_merge(Some("Merge".to_string()))?;
+            Self::profiles().data().append_item(merge_item.clone())?;
+        }
+        if Self::profiles()
+            .data()
+            .get_item(&"Script".to_string())
+            .is_err()
+        {
+            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}");
 
@@ -64,7 +81,7 @@ impl Config {
         Ok(())
     }
 
-    /// 将配置丢到对应的文件中
+    /// 将订阅丢到对应的文件中
     pub fn generate_file(typ: ConfigType) -> Result<PathBuf> {
         let path = match typ {
             ConfigType::Run => dirs::app_home_dir()?.join(RUNTIME_CONFIG),
@@ -82,9 +99,9 @@ impl Config {
         Ok(path)
     }
 
-    /// 生成配置存好
-    pub fn generate() -> Result<()> {
-        let (config, exists_keys, logs) = enhance::enhance();
+    /// 生成订阅存好
+    pub async fn generate() -> Result<()> {
+        let (config, exists_keys, logs) = enhance::enhance().await;
 
         *Config::runtime().draft() = IRuntime {
             config: Some(config),

src-tauri/src/config/draft.rs

@@ -26,7 +26,7 @@ macro_rules! draft_define {
             }
 
             pub fn draft(&self) -> MappedMutexGuard<$id> {
-                MutexGuard::map(self.inner.lock(), |mut inner| {
+                MutexGuard::map(self.inner.lock(), |inner| {
                     if inner.1.is_none() {
                         inner.1 = Some(inner.0.clone());
                     }

src-tauri/src/config/mod.rs

@@ -1,4 +1,5 @@
 mod clash;
+#[allow(clippy::module_inception)]
 mod config;
 mod draft;
 mod prfitem;
@@ -13,3 +14,8 @@ pub use self::prfitem::*;
 pub use self::profiles::*;
 pub use self::runtime::*;
 pub use self::verge::*;
+
+pub const DEFAULT_PAC: &str = r#"function FindProxyForURL(url, host) {
+  return "PROXY 127.0.0.1:%mixed-port%; SOCKS5 127.0.0.1:%mixed-port%; DIRECT;";
+}
+"#;

src-tauri/src/config/prfitem.rs

@@ -1,4 +1,4 @@
-use crate::utils::{dirs, help, tmpl};
+use crate::utils::{dirs, help, resolve::VERSION, tmpl};
 use anyhow::{bail, Context, Result};
 use reqwest::StatusCode;
 use serde::{Deserialize, Serialize};
@@ -8,7 +8,7 @@ use sysproxy::Sysproxy;
 
 use super::Config;
 
-#[derive(Debug, Clone, Deserialize, Serialize)]
+#[derive(Debug, Clone, Deserialize, Serialize, Default)]
 pub struct PrfItem {
     pub uid: Option<String>,
 
@@ -46,6 +46,10 @@ pub struct PrfItem {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub option: Option<PrfOption>,
 
+    /// profile web page url
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub home: Option<String>,
+
     /// the file data
     #[serde(skip)]
     pub file_data: Option<String>,
@@ -59,10 +63,10 @@ pub struct PrfSelected {
 
 #[derive(Default, Debug, Clone, Copy, Deserialize, Serialize)]
 pub struct PrfExtra {
-    pub upload: usize,
-    pub download: usize,
-    pub total: usize,
-    pub expire: usize,
+    pub upload: u64,
+    pub download: u64,
+    pub total: u64,
+    pub expire: u64,
 }
 
 #[derive(Default, Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
@@ -84,6 +88,22 @@ pub struct PrfOption {
 
     #[serde(skip_serializing_if = "Option::is_none")]
     pub update_interval: Option<u64>,
+
+    /// for `remote` profile
+    /// disable certificate validation
+    /// default is `false`
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub danger_accept_invalid_certs: Option<bool>,
+
+    pub merge: Option<String>,
+
+    pub script: Option<String>,
+
+    pub rules: Option<String>,
+
+    pub proxies: Option<String>,
+
+    pub groups: Option<String>,
 }
 
 impl PrfOption {
@@ -93,28 +113,18 @@ impl PrfOption {
                 a.user_agent = b.user_agent.or(a.user_agent);
                 a.with_proxy = b.with_proxy.or(a.with_proxy);
                 a.self_proxy = b.self_proxy.or(a.self_proxy);
+                a.danger_accept_invalid_certs = b
+                    .danger_accept_invalid_certs
+                    .or(a.danger_accept_invalid_certs);
                 a.update_interval = b.update_interval.or(a.update_interval);
+                a.merge = b.merge.or(a.merge);
+                a.script = b.script.or(a.script);
+                a.rules = b.rules.or(a.rules);
+                a.proxies = b.proxies.or(a.proxies);
+                a.groups = b.groups.or(a.groups);
                 Some(a)
             }
-            t @ _ => t.0.or(t.1),
-        }
-    }
-}
-
-impl Default for PrfItem {
-    fn default() -> Self {
-        PrfItem {
-            uid: None,
-            itype: None,
-            name: None,
-            desc: None,
-            file: None,
-            url: None,
-            selected: None,
-            extra: None,
-            updated: None,
-            option: None,
-            file_data: None,
+            t => t.0.or(t.1),
         }
     }
 }
@@ -140,28 +150,57 @@ impl PrfItem {
             "local" => {
                 let name = item.name.unwrap_or("Local File".into());
                 let desc = item.desc.unwrap_or("".into());
-                PrfItem::from_local(name, desc, file_data)
+                PrfItem::from_local(name, desc, file_data, item.option)
             }
-            "merge" => {
-                let name = item.name.unwrap_or("Merge".into());
-                let desc = item.desc.unwrap_or("".into());
-                PrfItem::from_merge(name, desc)
-            }
-            "script" => {
-                let name = item.name.unwrap_or("Script".into());
-                let desc = item.desc.unwrap_or("".into());
-                PrfItem::from_script(name, desc)
-            }
-            typ @ _ => bail!("invalid profile item type \"{typ}\""),
+            typ => bail!("invalid profile item type \"{typ}\""),
         }
     }
 
     /// ## Local type
     /// create a new item from name/desc
-    pub fn from_local(name: String, desc: String, file_data: Option<String>) -> Result<PrfItem> {
-        let uid = help::get_uid("l");
+    pub fn from_local(
+        name: String,
+        desc: String,
+        file_data: Option<String>,
+        option: Option<PrfOption>,
+    ) -> Result<PrfItem> {
+        let uid = help::get_uid("L");
         let file = format!("{uid}.yaml");
+        let opt_ref = option.as_ref();
+        let update_interval = opt_ref.and_then(|o| o.update_interval);
+        let mut merge = opt_ref.and_then(|o| o.merge.clone());
+        let mut script = opt_ref.and_then(|o| o.script.clone());
+        let mut rules = opt_ref.and_then(|o| o.rules.clone());
+        let mut proxies = opt_ref.and_then(|o| o.proxies.clone());
+        let mut groups = opt_ref.and_then(|o| o.groups.clone());
 
+        if merge.is_none() {
+            let merge_item = PrfItem::from_merge(None)?;
+            Config::profiles().data().append_item(merge_item.clone())?;
+            merge = merge_item.uid;
+        }
+        if script.is_none() {
+            let script_item = PrfItem::from_script(None)?;
+            Config::profiles().data().append_item(script_item.clone())?;
+            script = script_item.uid;
+        }
+        if rules.is_none() {
+            let rules_item = PrfItem::from_rules()?;
+            Config::profiles().data().append_item(rules_item.clone())?;
+            rules = rules_item.uid;
+        }
+        if proxies.is_none() {
+            let proxies_item = PrfItem::from_proxies()?;
+            Config::profiles()
+                .data()
+                .append_item(proxies_item.clone())?;
+            proxies = proxies_item.uid;
+        }
+        if groups.is_none() {
+            let groups_item = PrfItem::from_groups()?;
+            Config::profiles().data().append_item(groups_item.clone())?;
+            groups = groups_item.uid;
+        }
         Ok(PrfItem {
             uid: Some(uid),
             itype: Some("local".into()),
@@ -171,7 +210,16 @@ impl PrfItem {
             url: None,
             selected: None,
             extra: None,
-            option: None,
+            option: Some(PrfOption {
+                update_interval,
+                merge,
+                script,
+                rules,
+                proxies,
+                groups,
+                ..PrfOption::default()
+            }),
+            home: None,
             updated: Some(chrono::Local::now().timestamp() as usize),
             file_data: Some(file_data.unwrap_or(tmpl::ITEM_LOCAL.into())),
         })
@@ -188,13 +236,23 @@ impl PrfItem {
         let opt_ref = option.as_ref();
         let with_proxy = opt_ref.map_or(false, |o| o.with_proxy.unwrap_or(false));
         let self_proxy = opt_ref.map_or(false, |o| o.self_proxy.unwrap_or(false));
-        let user_agent = opt_ref.map_or(None, |o| o.user_agent.clone());
-
-        let mut builder = reqwest::ClientBuilder::new().no_proxy();
+        let accept_invalid_certs =
+            opt_ref.map_or(false, |o| o.danger_accept_invalid_certs.unwrap_or(false));
+        let user_agent = opt_ref.and_then(|o| o.user_agent.clone());
+        let update_interval = opt_ref.and_then(|o| o.update_interval);
+        let mut merge = opt_ref.and_then(|o| o.merge.clone());
+        let mut script = opt_ref.and_then(|o| o.script.clone());
+        let mut rules = opt_ref.and_then(|o| o.rules.clone());
+        let mut proxies = opt_ref.and_then(|o| o.proxies.clone());
+        let mut groups = opt_ref.and_then(|o| o.groups.clone());
+        let mut builder = reqwest::ClientBuilder::new().use_rustls_tls().no_proxy();
 
         // 使用软件自己的代理
         if self_proxy {
-            let port = Config::clash().data().get_mixed_port();
+            let port = Config::verge()
+                .latest()
+                .verge_mixed_port
+                .unwrap_or(Config::clash().data().get_mixed_port());
 
             let proxy_scheme = format!("http://127.0.0.1:{port}");
 
@@ -210,26 +268,27 @@ impl PrfItem {
         }
         // 使用系统代理
         else if with_proxy {
-            match Sysproxy::get_system_proxy() {
-                Ok(p @ Sysproxy { enable: true, .. }) => {
-                    let proxy_scheme = format!("http://{}:{}", p.host, p.port);
+            if let Ok(p @ Sysproxy { enable: true, .. }) = Sysproxy::get_system_proxy() {
+                let proxy_scheme = format!("http://{}:{}", p.host, p.port);
 
-                    if let Ok(proxy) = reqwest::Proxy::http(&proxy_scheme) {
-                        builder = builder.proxy(proxy);
-                    }
-                    if let Ok(proxy) = reqwest::Proxy::https(&proxy_scheme) {
-                        builder = builder.proxy(proxy);
-                    }
-                    if let Ok(proxy) = reqwest::Proxy::all(&proxy_scheme) {
-                        builder = builder.proxy(proxy);
-                    }
+                if let Ok(proxy) = reqwest::Proxy::http(&proxy_scheme) {
+                    builder = builder.proxy(proxy);
                 }
-                _ => {}
-            };
+                if let Ok(proxy) = reqwest::Proxy::https(&proxy_scheme) {
+                    builder = builder.proxy(proxy);
+                }
+                if let Ok(proxy) = reqwest::Proxy::all(&proxy_scheme) {
+                    builder = builder.proxy(proxy);
+                }
+            }
         }
 
-        let version = unsafe { dirs::APP_VERSION };
-        let version = format!("clash-verge/{version}");
+        let version = match VERSION.get() {
+            Some(v) => format!("clash-verge/v{}", v),
+            None => "clash-verge/unknown".to_string(),
+        };
+
+        builder = builder.danger_accept_invalid_certs(accept_invalid_certs);
         builder = builder.user_agent(user_agent.unwrap_or(version));
 
         let resp = builder.build()?.get(url).send().await?;
@@ -245,12 +304,11 @@ impl PrfItem {
         let extra = match header.get("Subscription-Userinfo") {
             Some(value) => {
                 let sub_info = value.to_str().unwrap_or("");
-
                 Some(PrfExtra {
-                    upload: help::parse_str(sub_info, "upload=").unwrap_or(0),
-                    download: help::parse_str(sub_info, "download=").unwrap_or(0),
-                    total: help::parse_str(sub_info, "total=").unwrap_or(0),
-                    expire: help::parse_str(sub_info, "expire=").unwrap_or(0),
+                    upload: help::parse_str(sub_info, "upload").unwrap_or(0),
+                    download: help::parse_str(sub_info, "download").unwrap_or(0),
+                    total: help::parse_str(sub_info, "total").unwrap_or(0),
+                    expire: help::parse_str(sub_info, "expire").unwrap_or(0),
                 })
             }
             None => None,
@@ -259,37 +317,90 @@ impl PrfItem {
         // parse the Content-Disposition
         let filename = match header.get("Content-Disposition") {
             Some(value) => {
-                let filename = value.to_str().unwrap_or("");
-                help::parse_str::<String>(filename, "filename=")
+                let filename = format!("{value:?}");
+                let filename = filename.trim_matches('"');
+                match help::parse_str::<String>(filename, "filename*") {
+                    Some(filename) => {
+                        let iter = percent_encoding::percent_decode(filename.as_bytes());
+                        let filename = iter.decode_utf8().unwrap_or_default();
+                        filename.split("''").last().map(|s| s.to_string())
+                    }
+                    None => match help::parse_str::<String>(filename, "filename") {
+                        Some(filename) => {
+                            let filename = filename.trim_matches('"');
+                            Some(filename.to_string())
+                        }
+                        None => None,
+                    },
+                }
+            }
+            None => Some(
+                crate::utils::help::get_last_part_and_decode(url).unwrap_or("Remote File".into()),
+            ),
+        };
+        let update_interval = match update_interval {
+            Some(val) => Some(val),
+            None => match header.get("profile-update-interval") {
+                Some(value) => match value.to_str().unwrap_or("").parse::<u64>() {
+                    Ok(val) => Some(val * 60), // hour -> min
+                    Err(_) => None,
+                },
+                None => None,
+            },
+        };
+
+        let home = match header.get("profile-web-page-url") {
+            Some(value) => {
+                let str_value = value.to_str().unwrap_or("");
+                Some(str_value.to_string())
             }
             None => None,
         };
 
-        // parse the profile-update-interval
-        let option = match header.get("profile-update-interval") {
-            Some(value) => match value.to_str().unwrap_or("").parse::<u64>() {
-                Ok(val) => Some(PrfOption {
-                    update_interval: Some(val * 60), // hour -> min
-                    ..PrfOption::default()
-                }),
-                Err(_) => None,
-            },
-            None => None,
-        };
-
-        let uid = help::get_uid("r");
+        let uid = help::get_uid("R");
         let file = format!("{uid}.yaml");
         let name = name.unwrap_or(filename.unwrap_or("Remote File".into()));
         let data = resp.text_with_charset("utf-8").await?;
 
+        // process the charset "UTF-8 with BOM"
+        let data = data.trim_start_matches('\u{feff}');
+
         // check the data whether the valid yaml format
-        let yaml = serde_yaml::from_str::<Mapping>(&data) //
+        let yaml = serde_yaml::from_str::<Mapping>(data)
             .context("the remote profile data is invalid yaml")?;
 
         if !yaml.contains_key("proxies") && !yaml.contains_key("proxy-providers") {
             bail!("profile does not contain `proxies` or `proxy-providers`");
         }
 
+        if merge.is_none() {
+            let merge_item = PrfItem::from_merge(None)?;
+            Config::profiles().data().append_item(merge_item.clone())?;
+            merge = merge_item.uid;
+        }
+        if script.is_none() {
+            let script_item = PrfItem::from_script(None)?;
+            Config::profiles().data().append_item(script_item.clone())?;
+            script = script_item.uid;
+        }
+        if rules.is_none() {
+            let rules_item = PrfItem::from_rules()?;
+            Config::profiles().data().append_item(rules_item.clone())?;
+            rules = rules_item.uid;
+        }
+        if proxies.is_none() {
+            let proxies_item = PrfItem::from_proxies()?;
+            Config::profiles()
+                .data()
+                .append_item(proxies_item.clone())?;
+            proxies = proxies_item.uid;
+        }
+        if groups.is_none() {
+            let groups_item = PrfItem::from_groups()?;
+            Config::profiles().data().append_item(groups_item.clone())?;
+            groups = groups_item.uid;
+        }
+
         Ok(PrfItem {
             uid: Some(uid),
             itype: Some("remote".into()),
@@ -299,46 +410,65 @@ impl PrfItem {
             url: Some(url.into()),
             selected: None,
             extra,
-            option,
+            option: Some(PrfOption {
+                update_interval,
+                merge,
+                script,
+                rules,
+                proxies,
+                groups,
+                ..PrfOption::default()
+            }),
+            home,
             updated: Some(chrono::Local::now().timestamp() as usize),
-            file_data: Some(data),
+            file_data: Some(data.into()),
         })
     }
 
     /// ## Merge type (enhance)
     /// create the enhanced item by using `merge` rule
-    pub fn from_merge(name: String, desc: String) -> Result<PrfItem> {
-        let uid = help::get_uid("m");
-        let file = format!("{uid}.yaml");
+    pub fn from_merge(uid: Option<String>) -> Result<PrfItem> {
+        let mut id = help::get_uid("m");
+        let mut template = tmpl::ITEM_MERGE_EMPTY.into();
+        if let Some(uid) = uid {
+            id = uid;
+            template = tmpl::ITEM_MERGE.into();
+        }
+        let file = format!("{id}.yaml");
 
         Ok(PrfItem {
-            uid: Some(uid),
+            uid: Some(id),
             itype: Some("merge".into()),
-            name: Some(name),
-            desc: Some(desc),
+            name: None,
+            desc: None,
             file: Some(file),
             url: None,
             selected: None,
             extra: None,
             option: None,
+            home: None,
             updated: Some(chrono::Local::now().timestamp() as usize),
-            file_data: Some(tmpl::ITEM_MERGE.into()),
+            file_data: Some(template),
         })
     }
 
     /// ## Script type (enhance)
     /// create the enhanced item by using javascript quick.js
-    pub fn from_script(name: String, desc: String) -> Result<PrfItem> {
-        let uid = help::get_uid("s");
-        let file = format!("{uid}.js"); // js ext
+    pub fn from_script(uid: Option<String>) -> Result<PrfItem> {
+        let mut id = help::get_uid("s");
+        if let Some(uid) = uid {
+            id = uid;
+        }
+        let file = format!("{id}.js"); // js ext
 
         Ok(PrfItem {
-            uid: Some(uid),
+            uid: Some(id),
             itype: Some("script".into()),
-            name: Some(name),
-            desc: Some(desc),
+            name: None,
+            desc: None,
             file: Some(file),
             url: None,
+            home: None,
             selected: None,
             extra: None,
             option: None,
@@ -347,6 +477,69 @@ impl PrfItem {
         })
     }
 
+    /// ## Rules type (enhance)
+    pub fn from_rules() -> Result<PrfItem> {
+        let uid = help::get_uid("r");
+        let file = format!("{uid}.yaml"); // yaml ext
+
+        Ok(PrfItem {
+            uid: Some(uid),
+            itype: Some("rules".into()),
+            name: None,
+            desc: None,
+            file: Some(file),
+            url: None,
+            home: None,
+            selected: None,
+            extra: None,
+            option: None,
+            updated: Some(chrono::Local::now().timestamp() as usize),
+            file_data: Some(tmpl::ITEM_RULES.into()),
+        })
+    }
+
+    /// ## Proxies type (enhance)
+    pub fn from_proxies() -> Result<PrfItem> {
+        let uid = help::get_uid("p");
+        let file = format!("{uid}.yaml"); // yaml ext
+
+        Ok(PrfItem {
+            uid: Some(uid),
+            itype: Some("proxies".into()),
+            name: None,
+            desc: None,
+            file: Some(file),
+            url: None,
+            home: None,
+            selected: None,
+            extra: None,
+            option: None,
+            updated: Some(chrono::Local::now().timestamp() as usize),
+            file_data: Some(tmpl::ITEM_PROXIES.into()),
+        })
+    }
+
+    /// ## Groups type (enhance)
+    pub fn from_groups() -> Result<PrfItem> {
+        let uid = help::get_uid("g");
+        let file = format!("{uid}.yaml"); // yaml ext
+
+        Ok(PrfItem {
+            uid: Some(uid),
+            itype: Some("groups".into()),
+            name: None,
+            desc: None,
+            file: Some(file),
+            url: None,
+            home: None,
+            selected: None,
+            extra: None,
+            option: None,
+            updated: Some(chrono::Local::now().timestamp() as usize),
+            file_data: Some(tmpl::ITEM_GROUPS.into()),
+        })
+    }
+
     /// get the file data
     pub fn read_file(&self) -> Result<String> {
         if self.file.is_none() {

src-tauri/src/config/profiles.rs

@@ -1,4 +1,4 @@
-use super::prfitem::PrfItem;
+use super::{prfitem::PrfItem, PrfOption};
 use crate::utils::{dirs, help};
 use anyhow::{bail, Context, Result};
 use serde::{Deserialize, Serialize};
@@ -11,12 +11,6 @@ pub struct IProfiles {
     /// same as PrfConfig.current
     pub current: Option<String>,
 
-    /// same as PrfConfig.chain
-    pub chain: Option<Vec<String>>,
-
-    /// record valid fields for clash
-    pub valid: Option<Vec<String>>,
-
     /// profile list
     pub items: Option<Vec<PrfItem>>,
 }
@@ -37,13 +31,13 @@ impl IProfiles {
                     profiles.items = Some(vec![]);
                 }
                 // compatible with the old old old version
-                profiles.items.as_mut().map(|items| {
-                    for mut item in items.iter_mut() {
+                if let Some(items) = profiles.items.as_mut() {
+                    for item in items.iter_mut() {
                         if item.uid.is_none() {
                             item.uid = Some(help::get_uid("d"));
                         }
                     }
-                });
+                }
                 profiles
             }
             Err(err) => {
@@ -55,7 +49,6 @@ impl IProfiles {
 
     pub fn template() -> Self {
         Self {
-            valid: Some(vec!["dns".into()]),
             items: Some(vec![]),
             ..Self::default()
         }
@@ -84,14 +77,6 @@ impl IProfiles {
             }
         }
 
-        if let Some(chain) = patch.chain {
-            self.chain = Some(chain);
-        }
-
-        if let Some(valid) = patch.valid {
-            self.valid = Some(valid);
-        }
-
         Ok(())
     }
 
@@ -138,24 +123,50 @@ impl IProfiles {
             let path = dirs::app_profiles_dir()?.join(&file);
 
             fs::File::create(path)
-                .context(format!("failed to create file \"{}\"", file))?
+                .with_context(|| format!("failed to create file \"{}\"", file))?
                 .write(file_data.as_bytes())
-                .context(format!("failed to write to file \"{}\"", file))?;
+                .with_context(|| format!("failed to write to file \"{}\"", file))?;
         }
 
         if self.items.is_none() {
             self.items = Some(vec![]);
         }
 
-        self.items.as_mut().map(|items| items.push(item));
+        if let Some(items) = self.items.as_mut() {
+            items.push(item)
+        }
+        self.save_file()
+    }
+
+    /// reorder items
+    pub fn reorder(&mut self, active_id: String, over_id: String) -> Result<()> {
+        let mut items = self.items.take().unwrap_or_default();
+        let mut old_index = None;
+        let mut new_index = None;
+
+        for (i, _) in items.iter().enumerate() {
+            if items[i].uid == Some(active_id.clone()) {
+                old_index = Some(i);
+            }
+            if items[i].uid == Some(over_id.clone()) {
+                new_index = Some(i);
+            }
+        }
+
+        if old_index.is_none() || new_index.is_none() {
+            return Ok(());
+        }
+        let item = items.remove(old_index.unwrap());
+        items.insert(new_index.unwrap(), item);
+        self.items = Some(items);
         self.save_file()
     }
 
     /// update the item value
     pub fn patch_item(&mut self, uid: String, item: PrfItem) -> Result<()> {
-        let mut items = self.items.take().unwrap_or(vec![]);
+        let mut items = self.items.take().unwrap_or_default();
 
-        for mut each in items.iter_mut() {
+        for each in items.iter_mut() {
             if each.uid == Some(uid.clone()) {
                 patch!(each, item, itype);
                 patch!(each, item, name);
@@ -189,11 +200,12 @@ impl IProfiles {
         if let Some(items) = self.items.as_mut() {
             let some_uid = Some(uid.clone());
 
-            for mut each in items.iter_mut() {
+            for each in items.iter_mut() {
                 if each.uid == some_uid {
                     each.extra = item.extra;
                     each.updated = item.updated;
-
+                    each.home = item.home;
+                    each.option = PrfOption::merge(each.option.clone(), item.option);
                     // save the file data
                     // move the field value after save
                     if let Some(file_data) = item.file_data.take() {
@@ -207,9 +219,9 @@ impl IProfiles {
                         let path = dirs::app_profiles_dir()?.join(&file);
 
                         fs::File::create(path)
-                            .context(format!("failed to create file \"{}\"", file))?
+                            .with_context(|| format!("failed to create file \"{}\"", file))?
                             .write(file_data.as_bytes())
-                            .context(format!("failed to write to file \"{}\"", file))?;
+                            .with_context(|| format!("failed to write to file \"{}\"", file))?;
                     }
 
                     break;
@@ -225,32 +237,125 @@ impl IProfiles {
     pub fn delete_item(&mut self, uid: String) -> Result<bool> {
         let current = self.current.as_ref().unwrap_or(&uid);
         let current = current.clone();
-
-        let mut items = self.items.take().unwrap_or(vec![]);
+        let item = self.get_item(&uid)?;
+        let merge_uid = item.option.as_ref().and_then(|e| e.merge.clone());
+        let script_uid = item.option.as_ref().and_then(|e| e.script.clone());
+        let rules_uid = item.option.as_ref().and_then(|e| e.rules.clone());
+        let proxies_uid = item.option.as_ref().and_then(|e| e.proxies.clone());
+        let groups_uid = item.option.as_ref().and_then(|e| e.groups.clone());
+        let mut items = self.items.take().unwrap_or_default();
         let mut index = None;
+        let mut merge_index = None;
+        let mut script_index = None;
+        let mut rules_index = None;
+        let mut proxies_index = None;
+        let mut groups_index = None;
 
         // get the index
-        for i in 0..items.len() {
+        for (i, _) in items.iter().enumerate() {
             if items[i].uid == Some(uid.clone()) {
                 index = Some(i);
                 break;
             }
         }
-
         if let Some(index) = index {
-            items.remove(index).file.map(|file| {
+            if let Some(file) = items.remove(index).file {
                 let _ = dirs::app_profiles_dir().map(|path| {
                     let path = path.join(file);
                     if path.exists() {
                         let _ = fs::remove_file(path);
                     }
                 });
-            });
+            }
+        }
+        // get the merge index
+        for (i, _) in items.iter().enumerate() {
+            if items[i].uid == merge_uid {
+                merge_index = Some(i);
+                break;
+            }
+        }
+        if let Some(index) = merge_index {
+            if let Some(file) = items.remove(index).file {
+                let _ = dirs::app_profiles_dir().map(|path| {
+                    let path = path.join(file);
+                    if path.exists() {
+                        let _ = fs::remove_file(path);
+                    }
+                });
+            }
+        }
+        // get the script index
+        for (i, _) in items.iter().enumerate() {
+            if items[i].uid == script_uid {
+                script_index = Some(i);
+                break;
+            }
+        }
+        if let Some(index) = script_index {
+            if let Some(file) = items.remove(index).file {
+                let _ = dirs::app_profiles_dir().map(|path| {
+                    let path = path.join(file);
+                    if path.exists() {
+                        let _ = fs::remove_file(path);
+                    }
+                });
+            }
+        }
+        // get the rules index
+        for (i, _) in items.iter().enumerate() {
+            if items[i].uid == rules_uid {
+                rules_index = Some(i);
+                break;
+            }
+        }
+        if let Some(index) = rules_index {
+            if let Some(file) = items.remove(index).file {
+                let _ = dirs::app_profiles_dir().map(|path| {
+                    let path = path.join(file);
+                    if path.exists() {
+                        let _ = fs::remove_file(path);
+                    }
+                });
+            }
+        }
+        // get the proxies index
+        for (i, _) in items.iter().enumerate() {
+            if items[i].uid == proxies_uid {
+                proxies_index = Some(i);
+                break;
+            }
+        }
+        if let Some(index) = proxies_index {
+            if let Some(file) = items.remove(index).file {
+                let _ = dirs::app_profiles_dir().map(|path| {
+                    let path = path.join(file);
+                    if path.exists() {
+                        let _ = fs::remove_file(path);
+                    }
+                });
+            }
+        }
+        // get the groups index
+        for (i, _) in items.iter().enumerate() {
+            if items[i].uid == groups_uid {
+                groups_index = Some(i);
+                break;
+            }
+        }
+        if let Some(index) = groups_index {
+            if let Some(file) = items.remove(index).file {
+                let _ = dirs::app_profiles_dir().map(|path| {
+                    let path = path.join(file);
+                    if path.exists() {
+                        let _ = fs::remove_file(path);
+                    }
+                });
+            }
         }
-
         // delete the original uid
         if current == uid {
-            self.current = match items.len() > 0 {
+            self.current = match !items.is_empty() {
                 true => items[0].uid.clone(),
                 false => None,
             };
@@ -261,7 +366,7 @@ impl IProfiles {
         Ok(current == uid)
     }
 
-    /// 获取current指向的配置内容
+    /// 获取current指向的订阅内容
     pub fn current_mapping(&self) -> Result<Mapping> {
         match (self.current.as_ref(), self.items.as_ref()) {
             (Some(current), Some(items)) => {
@@ -270,11 +375,81 @@ impl IProfiles {
                         Some(file) => dirs::app_profiles_dir()?.join(file),
                         None => bail!("failed to get the file field"),
                     };
-                    return Ok(help::read_merge_mapping(&file_path)?);
+                    return help::read_mapping(&file_path);
                 }
                 bail!("failed to find the current profile \"uid:{current}\"");
             }
             _ => Ok(Mapping::new()),
         }
     }
+
+    /// 获取current指向的订阅的merge
+    pub fn current_merge(&self) -> Option<String> {
+        match (self.current.as_ref(), self.items.as_ref()) {
+            (Some(current), Some(items)) => {
+                if let Some(item) = items.iter().find(|e| e.uid.as_ref() == Some(current)) {
+                    let merge = item.option.as_ref().and_then(|e| e.merge.clone());
+                    return merge;
+                }
+                None
+            }
+            _ => None,
+        }
+    }
+
+    /// 获取current指向的订阅的script
+    pub fn current_script(&self) -> Option<String> {
+        match (self.current.as_ref(), self.items.as_ref()) {
+            (Some(current), Some(items)) => {
+                if let Some(item) = items.iter().find(|e| e.uid.as_ref() == Some(current)) {
+                    let script = item.option.as_ref().and_then(|e| e.script.clone());
+                    return script;
+                }
+                None
+            }
+            _ => None,
+        }
+    }
+
+    /// 获取current指向的订阅的rules
+    pub fn current_rules(&self) -> Option<String> {
+        match (self.current.as_ref(), self.items.as_ref()) {
+            (Some(current), Some(items)) => {
+                if let Some(item) = items.iter().find(|e| e.uid.as_ref() == Some(current)) {
+                    let rules = item.option.as_ref().and_then(|e| e.rules.clone());
+                    return rules;
+                }
+                None
+            }
+            _ => None,
+        }
+    }
+
+    /// 获取current指向的订阅的proxies
+    pub fn current_proxies(&self) -> Option<String> {
+        match (self.current.as_ref(), self.items.as_ref()) {
+            (Some(current), Some(items)) => {
+                if let Some(item) = items.iter().find(|e| e.uid.as_ref() == Some(current)) {
+                    let proxies = item.option.as_ref().and_then(|e| e.proxies.clone());
+                    return proxies;
+                }
+                None
+            }
+            _ => None,
+        }
+    }
+
+    /// 获取current指向的订阅的groups
+    pub fn current_groups(&self) -> Option<String> {
+        match (self.current.as_ref(), self.items.as_ref()) {
+            (Some(current), Some(items)) => {
+                if let Some(item) = items.iter().find(|e| e.uid.as_ref() == Some(current)) {
+                    let groups = item.option.as_ref().and_then(|e| e.groups.clone());
+                    return groups;
+                }
+                None
+            }
+            _ => None,
+        }
+    }
 }

src-tauri/src/config/runtime.rs

@@ -1,11 +1,11 @@
+use crate::enhance::field::use_keys;
 use serde::{Deserialize, Serialize};
-use serde_yaml::Mapping;
+use serde_yaml::{Mapping, Value};
 use std::collections::HashMap;
-
 #[derive(Default, Debug, Clone, Deserialize, Serialize)]
 pub struct IRuntime {
     pub config: Option<Mapping>,
-    // 记录在配置中（包括merge和script生成的）出现过的keys
+    // 记录在订阅中（包括merge和script生成的）出现过的keys
     // 这些keys不一定都生效
     pub exists_keys: Vec<String>,
     pub chain_logs: HashMap<String, Vec<(String, String)>>,
@@ -15,4 +15,31 @@ impl IRuntime {
     pub fn new() -> Self {
         Self::default()
     }
+
+    // 这里只更改 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"]
+                .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));
+        }
+    }
 }

src-tauri/src/config/verge.rs

@@ -1,5 +1,7 @@
+use crate::config::DEFAULT_PAC;
 use crate::utils::{dirs, help};
 use anyhow::Result;
+use log::LevelFilter;
 use serde::{Deserialize, Serialize};
 
 /// ### `verge.yaml` schema
@@ -8,19 +10,52 @@ pub struct IVerge {
     /// app listening port for app singleton
     pub app_singleton_port: Option<u16>,
 
+    /// app log level
+    /// silent | error | warn | info | debug | trace
+    pub app_log_level: Option<String>,
+
     // i18n
     pub language: Option<String>,
 
     /// `light` or `dark` or `system`
     pub theme_mode: Option<String>,
 
-    /// enable blur mode
-    /// maybe be able to set the alpha
-    pub theme_blur: Option<bool>,
+    /// tray click event
+    pub tray_event: Option<String>,
+
+    /// copy env type
+    pub env_type: Option<String>,
+
+    /// start page
+    pub start_page: Option<String>,
+    /// startup script path
+    pub startup_script: Option<String>,
 
     /// enable traffic graph default is true
     pub traffic_graph: Option<bool>,
 
+    /// show memory info (only for Clash Meta)
+    pub enable_memory_usage: Option<bool>,
+
+    /// enable group icon
+    pub enable_group_icon: Option<bool>,
+
+    /// common tray icon
+    pub common_tray_icon: Option<bool>,
+
+    /// tray icon
+    #[cfg(target_os = "macos")]
+    pub tray_icon: Option<String>,
+
+    /// menu icon
+    pub menu_icon: Option<String>,
+
+    /// sysproxy tray icon
+    pub sysproxy_tray_icon: Option<bool>,
+
+    /// tun tray icon
+    pub tun_tray_icon: Option<bool>,
+
     /// clash tun mode
     pub enable_tun_mode: Option<bool>,
 
@@ -40,12 +75,21 @@ pub struct IVerge {
     /// enable proxy guard
     pub enable_proxy_guard: Option<bool>,
 
+    /// always use default bypass
+    pub use_default_bypass: Option<bool>,
+
     /// set system proxy bypass
     pub system_proxy_bypass: Option<String>,
 
     /// proxy guard duration
     pub proxy_guard_duration: Option<u64>,
 
+    /// use pac mode
+    pub proxy_auto_config: Option<bool>,
+
+    /// pac script content
+    pub pac_file_content: Option<String>,
+
     /// theme setting
     pub theme_setting: Option<IVergeTheme>,
 
@@ -63,11 +107,69 @@ pub struct IVerge {
     /// 切换代理时自动关闭连接
     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>,
+
+    /// 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>,
+
+    /// verge 的各种 port 用于覆盖 clash 的各种 port
+    #[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>,
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct IVergeTestItem {
+    pub uid: Option<String>,
+    pub name: Option<String>,
+    pub icon: Option<String>,
+    pub url: Option<String>,
 }
 
 #[derive(Default, Debug, Clone, Deserialize, Serialize)]
@@ -99,18 +201,49 @@ impl IVerge {
 
     pub fn template() -> Self {
         Self {
-            clash_core: Some("clash".into()),
-            language: Some("en".into()),
+            clash_core: Some("verge-mihomo".into()),
+            language: Some("zh".into()),
             theme_mode: Some("system".into()),
-            theme_blur: Some(false),
+            #[cfg(not(target_os = "windows"))]
+            env_type: Some("bash".into()),
+            #[cfg(target_os = "windows")]
+            env_type: Some("powershell".into()),
+            start_page: Some("/".into()),
             traffic_graph: Some(true),
+            enable_memory_usage: Some(true),
+            enable_group_icon: Some(true),
+            #[cfg(target_os = "macos")]
+            tray_icon: Some("monochrome".into()),
+            menu_icon: Some("monochrome".into()),
+            common_tray_icon: Some(false),
+            sysproxy_tray_icon: Some(false),
+            tun_tray_icon: Some(false),
             enable_auto_launch: Some(false),
             enable_silent_start: Some(false),
             enable_system_proxy: Some(false),
+            proxy_auto_config: Some(false),
+            pac_file_content: Some(DEFAULT_PAC.into()),
+            enable_random_port: Some(false),
+            #[cfg(not(target_os = "windows"))]
+            verge_redir_port: Some(7895),
+            #[cfg(not(target_os = "windows"))]
+            verge_redir_enabled: Some(true),
+            #[cfg(target_os = "linux")]
+            verge_tproxy_port: Some(7896),
+            #[cfg(target_os = "linux")]
+            verge_tproxy_enabled: Some(true),
+            verge_mixed_port: Some(7897),
+            verge_socks_port: Some(7898),
+            verge_socks_enabled: Some(true),
+            verge_port: Some(7899),
+            verge_http_enabled: Some(true),
             enable_proxy_guard: Some(false),
+            use_default_bypass: Some(true),
             proxy_guard_duration: Some(30),
             auto_close_connection: Some(true),
+            auto_check_update: Some(true),
             enable_builtin_enhanced: Some(true),
+            auto_log_clean: Some(3),
             ..Self::default()
         }
     }
@@ -131,19 +264,48 @@ impl IVerge {
             };
         }
 
+        patch!(app_log_level);
         patch!(language);
         patch!(theme_mode);
-        patch!(theme_blur);
+        patch!(tray_event);
+        patch!(env_type);
+        patch!(start_page);
+        patch!(startup_script);
         patch!(traffic_graph);
+        patch!(enable_memory_usage);
+        patch!(enable_group_icon);
+        #[cfg(target_os = "macos")]
+        patch!(tray_icon);
+        patch!(menu_icon);
+        patch!(common_tray_icon);
+        patch!(sysproxy_tray_icon);
+        patch!(tun_tray_icon);
 
         patch!(enable_tun_mode);
         patch!(enable_service_mode);
         patch!(enable_auto_launch);
         patch!(enable_silent_start);
+        patch!(enable_random_port);
+        #[cfg(not(target_os = "windows"))]
+        patch!(verge_redir_port);
+        #[cfg(not(target_os = "windows"))]
+        patch!(verge_redir_enabled);
+        #[cfg(target_os = "linux")]
+        patch!(verge_tproxy_port);
+        #[cfg(target_os = "linux")]
+        patch!(verge_tproxy_enabled);
+        patch!(verge_mixed_port);
+        patch!(verge_socks_port);
+        patch!(verge_socks_enabled);
+        patch!(verge_port);
+        patch!(verge_http_enabled);
         patch!(enable_system_proxy);
         patch!(enable_proxy_guard);
+        patch!(use_default_bypass);
         patch!(system_proxy_bypass);
         patch!(proxy_guard_duration);
+        patch!(proxy_auto_config);
+        patch!(pac_file_content);
 
         patch!(theme_setting);
         patch!(web_ui_list);
@@ -151,8 +313,15 @@ impl IVerge {
         patch!(hotkeys);
 
         patch!(auto_close_connection);
+        patch!(auto_check_update);
         patch!(default_latency_test);
+        patch!(default_latency_timeout);
         patch!(enable_builtin_enhanced);
+        patch!(proxy_layout_column);
+        patch!(test_list);
+        patch!(auto_log_clean);
+        patch!(window_size_position);
+        patch!(window_is_maximized);
     }
 
     /// 在初始化前尝试拿到单例端口的值
@@ -167,4 +336,21 @@ impl IVerge {
             Err(_) => SERVER_PORT, // 这里就不log错误了
         }
     }
+
+    /// 获取日志等级
+    pub fn get_log_level(&self) -> LevelFilter {
+        if let Some(level) = self.app_log_level.as_ref() {
+            match level.to_lowercase().as_str() {
+                "silent" => LevelFilter::Off,
+                "error" => LevelFilter::Error,
+                "warn" => LevelFilter::Warn,
+                "info" => LevelFilter::Info,
+                "debug" => LevelFilter::Debug,
+                "trace" => LevelFilter::Trace,
+                _ => LevelFilter::Info,
+            }
+        } else {
+            LevelFilter::Info
+        }
+    }
 }

src-tauri/src/core/clash_api.rs

@@ -1,6 +1,7 @@
 use crate::config::Config;
 use anyhow::{bail, Result};
 use reqwest::header::HeaderMap;
+use serde::{Deserialize, Serialize};
 use serde_yaml::Mapping;
 use std::collections::HashMap;
 
@@ -19,7 +20,7 @@ pub async fn put_configs(path: &str) -> Result<()> {
 
     match response.status().as_u16() {
         204 => Ok(()),
-        status @ _ => {
+        status => {
             bail!("failed to put configs with status \"{status}\"")
         }
     }
@@ -36,6 +37,36 @@ pub async fn patch_configs(config: &Mapping) -> Result<()> {
     Ok(())
 }
 
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct DelayRes {
+    delay: u64,
+}
+
+/// GET /proxies/{name}/delay
+/// 获取代理延迟
+pub async fn get_proxy_delay(
+    name: String,
+    test_url: Option<String>,
+    timeout: i32,
+) -> Result<DelayRes> {
+    let (url, headers) = clash_client_info()?;
+    let url = format!("{url}/proxies/{name}/delay");
+
+    let default_url = "http://1.1.1.1";
+    let test_url = test_url
+        .map(|s| if s.is_empty() { default_url.into() } else { s })
+        .unwrap_or(default_url.into());
+
+    let client = reqwest::ClientBuilder::new().no_proxy().build()?;
+    let builder = client
+        .get(&url)
+        .headers(headers)
+        .query(&[("timeout", &format!("{timeout}")), ("url", &test_url)]);
+    let response = builder.send().await?;
+
+    Ok(response.json::<DelayRes>().await?)
+}
+
 /// 根据clash info获取clash服务地址和请求头
 fn clash_client_info() -> Result<(String, HeaderMap)> {
     let client = { Config::clash().data().get_client_info() };
@@ -54,11 +85,15 @@ fn clash_client_info() -> Result<(String, HeaderMap)> {
 }
 
 /// 缩短clash的日志
+#[allow(dead_code)]
 pub fn parse_log(log: String) -> String {
-    if log.starts_with("time=") {
-        return (&log[33..]).to_owned();
+    if log.starts_with("time=") && log.len() > 33 {
+        return (log[33..]).to_owned();
     }
-    (&log[9..]).to_owned()
+    if log.len() > 9 {
+        return (log[9..]).to_owned();
+    }
+    log
 }
 
 /// 缩短clash -t的错误输出
@@ -75,7 +110,7 @@ pub fn parse_check_output(log: String) -> String {
         };
 
         if mr > m {
-            return (&log[e..mr]).to_owned();
+            return (log[e..mr]).to_owned();
         }
     }
 
@@ -83,7 +118,7 @@ pub fn parse_check_output(log: String) -> String {
     let r = log.find("path=").or(Some(log.len()));
 
     if let (Some(l), Some(r)) = (l, r) {
-        return (&log[(l + 6)..(r - 1)]).to_owned();
+        return (log[(l + 6)..(r - 1)]).to_owned();
     }
 
     log

src-tauri/src/core/core.rs

@@ -1,11 +1,13 @@
-use super::{clash_api, logger::Logger};
+use crate::config::*;
+use crate::core::{clash_api, handle, logger::Logger, service};
 use crate::log_err;
-use crate::{config::*, utils::dirs};
-use anyhow::{bail, Context, Result};
+use crate::utils::dirs;
+use anyhow::{bail, Result};
 use once_cell::sync::OnceCell;
 use parking_lot::Mutex;
-use std::{fs, io::Write, sync::Arc, time::Duration};
-use sysinfo::{Pid, PidExt, ProcessExt, System, SystemExt};
+use serde_yaml::Mapping;
+use std::{sync::Arc, time::Duration};
+use sysinfo::System;
 use tauri::api::process::{Command, CommandChild, CommandEvent};
 use tokio::time::sleep;
 
@@ -28,21 +30,6 @@ impl CoreManager {
     }
 
     pub fn init(&self) -> Result<()> {
-        // kill old clash process
-        let _ = dirs::clash_pid_path()
-            .and_then(|path| fs::read(path).map(|p| p.to_vec()).context(""))
-            .and_then(|pid| String::from_utf8_lossy(&pid).parse().context(""))
-            .map(|pid| {
-                let mut system = System::new();
-                system.refresh_all();
-                system.process(Pid::from_u32(pid)).map(|proc| {
-                    if proc.name().contains("clash") {
-                        log::debug!(target: "app", "kill old clash process");
-                        proc.kill();
-                    }
-                });
-            });
-
         tauri::async_runtime::spawn(async {
             // 启动clash
             log_err!(Self::global().run_core().await);
@@ -51,7 +38,7 @@ impl CoreManager {
         Ok(())
     }
 
-    /// 检查配置是否正确
+    /// 检查订阅是否正确
     pub fn check_config(&self) -> Result<()> {
         let config_path = Config::generate_file(ConfigType::Check)?;
         let config_path = dirs::path_to_str(&config_path)?;
@@ -68,6 +55,10 @@ impl CoreManager {
 
         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}");
         }
@@ -81,18 +72,29 @@ impl CoreManager {
 
         #[allow(unused_mut)]
         let mut should_kill = match self.sidecar.lock().take() {
-            Some(child) => {
-                log::debug!(target: "app", "stop the core by sidecar");
-                let _ = child.kill();
-                true
-            }
+            Some(_) => true,
             None => false,
         };
 
-        #[cfg(target_os = "windows")]
+        // 关闭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!(super::win_service::stop_core_by_service().await);
+            log_err!(service::stop_core_by_service().await);
             should_kill = true;
         }
 
@@ -101,32 +103,27 @@ impl CoreManager {
             sleep(Duration::from_millis(500)).await;
         }
 
-        #[cfg(target_os = "windows")]
-        {
-            use super::win_service;
+        // 服务模式
+        let enable = { Config::verge().latest().enable_service_mode };
+        let enable = enable.unwrap_or(false);
 
-            // 服务模式
-            let enable = { Config::verge().latest().enable_service_mode.clone() };
-            let enable = enable.unwrap_or(false);
+        *self.use_service_mode.lock() = enable;
 
-            *self.use_service_mode.lock() = enable;
+        if enable {
+            // 服务模式启动失败就直接运行sidecar
+            log::debug!(target: "app", "try to run core in service mode");
 
-            if enable {
-                // 服务模式启动失败就直接运行sidecar
-                log::debug!(target: "app", "try to run core in service mode");
-
-                match (|| async {
-                    win_service::check_service().await?;
-                    win_service::run_core_by_service(&config_path).await
-                })()
-                .await
-                {
-                    Ok(_) => return Ok(()),
-                    Err(err) => {
-                        // 修改这个值，免得stop出错
-                        *self.use_service_mode.lock() = false;
-                        log::error!(target: "app", "{err}");
-                    }
+            let 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}");
                 }
             }
         }
@@ -135,52 +132,51 @@ impl CoreManager {
         let app_dir = dirs::path_to_str(&app_dir)?;
 
         let clash_core = { Config::verge().latest().clash_core.clone() };
-        let clash_core = clash_core.unwrap_or("clash".into());
+        let 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)?;
 
-        // fix #212
-        let args = match clash_core.as_str() {
-            "clash-meta" => vec!["-m", "-d", app_dir, "-f", config_path],
-            _ => vec!["-d", app_dir, "-f", config_path],
-        };
+        let args = vec!["-d", app_dir, "-f", config_path];
 
         let cmd = Command::new_sidecar(clash_core)?;
         let (mut rx, cmd_child) = cmd.args(args).spawn()?;
 
-        // 将pid写入文件中
-        crate::log_err!((|| {
-            let pid = cmd_child.pid();
-            let path = dirs::clash_pid_path()?;
-            fs::File::create(path)
-                .context("failed to create the pid file")?
-                .write(format!("{pid}").as_bytes())
-                .context("failed to write pid to the file")?;
-            <Result<()>>::Ok(())
-        })());
-
         let mut sidecar = self.sidecar.lock();
         *sidecar = Some(cmd_child);
+        drop(sidecar);
 
         tauri::async_runtime::spawn(async move {
             while let Some(event) = rx.recv().await {
                 match event {
                     CommandEvent::Stdout(line) => {
-                        let stdout = clash_api::parse_log(line.clone());
-                        log::info!(target: "app", "[clash]: {stdout}");
+                        log::info!(target: "app", "[mihomo]: {line}");
                         Logger::global().set_log(line);
                     }
                     CommandEvent::Stderr(err) => {
-                        let stdout = clash_api::parse_log(err.clone());
-                        log::error!(target: "app", "[clash]: {stdout}");
+                        log::error!(target: "app", "[mihomo]: {err}");
                         Logger::global().set_log(err);
                     }
                     CommandEvent::Error(err) => {
-                        log::error!(target: "app", "[clash]: {err}");
+                        log::error!(target: "app", "[mihomo]: {err}");
                         Logger::global().set_log(err);
                     }
                     CommandEvent::Terminated(_) => {
-                        log::info!(target: "app", "clash core terminated");
+                        log::info!(target: "app", "mihomo core terminated");
+                        let _ = CoreManager::global().recover_core();
                         break;
                     }
                     _ => {}
@@ -191,21 +187,62 @@ impl CoreManager {
         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();
+                }
+            }
+        });
+
+        Ok(())
+    }
+
     /// 停止核心运行
-    pub fn stop_core(&self) -> Result<()> {
-        #[cfg(target_os = "windows")]
+    pub async fn stop_core(&self) -> Result<()> {
+        // 关闭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;
+
         if *self.use_service_mode.lock() {
             log::debug!(target: "app", "stop the core by service");
-            tauri::async_runtime::block_on(async move {
-                log_err!(super::win_service::stop_core_by_service().await);
-            });
+            log_err!(service::stop_core_by_service().await);
             return Ok(());
         }
 
         let mut sidecar = self.sidecar.lock();
-        if let Some(child) = sidecar.take() {
-            log::debug!(target: "app", "stop the core by sidecar");
-            let _ = child.kill();
+        let _ = sidecar.take();
+
+        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();
         }
         Ok(())
     }
@@ -213,8 +250,9 @@ impl CoreManager {
     /// 切换核心
     pub async fn change_core(&self, clash_core: Option<String>) -> Result<()> {
         let clash_core = clash_core.ok_or(anyhow::anyhow!("clash core is null"))?;
+        const CLASH_CORES: [&str; 2] = ["verge-mihomo", "verge-mihomo-alpha"];
 
-        if &clash_core != "clash" && &clash_core != "clash-meta" {
+        if !CLASH_CORES.contains(&clash_core.as_str()) {
             bail!("invalid clash core name \"{clash_core}\"");
         }
 
@@ -222,8 +260,8 @@ impl CoreManager {
 
         Config::verge().draft().clash_core = Some(clash_core);
 
-        // 更新配置
-        Config::generate()?;
+        // 更新订阅
+        Config::generate().await?;
 
         self.check_config()?;
 
@@ -250,13 +288,13 @@ impl CoreManager {
     pub async fn update_config(&self) -> Result<()> {
         log::debug!(target: "app", "try to update clash config");
 
-        // 更新配置
-        Config::generate()?;
+        // 更新订阅
+        Config::generate().await?;
 
-        // 检查配置是否正常
+        // 检查订阅是否正常
         self.check_config()?;
 
-        // 更新运行时配置
+        // 更新运行时订阅
         let path = Config::generate_file(ConfigType::Run)?;
         let path = dirs::path_to_str(&path)?;
 

src-tauri/src/core/handle.rs

@@ -28,7 +28,7 @@ impl Handle {
         self.app_handle
             .lock()
             .as_ref()
-            .map_or(None, |a| a.get_window("main"))
+            .and_then(|a| a.get_window("main"))
     }
 
     pub fn refresh_clash() {

src-tauri/src/core/hotkey.rs

@@ -4,7 +4,6 @@ use once_cell::sync::OnceCell;
 use parking_lot::Mutex;
 use std::{collections::HashMap, sync::Arc};
 use tauri::{AppHandle, GlobalShortcutManager};
-use tauri_runtime_wry::wry::application::accelerator::Accelerator;
 
 pub struct Hotkey {
     current: Arc<Mutex<Vec<String>>>, // 保存当前的热键设置
@@ -35,7 +34,7 @@ impl Hotkey {
 
                 match (key, func) {
                     (Some(key), Some(func)) => {
-                        log_err!(Self::check_key(key).and_then(|_| self.register(key, func)));
+                        log_err!(self.register(key, func));
                     }
                     _ => {
                         let key = key.unwrap_or("None");
@@ -44,22 +43,12 @@ impl Hotkey {
                     }
                 }
             }
-            *self.current.lock() = hotkeys.clone();
+            self.current.lock().clone_from(hotkeys);
         }
 
         Ok(())
     }
 
-    /// 检查一个键是否合法
-    fn check_key(hotkey: &str) -> Result<()> {
-        // fix #287
-        // tauri的这几个方法全部有Result expect，会panic，先检测一遍避免挂了
-        if hotkey.parse::<Accelerator>().is_err() {
-            bail!("invalid hotkey `{hotkey}`");
-        }
-        Ok(())
-    }
-
     fn get_manager(&self) -> Result<impl GlobalShortcutManager> {
         let app_handle = self.app_handle.lock();
         if app_handle.is_none() {
@@ -76,16 +65,12 @@ impl Hotkey {
         }
 
         let f = match func.trim() {
+            "open_or_close_dashboard" => feat::open_or_close_dashboard,
             "clash_mode_rule" => || feat::change_clash_mode("rule".into()),
             "clash_mode_global" => || feat::change_clash_mode("global".into()),
             "clash_mode_direct" => || feat::change_clash_mode("direct".into()),
-            "clash_mode_script" => || feat::change_clash_mode("script".into()),
-            "toggle_system_proxy" => || feat::toggle_system_proxy(),
-            "enable_system_proxy" => || feat::enable_system_proxy(),
-            "disable_system_proxy" => || feat::disable_system_proxy(),
-            "toggle_tun_mode" => || feat::toggle_tun_mode(),
-            "enable_tun_mode" => || feat::enable_tun_mode(),
-            "disable_tun_mode" => || feat::disable_tun_mode(),
+            "toggle_system_proxy" => feat::toggle_system_proxy,
+            "toggle_tun_mode" => feat::toggle_tun_mode,
 
             _ => bail!("invalid function \"{func}\""),
         };
@@ -96,7 +81,7 @@ impl Hotkey {
     }
 
     fn unregister(&self, hotkey: &str) -> Result<()> {
-        self.get_manager()?.unregister(&hotkey)?;
+        self.get_manager()?.unregister(hotkey)?;
         log::info!(target: "app", "unregister hotkey {hotkey}");
         Ok(())
     }
@@ -108,11 +93,6 @@ impl Hotkey {
 
         let (del, add) = Self::get_diff(old_map, new_map);
 
-        // 先检查一遍所有新的热键是不是可以用的
-        for (hotkey, _) in add.iter() {
-            Self::check_key(hotkey)?;
-        }
-
         del.iter().for_each(|key| {
             let _ = self.unregister(key);
         });
@@ -125,7 +105,7 @@ impl Hotkey {
         Ok(())
     }
 
-    fn get_map_from_vec<'a>(hotkeys: &'a Vec<String>) -> HashMap<&'a str, &'a str> {
+    fn get_map_from_vec(hotkeys: &Vec<String>) -> HashMap<&str, &str> {
         let mut map = HashMap::new();
 
         hotkeys.iter().for_each(|hotkey| {
@@ -162,7 +142,7 @@ impl Hotkey {
         });
 
         new_map.iter().for_each(|(&key, &func)| {
-            if old_map.get(key).is_none() {
+            if !old_map.contains_key(key) {
                 add_list.push((key, func));
             }
         });

src-tauri/src/core/mod.rs

@@ -1,11 +1,13 @@
 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;
 pub mod tray;
-pub mod win_service;
+pub mod win_uwp;
 
 pub use self::core::*;

src-tauri/src/core/service.rs

@@ -0,0 +1,354 @@
+use crate::config::{Config, IVerge};
+use crate::core::handle;
+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;
+
+// Windows only
+
+const SERVICE_URL: &str = "http://127.0.0.1:33211";
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct ResponseBody {
+    pub core_type: Option<String>,
+    pub bin_path: String,
+    pub config_dir: String,
+    pub log_file: String,
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct JsonResponse {
+    pub code: u64,
+    pub msg: String,
+    pub data: Option<ResponseBody>,
+}
+
+/// Install the Clash Verge Service
+/// 该函数应该在协程或者线程中执行，避免UAC弹窗阻塞主线程
+///
+#[cfg(target_os = "windows")]
+pub async fn install_service() -> Result<()> {
+    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");
+
+    if !install_path.exists() {
+        bail!("installer exe not found");
+    }
+
+    let token = Token::with_current_process()?;
+    let level = token.privilege_level()?;
+
+    let status = match level {
+        PrivilegeLevel::NotPrivileged => RunasCommand::new(install_path).show(false).status()?,
+        _ => StdCommand::new(install_path)
+            .creation_flags(0x08000000)
+            .status()?,
+    };
+
+    if !status.success() {
+        bail!(
+            "failed to install service with status {}",
+            status.code().unwrap()
+        );
+    }
+
+    Ok(())
+}
+
+#[cfg(target_os = "linux")]
+pub async fn install_service() -> Result<()> {
+    use users::get_effective_uid;
+
+    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 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");
+    }
+
+    let token = Token::with_current_process()?;
+    let level = token.privilege_level()?;
+
+    let status = match level {
+        PrivilegeLevel::NotPrivileged => RunasCommand::new(uninstall_path).show(false).status()?,
+        _ => StdCommand::new(uninstall_path)
+            .creation_flags(0x08000000)
+            .status()?,
+    };
+
+    if !status.success() {
+        bail!(
+            "failed to uninstall service with status {}",
+            status.code().unwrap()
+        );
+    }
+
+    Ok(())
+}
+
+#[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 status = match get_effective_uid() {
+        0 => StdCommand::new(uninstaller_path).status()?,
+        _ => StdCommand::new(elevator)
+            .arg("sh")
+            .arg("-c")
+            .arg(uninstaller_path)
+            .status()?,
+    };
+
+    if !status.success() {
+        bail!(
+            "failed to install service with status {}",
+            status.code().unwrap()
+        );
+    }
+
+    Ok(())
+}
+
+#[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");
+
+    if !uninstaller_path.exists() {
+        bail!("uninstaller not found");
+    }
+
+    let shell = uninstaller_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(())
+}
+
+/// check the windows service status
+pub async fn check_service() -> Result<JsonResponse> {
+    let url = format!("{SERVICE_URL}/get_clash");
+    let response = reqwest::ClientBuilder::new()
+        .no_proxy()
+        .build()?
+        .get(url)
+        .send()
+        .await
+        .context("failed to connect to the Clash Verge Service")?
+        .json::<JsonResponse>()
+        .await
+        .context("failed to parse the Clash Verge Service response")?;
+
+    Ok(response)
+}
+
+/// start the clash by service
+pub(super) async fn run_core_by_service(config_file: &PathBuf) -> Result<()> {
+    let status = check_service().await?;
+
+    if status.code == 0 {
+        stop_core_by_service().await?;
+        sleep(Duration::from_secs(1)).await;
+    }
+
+    let clash_core = { Config::verge().latest().clash_core.clone() };
+    let 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 bin_ext = if cfg!(windows) { ".exe" } else { "" };
+    let clash_bin = format!("{clash_core}{bin_ext}");
+    let bin_path = current_exe()?.with_file_name(clash_bin);
+    let bin_path = dirs::path_to_str(&bin_path)?;
+
+    let config_dir = dirs::app_home_dir()?;
+    let config_dir = dirs::path_to_str(&config_dir)?;
+
+    let log_path = dirs::service_log_file()?;
+    let log_path = dirs::path_to_str(&log_path)?;
+
+    let config_file = dirs::path_to_str(config_file)?;
+
+    let mut map = HashMap::new();
+    map.insert("core_type", clash_core.as_str());
+    map.insert("bin_path", bin_path);
+    map.insert("config_dir", config_dir);
+    map.insert("config_file", config_file);
+    map.insert("log_file", log_path);
+
+    let url = format!("{SERVICE_URL}/start_clash");
+    let res = reqwest::ClientBuilder::new()
+        .no_proxy()
+        .build()?
+        .post(url)
+        .json(&map)
+        .send()
+        .await?
+        .json::<JsonResponse>()
+        .await
+        .context("failed to connect to the Clash Verge Service")?;
+
+    if res.code != 0 {
+        bail!(res.msg);
+    }
+
+    Ok(())
+}
+
+/// stop the clash by service
+pub(super) async fn stop_core_by_service() -> Result<()> {
+    let url = format!("{SERVICE_URL}/stop_clash");
+    let res = reqwest::ClientBuilder::new()
+        .no_proxy()
+        .build()?
+        .post(url)
+        .send()
+        .await?
+        .json::<JsonResponse>()
+        .await
+        .context("failed to connect to the Clash Verge Service")?;
+
+    if res.code != 0 {
+        bail!(res.msg);
+    }
+
+    Ok(())
+}
+
+/// 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(())
+}

src-tauri/src/core/sysopt.rs

@@ -1,11 +1,15 @@
-use crate::{config::Config, log_err};
+use crate::{
+    config::{Config, IVerge},
+    log_err,
+};
 use anyhow::{anyhow, Result};
 use auto_launch::{AutoLaunch, AutoLaunchBuilder};
 use once_cell::sync::OnceCell;
 use parking_lot::Mutex;
+use std::env::current_exe;
 use std::sync::Arc;
-use sysproxy::Sysproxy;
-use tauri::{async_runtime::Mutex as TokioMutex, utils::platform::current_exe};
+use sysproxy::{Autoproxy, Sysproxy};
+use tauri::async_runtime::Mutex as TokioMutex;
 
 pub struct Sysopt {
     /// current system proxy setting
@@ -15,6 +19,13 @@ pub struct Sysopt {
     /// 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>>>,
+
     /// helps to auto launch the app
     auto_launch: Arc<Mutex<Option<AutoLaunch>>>,
 
@@ -23,11 +34,48 @@ pub struct Sysopt {
 }
 
 #[cfg(target_os = "windows")]
-static DEFAULT_BYPASS: &str = "localhost;127.*;192.168.*;<local>";
+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/8,::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,::1";
 #[cfg(target_os = "macos")]
-static DEFAULT_BYPASS: &str = "127.0.0.1,localhost,<local>";
+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>";
+
+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();
+        let verge = verge.latest();
+        verge.system_proxy_bypass.clone()
+    };
+    let custom_bypass = match res {
+        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
+}
 
 impl Sysopt {
     pub fn global() -> &'static Sysopt {
@@ -36,6 +84,8 @@ impl Sysopt {
         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)),
         })
@@ -43,30 +93,52 @@ impl Sysopt {
 
     /// init the sysproxy
     pub fn init_sysproxy(&self) -> Result<()> {
-        let port = { Config::clash().latest().get_mixed_port() };
+        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, bypass) = {
+        let (enable, pac) = {
             let verge = Config::verge();
             let verge = verge.latest();
             (
-                verge.enable_system_proxy.clone().unwrap_or(false),
-                verge.system_proxy_bypass.clone(),
+                verge.enable_system_proxy.unwrap_or(false),
+                verge.proxy_auto_config.unwrap_or(false),
             )
         };
-
-        let current = Sysproxy {
+        let mut sys = Sysproxy {
             enable,
             host: String::from("127.0.0.1"),
             port,
-            bypass: bypass.unwrap_or(DEFAULT_BYPASS.into()),
+            bypass: get_bypass(),
         };
-
-        if enable {
-            let old = Sysproxy::get_system_proxy().map_or(None, |p| Some(p));
-            current.set_system_proxy()?;
-
+        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(current);
+            *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
@@ -78,28 +150,57 @@ impl Sysopt {
     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();
 
-        if cur_sysproxy.is_none() || old_sysproxy.is_none() {
+        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();
         }
 
-        let (enable, bypass) = {
-            let verge = Config::verge();
-            let verge = verge.latest();
-            (
-                verge.enable_system_proxy.clone().unwrap_or(false),
-                verge.system_proxy_bypass.clone(),
-            )
-        };
+        let port = Config::verge()
+            .latest()
+            .verge_mixed_port
+            .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;
 
-        sysproxy.enable = enable;
-        sysproxy.bypass = bypass.unwrap_or(DEFAULT_BYPASS.into());
+        let mut autoproxy = cur_autoproxy.take().unwrap();
+        autoproxy.url = format!("http://127.0.0.1:{pac_port}/commands/pac");
 
-        sysproxy.set_system_proxy()?;
-        *cur_sysproxy = Some(sysproxy);
+        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);
+        }
 
         Ok(())
     }
@@ -108,8 +209,11 @@ impl Sysopt {
     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关闭，否则就恢复原代理设置
@@ -133,16 +237,35 @@ impl Sysopt {
             log::info!(target: "app", "reset proxy with no action");
         }
 
+        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 enable = { Config::verge().latest().enable_auto_launch.clone() };
-        let enable = enable.unwrap_or(false);
-
         let app_exe = current_exe()?;
-        let app_exe = dunce::canonicalize(app_exe)?;
+        // let app_exe = dunce::canonicalize(app_exe)?;
         let app_name = app_exe
             .file_stem()
             .and_then(|f| f.to_str())
@@ -171,24 +294,29 @@ impl Sysopt {
         })()
         .unwrap_or(app_path);
 
+        // fix #403
+        #[cfg(target_os = "linux")]
+        let app_path = {
+            use crate::core::handle::Handle;
+            use tauri::Manager;
+
+            let handle = Handle::global();
+            match handle.app_handle.lock().as_ref() {
+                Some(app_handle) => {
+                    let appimage = app_handle.env().appimage;
+                    appimage
+                        .and_then(|p| p.to_str().map(|s| s.to_string()))
+                        .unwrap_or(app_path)
+                }
+                None => app_path,
+            }
+        };
+
         let auto = AutoLaunchBuilder::new()
             .set_app_name(app_name)
             .set_app_path(&app_path)
             .build()?;
 
-        // 避免在开发时将自启动关了
-        #[cfg(feature = "verge-dev")]
-        if !enable {
-            return Ok(());
-        }
-
-        // macos每次启动都更新登录项，避免重复设置登录项
-        #[cfg(target_os = "macos")]
-        let _ = auto.disable();
-
-        if enable {
-            auto.enable()?;
-        }
         *self.auto_launch.lock() = Some(auto);
 
         Ok(())
@@ -202,7 +330,7 @@ impl Sysopt {
             drop(auto_launch);
             return self.init_launch();
         }
-        let enable = { Config::verge().latest().enable_auto_launch.clone() };
+        let enable = { Config::verge().latest().enable_auto_launch };
         let enable = enable.unwrap_or(false);
         let auto_launch = auto_launch.as_ref().unwrap();
 
@@ -236,14 +364,14 @@ impl Sysopt {
             loop {
                 sleep(Duration::from_secs(wait_secs)).await;
 
-                let (enable, guard, guard_duration, bypass) = {
+                let (enable, guard, guard_duration, pac) = {
                     let verge = Config::verge();
                     let verge = verge.latest();
                     (
-                        verge.enable_system_proxy.clone().unwrap_or(false),
-                        verge.enable_proxy_guard.clone().unwrap_or(false),
-                        verge.proxy_guard_duration.clone().unwrap_or(10),
-                        verge.system_proxy_bypass.clone(),
+                        verge.enable_system_proxy.unwrap_or(false),
+                        verge.enable_proxy_guard.unwrap_or(false),
+                        verge.proxy_guard_duration.unwrap_or(10),
+                        verge.proxy_auto_config.unwrap_or(false),
                     )
                 };
 
@@ -257,16 +385,29 @@ impl Sysopt {
 
                 log::debug!(target: "app", "try to guard the system proxy");
 
-                let port = { Config::clash().latest().get_mixed_port() };
-
-                let sysproxy = Sysproxy {
-                    enable: true,
-                    host: "127.0.0.1".into(),
-                    port,
-                    bypass: bypass.unwrap_or(DEFAULT_BYPASS.into()),
+                let port = {
+                    Config::verge()
+                        .latest()
+                        .verge_mixed_port
+                        .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(),
+                    };
 
-                log_err!(sysproxy.set_system_proxy());
+                    log_err!(sysproxy.set_system_proxy());
+                }
             }
 
             let mut state = guard_state.lock().await;

src-tauri/src/core/timer.rs

@@ -40,7 +40,7 @@ impl Timer {
         let timer_map = self.timer_map.lock();
         let delay_timer = self.delay_timer.lock();
 
-        Config::profiles().latest().get_items().map(|items| {
+        if let Some(items) = Config::profiles().latest().get_items() {
             items
                 .iter()
                 .filter_map(|item| {
@@ -61,7 +61,7 @@ impl Timer {
                         }
                     }
                 })
-        });
+        }
 
         Ok(())
     }

src-tauri/src/core/tray.rs

@@ -1,4 +1,9 @@
-use crate::{config::Config, feat, utils::resolve};
+use crate::{
+    cmds,
+    config::Config,
+    feat,
+    utils::{dirs, resolve},
+};
 use anyhow::Result;
 use tauri::{
     api, AppHandle, CustomMenuItem, Manager, SystemTrayEvent, SystemTrayMenu, SystemTrayMenuItem,
@@ -13,53 +18,77 @@ impl Tray {
 
         let version = app_handle.package_info().version.to_string();
 
-        if zh {
-            SystemTrayMenu::new()
-                .add_item(CustomMenuItem::new("open_window", "打开面板"))
-                .add_native_item(SystemTrayMenuItem::Separator)
-                .add_item(CustomMenuItem::new("rule_mode", "规则模式"))
-                .add_item(CustomMenuItem::new("global_mode", "全局模式"))
-                .add_item(CustomMenuItem::new("direct_mode", "直连模式"))
-                .add_item(CustomMenuItem::new("script_mode", "脚本模式"))
-                .add_native_item(SystemTrayMenuItem::Separator)
-                .add_item(CustomMenuItem::new("system_proxy", "系统代理"))
-                .add_item(CustomMenuItem::new("tun_mode", "TUN 模式"))
-                .add_submenu(SystemTraySubmenu::new(
-                    "更多",
-                    SystemTrayMenu::new()
-                        .add_item(CustomMenuItem::new("restart_clash", "重启 Clash"))
-                        .add_item(CustomMenuItem::new("restart_app", "重启应用"))
-                        .add_item(
-                            CustomMenuItem::new("app_version", format!("Version {version}"))
-                                .disabled(),
-                        ),
-                ))
-                .add_native_item(SystemTrayMenuItem::Separator)
-                .add_item(CustomMenuItem::new("quit", "退出").accelerator("CmdOrControl+Q"))
-        } else {
-            SystemTrayMenu::new()
-                .add_item(CustomMenuItem::new("open_window", "Dashboard"))
-                .add_native_item(SystemTrayMenuItem::Separator)
-                .add_item(CustomMenuItem::new("rule_mode", "Rule Mode"))
-                .add_item(CustomMenuItem::new("global_mode", "Global Mode"))
-                .add_item(CustomMenuItem::new("direct_mode", "Direct Mode"))
-                .add_item(CustomMenuItem::new("script_mode", "Script Mode"))
-                .add_native_item(SystemTrayMenuItem::Separator)
-                .add_item(CustomMenuItem::new("system_proxy", "System Proxy"))
-                .add_item(CustomMenuItem::new("tun_mode", "Tun Mode"))
-                .add_submenu(SystemTraySubmenu::new(
-                    "More",
-                    SystemTrayMenu::new()
-                        .add_item(CustomMenuItem::new("restart_clash", "Restart Clash"))
-                        .add_item(CustomMenuItem::new("restart_app", "Restart App"))
-                        .add_item(
-                            CustomMenuItem::new("app_version", format!("Version {version}"))
-                                .disabled(),
-                        ),
-                ))
-                .add_native_item(SystemTrayMenuItem::Separator)
-                .add_item(CustomMenuItem::new("quit", "Quit").accelerator("CmdOrControl+Q"))
+        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<()> {
@@ -71,6 +100,20 @@ impl Tray {
     }
 
     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()
@@ -86,44 +129,220 @@ impl Tray {
         let _ = tray.get_item("rule_mode").set_selected(mode == "rule");
         let _ = tray.get_item("global_mode").set_selected(mode == "global");
         let _ = tray.get_item("direct_mode").set_selected(mode == "direct");
-        let _ = tray.get_item("script_mode").set_selected(mode == "script");
+
+        #[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" | "script_mode") => {
+                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" => {
-                    resolve::resolve_reset();
-                    api::process::kill_children();
-                    app_handle.exit(0);
-                    std::process::exit(0);
-                }
+                "quit" => cmds::exit_app(app_handle.clone()),
+
                 _ => {}
             },
-            #[cfg(target_os = "windows")]
-            SystemTrayEvent::LeftClick { .. } => {
-                resolve::create_window(app_handle);
-            }
             _ => {}
         }
     }

src-tauri/src/core/win_service.rs

@@ -1,178 +0,0 @@
-#![cfg(target_os = "windows")]
-
-use crate::config::Config;
-use crate::utils::dirs;
-use anyhow::{bail, Context, Result};
-use deelevate::{PrivilegeLevel, Token};
-use runas::Command as RunasCommand;
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-use std::os::windows::process::CommandExt;
-use std::path::PathBuf;
-use std::time::Duration;
-use std::{env::current_exe, process::Command as StdCommand};
-use tokio::time::sleep;
-
-const SERVICE_URL: &str = "http://127.0.0.1:33211";
-
-#[derive(Debug, Deserialize, Serialize, Clone)]
-pub struct ResponseBody {
-    pub core_type: Option<String>,
-    pub bin_path: String,
-    pub config_dir: String,
-    pub log_file: String,
-}
-
-#[derive(Debug, Deserialize, Serialize, Clone)]
-pub struct JsonResponse {
-    pub code: u64,
-    pub msg: String,
-    pub data: Option<ResponseBody>,
-}
-
-/// Install the Clash Verge Service
-/// 该函数应该在协程或者线程中执行，避免UAC弹窗阻塞主线程
-pub async fn install_service() -> Result<()> {
-    let binary_path = dirs::service_path()?;
-    let install_path = binary_path.with_file_name("install-service.exe");
-
-    if !install_path.exists() {
-        bail!("installer exe not found");
-    }
-
-    let token = Token::with_current_process()?;
-    let level = token.privilege_level()?;
-
-    let status = match level {
-        PrivilegeLevel::NotPrivileged => RunasCommand::new(install_path).show(false).status()?,
-        _ => StdCommand::new(install_path)
-            .creation_flags(0x08000000)
-            .status()?,
-    };
-
-    if !status.success() {
-        bail!(
-            "failed to install service with status {}",
-            status.code().unwrap()
-        );
-    }
-
-    Ok(())
-}
-
-/// Uninstall the Clash Verge Service
-/// 该函数应该在协程或者线程中执行，避免UAC弹窗阻塞主线程
-pub async fn uninstall_service() -> Result<()> {
-    let binary_path = dirs::service_path()?;
-    let uninstall_path = binary_path.with_file_name("uninstall-service.exe");
-
-    if !uninstall_path.exists() {
-        bail!("uninstaller exe not found");
-    }
-
-    let token = Token::with_current_process()?;
-    let level = token.privilege_level()?;
-
-    let status = match level {
-        PrivilegeLevel::NotPrivileged => RunasCommand::new(uninstall_path).show(false).status()?,
-        _ => StdCommand::new(uninstall_path)
-            .creation_flags(0x08000000)
-            .status()?,
-    };
-
-    if !status.success() {
-        bail!(
-            "failed to uninstall service with status {}",
-            status.code().unwrap()
-        );
-    }
-
-    Ok(())
-}
-
-/// check the windows service status
-pub async fn check_service() -> Result<JsonResponse> {
-    let url = format!("{SERVICE_URL}/get_clash");
-    let response = reqwest::ClientBuilder::new()
-        .no_proxy()
-        .build()?
-        .get(url)
-        .send()
-        .await
-        .context("failed to connect to the Clash Verge Service")?
-        .json::<JsonResponse>()
-        .await
-        .context("failed to parse the Clash Verge Service response")?;
-
-    Ok(response)
-}
-
-/// start the clash by service
-pub(super) async fn run_core_by_service(config_file: &PathBuf) -> Result<()> {
-    let status = check_service().await?;
-
-    if status.code == 0 {
-        stop_core_by_service().await?;
-        sleep(Duration::from_secs(1)).await;
-    }
-
-    let clash_core = { Config::verge().latest().clash_core.clone() };
-    let clash_core = clash_core.unwrap_or("clash".into());
-
-    let clash_bin = format!("{clash_core}.exe");
-    let bin_path = current_exe()?.with_file_name(clash_bin);
-    let bin_path = dirs::path_to_str(&bin_path)?;
-
-    let config_dir = dirs::app_home_dir()?;
-    let config_dir = dirs::path_to_str(&config_dir)?;
-
-    let log_path = dirs::service_log_file()?;
-    let log_path = dirs::path_to_str(&log_path)?;
-
-    let config_file = dirs::path_to_str(config_file)?;
-
-    let mut map = HashMap::new();
-    map.insert("core_type", clash_core.as_str());
-    map.insert("bin_path", bin_path);
-    map.insert("config_dir", config_dir);
-    map.insert("config_file", config_file);
-    map.insert("log_file", log_path);
-
-    let url = format!("{SERVICE_URL}/start_clash");
-    let res = reqwest::ClientBuilder::new()
-        .no_proxy()
-        .build()?
-        .post(url)
-        .json(&map)
-        .send()
-        .await?
-        .json::<JsonResponse>()
-        .await
-        .context("failed to connect to the Clash Verge Service")?;
-
-    if res.code != 0 {
-        bail!(res.msg);
-    }
-
-    Ok(())
-}
-
-/// stop the clash by service
-pub(super) async fn stop_core_by_service() -> Result<()> {
-    let url = format!("{SERVICE_URL}/stop_clash");
-    let res = reqwest::ClientBuilder::new()
-        .no_proxy()
-        .build()?
-        .post(url)
-        .send()
-        .await?
-        .json::<JsonResponse>()
-        .await
-        .context("failed to connect to the Clash Verge Service")?;
-
-    if res.code != 0 {
-        bail!(res.msg);
-    }
-
-    Ok(())
-}

src-tauri/src/core/win_uwp.rs

@@ -0,0 +1,26 @@
+#![cfg(target_os = "windows")]
+
+use crate::utils::dirs;
+use anyhow::{bail, Result};
+use deelevate::{PrivilegeLevel, Token};
+use runas::Command as RunasCommand;
+use std::process::Command as StdCommand;
+
+pub async fn invoke_uwptools() -> Result<()> {
+    let resource_dir = dirs::app_resources_dir()?;
+    let tool_path = resource_dir.join("enableLoopback.exe");
+
+    if !tool_path.exists() {
+        bail!("enableLoopback exe not found");
+    }
+
+    let token = Token::with_current_process()?;
+    let level = token.privilege_level()?;
+
+    match level {
+        PrivilegeLevel::NotPrivileged => RunasCommand::new(tool_path).status()?,
+        _ => StdCommand::new(tool_path).status()?,
+    };
+
+    Ok(())
+}

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

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

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

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

src-tauri/src/enhance/chain.rs

@@ -1,3 +1,4 @@
+use super::SeqMap;
 use crate::{
     config::PrfItem,
     utils::{dirs, help},
@@ -15,12 +16,16 @@ pub struct ChainItem {
 pub enum ChainType {
     Merge(Mapping),
     Script(String),
+    Rules(SeqMap),
+    Proxies(SeqMap),
+    Groups(SeqMap),
 }
 
 #[derive(Debug, Clone)]
 pub enum ChainSupport {
     Clash,
     ClashMeta,
+    ClashMetaAlpha,
     All,
 }
 
@@ -42,7 +47,19 @@ impl From<&PrfItem> for Option<ChainItem> {
             }),
             "merge" => Some(ChainItem {
                 uid,
-                data: ChainType::Merge(help::read_merge_mapping(&path).ok()?),
+                data: ChainType::Merge(help::read_mapping(&path).ok()?),
+            }),
+            "rules" => Some(ChainItem {
+                uid,
+                data: ChainType::Rules(help::read_seq_map(&path).ok()?),
+            }),
+            "proxies" => Some(ChainItem {
+                uid,
+                data: ChainType::Proxies(help::read_seq_map(&path).ok()?),
+            }),
+            "groups" => Some(ChainItem {
+                uid,
+                data: ChainType::Groups(help::read_seq_map(&path).ok()?),
             }),
             _ => None,
         }
@@ -60,9 +77,19 @@ impl ChainItem {
         let hy_alpn =
             ChainItem::to_script("verge_hy_alpn", include_str!("./builtin/meta_hy_alpn.js"));
 
+        // meta 的一些处理
+        let meta_guard_alpha =
+            ChainItem::to_script("verge_meta_guard", include_str!("./builtin/meta_guard.js"));
+
+        // meta 1.13.2 alpn string 转 数组
+        let hy_alpn_alpha =
+            ChainItem::to_script("verge_hy_alpn", include_str!("./builtin/meta_hy_alpn.js"));
+
         vec![
             (ChainSupport::ClashMeta, hy_alpn),
             (ChainSupport::ClashMeta, meta_guard),
+            (ChainSupport::ClashMetaAlpha, hy_alpn_alpha),
+            (ChainSupport::ClashMetaAlpha, meta_guard_alpha),
         ]
     }
 
@@ -77,12 +104,13 @@ impl ChainItem {
 impl ChainSupport {
     pub fn is_support(&self, core: Option<&String>) -> bool {
         match core {
-            Some(core) => match (self, core.as_str()) {
-                (ChainSupport::All, _) => true,
-                (ChainSupport::Clash, "clash") => true,
-                (ChainSupport::ClashMeta, "clash-meta") => true,
-                _ => false,
-            },
+            Some(core) => matches!(
+                (self, core.as_str()),
+                (ChainSupport::All, _)
+                    | (ChainSupport::Clash, "clash")
+                    | (ChainSupport::ClashMeta, "verge-mihomo")
+                    | (ChainSupport::ClashMetaAlpha, "verge-mihomo-alpha")
+            ),
             None => true,
         }
     }

src-tauri/src/enhance/field.rs

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

src-tauri/src/enhance/merge.rs

@@ -1,56 +1,25 @@
-use super::{use_filter, use_lowercase};
-use serde_yaml::{self, Mapping, Sequence, Value};
+use super::use_lowercase;
+use serde_yaml::{self, Mapping, Value};
 
-#[allow(unused)]
-const MERGE_FIELDS: [&str; 6] = [
-    "prepend-rules",
-    "append-rules",
-    "prepend-proxies",
-    "append-proxies",
-    "prepend-proxy-groups",
-    "append-proxy-groups",
-];
-
-pub fn use_merge(merge: Mapping, mut config: Mapping) -> Mapping {
-    // 直接覆盖原字段
-    use_lowercase(merge.clone())
-        .into_iter()
-        .for_each(|(key, value)| {
-            config.insert(key, value);
-        });
-
-    let merge_list = MERGE_FIELDS.iter().map(|s| s.to_string());
-    let merge = use_filter(merge, &merge_list.collect());
-
-    ["rules", "proxies", "proxy-groups"]
-        .iter()
-        .for_each(|key_str| {
-            let key_val = Value::from(key_str.to_string());
-
-            let mut list = Sequence::default();
-            list = config.get(&key_val).map_or(list.clone(), |val| {
-                val.as_sequence().map_or(list, |v| v.clone())
-            });
-
-            let pre_key = Value::from(format!("prepend-{key_str}"));
-            let post_key = Value::from(format!("append-{key_str}"));
-
-            if let Some(pre_val) = merge.get(&pre_key) {
-                if pre_val.is_sequence() {
-                    let mut pre_val = pre_val.as_sequence().unwrap().clone();
-                    pre_val.extend(list);
-                    list = pre_val;
-                }
+fn deep_merge(a: &mut Value, b: &Value) {
+    match (a, b) {
+        (&mut Value::Mapping(ref mut a), Value::Mapping(b)) => {
+            for (k, v) in b {
+                deep_merge(a.entry(k.clone()).or_insert(Value::Null), v);
             }
+        }
+        (a, b) => *a = b.clone(),
+    }
+}
 
-            if let Some(post_val) = merge.get(&post_key) {
-                if post_val.is_sequence() {
-                    list.extend(post_val.as_sequence().unwrap().clone());
-                }
-            }
+pub fn use_merge(merge: Mapping, config: Mapping) -> Mapping {
+    let mut config = Value::from(config);
+    let merge = use_lowercase(merge.clone());
+
+    deep_merge(&mut config, &Value::from(merge));
+
+    let config = config.as_mapping().unwrap().clone();
 
-            config.insert(key_val, Value::from(list));
-        });
     config
 }
 

src-tauri/src/enhance/mod.rs

@@ -1,16 +1,18 @@
 mod chain;
-mod field;
+pub mod field;
 mod merge;
 mod script;
+pub mod seq;
 mod tun;
 
-pub(self) use self::field::*;
-
 use self::chain::*;
+use self::field::*;
 use self::merge::*;
 use self::script::*;
+use self::seq::*;
 use self::tun::*;
 use crate::config::Config;
+use crate::utils::tmpl;
 use serde_yaml::Mapping;
 use std::collections::HashMap;
 use std::collections::HashSet;
@@ -18,107 +20,242 @@ use std::collections::HashSet;
 type ResultLog = Vec<(String, String)>;
 
 /// Enhance mode
-/// 返回最终配置、该配置包含的键、和script执行的结果
-pub fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
-    // config.yaml 的配置
+/// 返回最终订阅、该订阅包含的键、和script执行的结果
+pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
+    // config.yaml 的订阅
     let clash_config = { Config::clash().latest().0.clone() };
 
-    let (clash_core, tun_mode, enable_builtin) = {
+    let (clash_core, enable_tun, enable_builtin, socks_enabled, http_enabled) = {
         let verge = Config::verge();
         let verge = verge.latest();
         (
             verge.clash_core.clone(),
-            verge.enable_tun_mode.clone(),
-            verge.enable_builtin_enhanced.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),
         )
     };
+    #[cfg(not(target_os = "windows"))]
+    let redir_enabled = {
+        let verge = Config::verge();
+        let verge = verge.latest();
+        verge.verge_redir_enabled.unwrap_or(true)
+    };
+    #[cfg(target_os = "linux")]
+    let tproxy_enabled = {
+        let verge = Config::verge();
+        let verge = verge.latest();
+        verge.verge_tproxy_enabled.unwrap_or(true)
+    };
 
     // 从profiles里拿东西
-    let (mut config, chain, valid) = {
+    let (
+        mut config,
+        merge_item,
+        script_item,
+        rules_item,
+        proxies_item,
+        groups_item,
+        global_merge,
+        global_script,
+    ) = {
         let profiles = Config::profiles();
         let profiles = profiles.latest();
 
-        let current = profiles.current_mapping().unwrap_or(Mapping::new());
+        let current = profiles.current_mapping().unwrap_or_default();
+        let merge = profiles
+            .get_item(&profiles.current_merge().unwrap_or_default())
+            .ok()
+            .and_then(<Option<ChainItem>>::from)
+            .unwrap_or_else(|| ChainItem {
+                uid: "".into(),
+                data: ChainType::Merge(Mapping::new()),
+            });
+        let script = profiles
+            .get_item(&profiles.current_script().unwrap_or_default())
+            .ok()
+            .and_then(<Option<ChainItem>>::from)
+            .unwrap_or_else(|| ChainItem {
+                uid: "".into(),
+                data: ChainType::Script(tmpl::ITEM_SCRIPT.into()),
+            });
+        let rules = profiles
+            .get_item(&profiles.current_rules().unwrap_or_default())
+            .ok()
+            .and_then(<Option<ChainItem>>::from)
+            .unwrap_or_else(|| ChainItem {
+                uid: "".into(),
+                data: ChainType::Rules(SeqMap::default()),
+            });
+        let proxies = profiles
+            .get_item(&profiles.current_proxies().unwrap_or_default())
+            .ok()
+            .and_then(<Option<ChainItem>>::from)
+            .unwrap_or_else(|| ChainItem {
+                uid: "".into(),
+                data: ChainType::Proxies(SeqMap::default()),
+            });
+        let groups = profiles
+            .get_item(&profiles.current_groups().unwrap_or_default())
+            .ok()
+            .and_then(<Option<ChainItem>>::from)
+            .unwrap_or_else(|| ChainItem {
+                uid: "".into(),
+                data: ChainType::Groups(SeqMap::default()),
+            });
 
-        let chain = match profiles.chain.as_ref() {
-            Some(chain) => chain
-                .iter()
-                .filter_map(|uid| profiles.get_item(uid).ok())
-                .filter_map(|item| <Option<ChainItem>>::from(item))
-                .collect::<Vec<ChainItem>>(),
-            None => vec![],
-        };
+        let global_merge = profiles
+            .get_item(&"Merge".to_string())
+            .ok()
+            .and_then(<Option<ChainItem>>::from)
+            .unwrap_or_else(|| ChainItem {
+                uid: "Merge".into(),
+                data: ChainType::Merge(Mapping::new()),
+            });
 
-        let valid = profiles.valid.clone().unwrap_or(vec![]);
+        let global_script = profiles
+            .get_item(&"Script".to_string())
+            .ok()
+            .and_then(<Option<ChainItem>>::from)
+            .unwrap_or_else(|| ChainItem {
+                uid: "Script".into(),
+                data: ChainType::Script(tmpl::ITEM_SCRIPT.into()),
+            });
 
-        (current, chain, valid)
+        (
+            current,
+            merge,
+            script,
+            rules,
+            proxies,
+            groups,
+            global_merge,
+            global_script,
+        )
     };
 
     let mut result_map = HashMap::new(); // 保存脚本日志
     let mut exists_keys = use_keys(&config); // 保存出现过的keys
 
-    let valid = use_valid_fields(valid);
-    config = use_filter(config, &valid);
+    // 全局Merge和Script
+    if let ChainType::Merge(merge) = global_merge.data {
+        exists_keys.extend(use_keys(&merge));
+        config = use_merge(merge, config.to_owned());
+    }
 
-    // 处理用户的profile
-    chain.into_iter().for_each(|item| match item.data {
-        ChainType::Merge(merge) => {
-            exists_keys.extend(use_keys(&merge));
-            config = use_merge(merge, config.to_owned());
-            config = use_filter(config.to_owned(), &valid);
-        }
-        ChainType::Script(script) => {
-            let mut logs = vec![];
+    if let ChainType::Script(script) = global_script.data {
+        let mut logs = vec![];
 
-            match use_script(script, config.to_owned()) {
-                Ok((res_config, res_logs)) => {
-                    exists_keys.extend(use_keys(&res_config));
-                    config = use_filter(res_config, &valid);
-                    logs.extend(res_logs);
-                }
-                Err(err) => logs.push(("exception".into(), err.to_string())),
+        match use_script(script, config.to_owned()) {
+            Ok((res_config, res_logs)) => {
+                exists_keys.extend(use_keys(&res_config));
+                config = res_config;
+                logs.extend(res_logs);
             }
-
-            result_map.insert(item.uid, logs);
+            Err(err) => logs.push(("exception".into(), err.to_string())),
         }
-    });
+
+        result_map.insert(global_script.uid, logs);
+    }
+
+    // 订阅关联的Merge、Script、Rules、Proxies、Groups
+    if let ChainType::Rules(rules) = rules_item.data {
+        config = use_seq(rules, config.to_owned(), "rules");
+    }
+
+    if let ChainType::Proxies(proxies) = proxies_item.data {
+        config = use_seq(proxies, config.to_owned(), "proxies");
+    }
+
+    if let ChainType::Groups(groups) = groups_item.data {
+        config = use_seq(groups, config.to_owned(), "proxy-groups");
+    }
+
+    if let ChainType::Merge(merge) = merge_item.data {
+        exists_keys.extend(use_keys(&merge));
+        config = use_merge(merge, config.to_owned());
+    }
+
+    if let ChainType::Script(script) = script_item.data {
+        let mut logs = vec![];
+
+        match use_script(script, config.to_owned()) {
+            Ok((res_config, res_logs)) => {
+                exists_keys.extend(use_keys(&res_config));
+                config = res_config;
+                logs.extend(res_logs);
+            }
+            Err(err) => logs.push(("exception".into(), err.to_string())),
+        }
+
+        result_map.insert(script_item.uid, logs);
+    }
 
     // 合并默认的config
     for (key, value) in clash_config.into_iter() {
-        config.insert(key, value);
+        if key.as_str() == Some("tun") {
+            let mut tun = config.get_mut("tun").map_or(Mapping::new(), |val| {
+                val.as_mapping().cloned().unwrap_or(Mapping::new())
+            });
+            let patch_tun = value.as_mapping().cloned().unwrap_or(Mapping::new());
+            for (key, value) in patch_tun.into_iter() {
+                tun.insert(key, value);
+            }
+            config.insert("tun".into(), tun.into());
+        } else {
+            if key.as_str() == Some("socks-port") && !socks_enabled {
+                config.remove("socks-port");
+                continue;
+            }
+            if key.as_str() == Some("port") && !http_enabled {
+                config.remove("port");
+                continue;
+            }
+            #[cfg(not(target_os = "windows"))]
+            {
+                if key.as_str() == Some("redir-port") && !redir_enabled {
+                    config.remove("redir-port");
+                    continue;
+                }
+            }
+            #[cfg(target_os = "linux")]
+            {
+                if key.as_str() == Some("tproxy-port") && !tproxy_enabled {
+                    config.remove("tproxy-port");
+                    continue;
+                }
+            }
+            config.insert(key, value);
+        }
     }
 
-    let clash_fields = use_clash_fields();
-
     // 内建脚本最后跑
-    if enable_builtin.unwrap_or(true) {
+    if enable_builtin {
         ChainItem::builtin()
             .into_iter()
             .filter(|(s, _)| s.is_support(clash_core.as_ref()))
             .map(|(_, c)| c)
             .for_each(|item| {
                 log::debug!(target: "app", "run builtin script {}", item.uid);
-
-                match item.data {
-                    ChainType::Script(script) => match use_script(script, config.to_owned()) {
+                if let ChainType::Script(script) = item.data {
+                    match use_script(script, config.to_owned()) {
                         Ok((res_config, _)) => {
-                            config = use_filter(res_config, &clash_fields);
+                            config = res_config;
                         }
                         Err(err) => {
                             log::error!(target: "app", "builtin script error `{err}`");
                         }
-                    },
-                    _ => {}
+                    }
                 }
             });
     }
 
-    config = use_filter(config, &clash_fields);
-    config = use_tun(config, tun_mode.unwrap_or(false));
+    config = use_tun(config, enable_tun).await;
     config = use_sort(config);
 
     let mut exists_set = HashSet::new();
-    exists_set.extend(exists_keys.into_iter().filter(|s| clash_fields.contains(s)));
+    exists_set.extend(exists_keys);
     exists_keys = exists_set.into_iter().collect();
 
     (config, exists_keys, result_map)

src-tauri/src/enhance/script.rs

@@ -1,62 +1,75 @@
 use super::use_lowercase;
-use anyhow::Result;
+use anyhow::{Error, Result};
 use serde_yaml::Mapping;
 
 pub fn use_script(script: String, config: Mapping) -> Result<(Mapping, Vec<(String, String)>)> {
-    use rquickjs::{Context, Func, Runtime};
+    use boa_engine::{native_function::NativeFunction, Context, JsValue, Source};
     use std::sync::{Arc, Mutex};
+    let mut context = Context::default();
 
-    let runtime = Runtime::new().unwrap();
-    let context = Context::full(&runtime).unwrap();
     let outputs = Arc::new(Mutex::new(vec![]));
 
     let copy_outputs = outputs.clone();
-    let result = context.with(|ctx| -> Result<Mapping> {
-        ctx.globals().set(
-            "__verge_log__",
-            Func::from(move |level: String, data: String| {
-                let mut out = copy_outputs.lock().unwrap();
-                out.push((level, data));
-            }),
-        )?;
-
-        ctx.eval(
-            r#"var console = Object.freeze({
+    unsafe {
+        let _ = context.register_global_builtin_callable(
+            "__verge_log__".into(),
+            2,
+            NativeFunction::from_closure(
+                move |_: &JsValue, args: &[JsValue], context: &mut Context| {
+                    let level = args.first().unwrap().to_string(context)?;
+                    let level = level.to_std_string().unwrap();
+                    let data = args.get(1).unwrap().to_string(context)?;
+                    let data = data.to_std_string().unwrap();
+                    let mut out = copy_outputs.lock().unwrap();
+                    out.push((level, data));
+                    Ok(JsValue::undefined())
+                },
+            ),
+        );
+    }
+    let _ = context.eval(Source::from_bytes(
+        r#"var console = Object.freeze({
         log(data){__verge_log__("log",JSON.stringify(data))}, 
         info(data){__verge_log__("info",JSON.stringify(data))}, 
         error(data){__verge_log__("error",JSON.stringify(data))},
         debug(data){__verge_log__("debug",JSON.stringify(data))},
       });"#,
-        )?;
+    ));
 
-        let config = use_lowercase(config.clone());
-        let config_str = serde_json::to_string(&config)?;
+    let config = use_lowercase(config.clone());
+    let config_str = serde_json::to_string(&config)?;
 
-        let code = format!(
-            r#"try{{
+    let code = format!(
+        r#"try{{
         {script};
         JSON.stringify(main({config_str})||'')
       }} catch(err) {{
         `__error_flag__ ${{err.toString()}}`
       }}"#
-        );
-        let result: String = ctx.eval(code.as_str())?;
+    );
+    if let Ok(result) = context.eval(Source::from_bytes(code.as_str())) {
+        if !result.is_string() {
+            anyhow::bail!("main function should return object");
+        }
+        let result = result.to_string(&mut context).unwrap();
+        let result = result.to_std_string().unwrap();
         if result.starts_with("__error_flag__") {
             anyhow::bail!(result[15..].to_owned());
         }
         if result == "\"\"" {
             anyhow::bail!("main function should return object");
         }
-        return Ok(serde_json::from_str::<Mapping>(result.as_str())?);
-    });
-
-    let mut out = outputs.lock().unwrap();
-    match result {
-        Ok(config) => Ok((use_lowercase(config), out.to_vec())),
-        Err(err) => {
-            out.push(("exception".into(), err.to_string()));
-            Ok((config, out.to_vec()))
+        let res: Result<Mapping, Error> = Ok(serde_json::from_str::<Mapping>(result.as_str())?);
+        let mut out = outputs.lock().unwrap();
+        match res {
+            Ok(config) => Ok((use_lowercase(config), out.to_vec())),
+            Err(err) => {
+                out.push(("exception".into(), err.to_string()));
+                Ok((config, out.to_vec()))
+            }
         }
+    } else {
+        anyhow::bail!("main function should return object");
     }
 }
 

src-tauri/src/enhance/seq.rs

@@ -0,0 +1,53 @@
+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 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;
+
+    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);
+    }
+
+    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());
+        }
+    }
+    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;
+}

src-tauri/src/enhance/tun.rs

@@ -1,3 +1,4 @@
+use crate::{core::service, log_err};
 use serde_yaml::{Mapping, Value};
 
 macro_rules! revise {
@@ -17,7 +18,7 @@ macro_rules! append {
     };
 }
 
-pub fn use_tun(mut config: Mapping, enable: bool) -> Mapping {
+pub async fn use_tun(mut config: Mapping, enable: bool) -> Mapping {
     let tun_key = Value::from("tun");
     let tun_val = config.get(&tun_key);
 
@@ -30,18 +31,14 @@ pub fn use_tun(mut config: Mapping, enable: bool) -> Mapping {
     });
 
     revise!(tun_val, "enable", enable);
-    if enable {
-        append!(tun_val, "stack", "gvisor");
-        append!(tun_val, "dns-hijack", vec!["any:53"]);
-        append!(tun_val, "auto-route", true);
-        append!(tun_val, "auto-detect-interface", true);
-    }
 
     revise!(config, "tun", tun_val);
 
     if enable {
+        log_err!(service::set_dns_by_service().await);
         use_dns_for_tun(config)
     } else {
+        log_err!(service::unset_dns_by_service().await);
         config
     }
 }