```

nothing changes
```

.cargo/config.toml

@@ -0,0 +1,5 @@
+[target.aarch64-unknown-linux-gnu]
+linker = "aarch64-linux-gnu-gcc"
+
+[target.armv7-unknown-linux-gnueabihf]
+linker = "arm-linux-gnueabihf-gcc"

.editorconfig

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

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,74 @@
+name: 问题反馈 / Bug report
+title: "[BUG] "
+description: 反馈你遇到的问题 / Report the issue you are experiencing
+labels: ["bug"]
+type: "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: 详细清晰地描述你遇到的问题，并配合截图 / Describe the problem you encountered in detail and clearly, and provide screenshots
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: 软件版本 / Verge Version
+      description: 请提供Verge的具体版本，如果是alpha版本，请注明下载时间(精确到小时分钟) / Please provide the specific version of Verge. If it is an alpha version, please indicate the download time (accurate to hours and minutes)
+    validations:
+      required: true
+  - type: textarea
+    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: checkboxes
+    id: os-labels
+    attributes:
+      label: 系统标签 / OS Labels
+      description: 请选择受影响的操作系统（至少选择一个） / Please select the affected operating system(s) (select at least one)
+      options:
+        - label: windows
+        - label: macos
+        - label: linux
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: 日志 / Log
+      description: 请提供完整或相关部分的Debug日志（请在“软件左侧菜单”->“设置”->“日志等级”调整到debug，Verge错误请把“杂项设置”->“app日志等级”调整到debug/trace，并重启Verge生效。日志文件在“软件左侧菜单”->“设置”->“日志目录”下） / Please provide a complete or relevant part of the Debug log (please adjust the "Log level" to debug in "Software left menu" -> "Settings" -> "Log level". If there is a Verge error, please adjust "Miscellaneous settings" -> "app log level" to trace, and restart Verge to take effect. The log file is under "Software left menu" -> "Settings" -> "Log directory")
+    validations:
+      required: true

.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,47 @@
+name: 功能请求 / Feature request
+title: "[Feature] "
+description: 提出你的功能请求 / Propose your feature request
+labels: ["enhancement"]
+type: "Feature"
+
+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
+  - type: checkboxes
+    id: os-labels
+    attributes:
+      label: 适用系统 / Target OS
+      description: 请选择该功能适用的操作系统（至少选择一个） / Please select the operating system(s) for this feature request (select at least one)
+      options:
+        - label: windows
+        - label: macos
+        - label: linux
+    validations:
+      required: true

.github/workflows/alpha.yml

@@ -0,0 +1,412 @@
+name: Alpha Build
+
+on:
+  workflow_dispatch:
+  schedule:
+    # UTC+8 00:00 (UTC 16:00 previous day) and UTC+8 12:00 (UTC 04:00)
+    - cron: "0 16,4 * * *"
+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:
+  check_commit:
+    runs-on: ubuntu-latest
+    outputs:
+      should_run: ${{ steps.check.outputs.should_run }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 2
+
+      - name: Check if commit changed
+        id: check
+        run: |
+          # For manual workflow_dispatch, always run
+          if [ "${{ github.event_name }}" == "workflow_dispatch" ]; then
+            echo "should_run=true" >> $GITHUB_OUTPUT
+            exit 0
+          fi
+
+          # Check if current commit is different from the previous one
+          CURRENT_COMMIT=$(git rev-parse HEAD)
+          PREVIOUS_COMMIT=$(git rev-parse HEAD~1)
+
+          if [ "$CURRENT_COMMIT" != "$PREVIOUS_COMMIT" ]; then
+            echo "New commit detected: $CURRENT_COMMIT"
+            echo "should_run=true" >> $GITHUB_OUTPUT
+          else
+            echo "No new commits since last run"
+            echo "should_run=false" >> $GITHUB_OUTPUT
+          fi
+
+  alpha:
+    needs: check_commit
+    if: ${{ needs.check_commit.outputs.should_run == 'true' }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-latest
+            target: x86_64-pc-windows-msvc
+          - os: windows-latest
+            target: aarch64-pc-windows-msvc
+          - os: macos-latest
+            target: aarch64-apple-darwin
+          - os: macos-latest
+            target: x86_64-apple-darwin
+          - os: ubuntu-22.04
+            target: x86_64-unknown-linux-gnu
+
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      - name: Install Rust Stable
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Add Rust Target
+        run: rustup target add ${{ matrix.target }}
+
+      - name: Rust Cache
+        uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: src-tauri
+          cache-all-crates: true
+          cache-on-failure: true
+
+      - name: Install dependencies (ubuntu only)
+        if: matrix.os == 'ubuntu-22.04'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librsvg2-dev patchelf
+
+      - name: Install Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+
+      - 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: Alpha Version update
+        run: pnpm run fix-alpha-version
+
+      - name: Tauri build
+        uses: tauri-apps/tauri-action@v0
+        env:
+          NODE_OPTIONS: "--max_old_space_size=4096"
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
+          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
+          APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_SIGNING_IDENTITY }}
+          APPLE_ID: ${{ secrets.APPLE_ID }}
+          APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
+          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
+        with:
+          tagName: alpha
+          releaseName: "Clash Verge Rev Alpha"
+          releaseBody: "More new features are now supported."
+          releaseDraft: false
+          prerelease: true
+          tauriScript: pnpm
+          args: --target ${{ matrix.target }}
+
+  alpha-for-linux-arm:
+    needs: check_commit
+    if: ${{ needs.check_commit.outputs.should_run == 'true' }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-22.04
+            target: aarch64-unknown-linux-gnu
+            arch: arm64
+          - os: ubuntu-22.04
+            target: armv7-unknown-linux-gnueabihf
+            arch: armhf
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      - name: Install Rust Stable
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Add Rust Target
+        run: rustup target add ${{ matrix.target }}
+
+      - name: Rust Cache
+        uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: src-tauri
+          cache-all-crates: true
+
+      - name: Install Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          run_install: false
+
+      - name: Pnpm install and check
+        run: |
+          pnpm i
+          pnpm check ${{ matrix.target }}
+
+      - name: "Setup for linux"
+        run: |-
+          sudo ls -lR /etc/apt/
+
+          cat > /tmp/sources.list << EOF
+          deb [arch=amd64,i386] http://archive.ubuntu.com/ubuntu jammy main multiverse universe restricted
+          deb [arch=amd64,i386] http://archive.ubuntu.com/ubuntu jammy-security main multiverse universe restricted
+          deb [arch=amd64,i386] http://archive.ubuntu.com/ubuntu jammy-updates main multiverse universe restricted
+          deb [arch=amd64,i386] http://archive.ubuntu.com/ubuntu jammy-backports main multiverse universe restricted
+
+          deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy main multiverse universe restricted
+          deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy-security main multiverse universe restricted
+          deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy-updates main multiverse universe restricted
+          deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy-backports main multiverse universe restricted
+          EOF
+
+          sudo mv /etc/apt/sources.list /etc/apt/sources.list.default
+          sudo mv /tmp/sources.list /etc/apt/sources.list
+
+          sudo dpkg --add-architecture ${{ matrix.arch }}
+          sudo apt update
+
+          sudo apt install -y \
+            libwebkit2gtk-4.1-dev:${{ matrix.arch }} \
+            libayatana-appindicator3-dev:${{ matrix.arch }} \
+            libssl-dev:${{ matrix.arch }} \
+            patchelf:${{ matrix.arch }} \
+            librsvg2-dev:${{ matrix.arch }}
+
+      - name: "Install aarch64 tools"
+        if: matrix.target == 'aarch64-unknown-linux-gnu'
+        run: |
+          sudo apt install -y \
+            gcc-aarch64-linux-gnu \
+            g++-aarch64-linux-gnu
+
+      - name: "Install armv7 tools"
+        if: matrix.target == 'armv7-unknown-linux-gnueabihf'
+        run: |
+          sudo apt install -y \
+            gcc-arm-linux-gnueabihf \
+            g++-arm-linux-gnueabihf
+
+      - name: Build for Linux
+        run: |
+          export PKG_CONFIG_ALLOW_CROSS=1
+          if [ "${{ matrix.target }}" == "aarch64-unknown-linux-gnu" ]; then
+            export PKG_CONFIG_PATH=/usr/lib/aarch64-linux-gnu/pkgconfig/:$PKG_CONFIG_PATH
+            export PKG_CONFIG_SYSROOT_DIR=/usr/aarch64-linux-gnu/
+          elif [ "${{ matrix.target }}" == "armv7-unknown-linux-gnueabihf" ]; then
+            export PKG_CONFIG_PATH=/usr/lib/arm-linux-gnueabihf/pkgconfig/:$PKG_CONFIG_PATH
+            export PKG_CONFIG_SYSROOT_DIR=/usr/arm-linux-gnueabihf/
+          fi
+          pnpm build --target ${{ matrix.target }}
+        env:
+          NODE_OPTIONS: "--max_old_space_size=4096"
+          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+
+      - name: Get Version
+        run: |
+          sudo apt-get update
+          sudo apt-get install jq
+          echo "VERSION=$(cat package.json | jq '.version' | tr -d '"')" >> $GITHUB_ENV
+          echo "BUILDTIME=$(TZ=Asia/Shanghai date)" >> $GITHUB_ENV
+
+      - name: Upload Release
+        uses: softprops/action-gh-release@v2
+        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:
+    needs: check_commit
+    if: ${{ needs.check_commit.outputs.should_run == 'true' }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-latest
+            target: x86_64-pc-windows-msvc
+            arch: x64
+          - 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: "22"
+
+      - 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_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+        with:
+          tauriScript: pnpm
+          args: --target ${{ matrix.target }}
+
+      - name: Rename
+        run: |
+          $files = Get-ChildItem ".\src-tauri\target\${{ matrix.target }}\release\bundle\nsis\*-setup.exe"
+          foreach ($file in $files) {
+            $newName = $file.Name -replace "-setup\.exe$", "_fixed_webview2-setup.exe"
+            Rename-Item $file.FullName $newName
+          }
+
+          $files = Get-ChildItem ".\src-tauri\target\${{ matrix.target }}\release\bundle\nsis\*.nsis.zip"
+          foreach ($file in $files) {
+            $newName = $file.Name -replace "-setup\.nsis\.zip$", "_fixed_webview2-setup.nsis.zip"
+            Rename-Item $file.FullName $newName
+          }
+
+          $files = Get-ChildItem ".\src-tauri\target\${{ matrix.target }}\release\bundle\nsis\*-setup.exe.sig"
+          foreach ($file in $files) {
+            $newName = $file.Name -replace "-setup\.exe\.sig$", "_fixed_webview2-setup.exe.sig"
+            Rename-Item $file.FullName $newName
+          }
+
+      - 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
+        run: pnpm portable-fixed-webview2 ${{ matrix.target }} --alpha
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  update_tag:
+    name: Update tag
+    runs-on: ubuntu-latest
+    needs: [check_commit, alpha, alpha-for-linux-arm, alpha-for-fixed-webview2]
+    if: ${{ needs.check_commit.outputs.should_run == 'true' }}
+    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
+          - MacOS intel芯片: x64.dmg
+          - MacOS apple M芯片: aarch64.dmg
+
+          ### Linux
+          - Linux 64位: amd64.deb/amd64.rpm
+          - Linux arm64 architecture: arm64.deb/aarch64.rpm
+          - Linux armv7架构: armhf.deb/armhfp.rpm
+
+          ### Windows (不再支持Win7)
+          #### 正常版本(推荐)
+          - 64位: x64-setup.exe
+          - arm64架构: arm64-setup.exe
+          #### 便携版问题很多不再提供
+          #### 内置Webview2版(体积较大，仅在企业版系统或无法安装webview2时使用)
+          - 64位: x64_fixed_webview2-setup.exe
+          - arm64架构: arm64_fixed_webview2-setup.exe
+
+          ### FAQ
+
+          - [常见问题](https://clash-verge-rev.github.io/faq/windows.html)
+
+          ### 稳定机场VPN推荐
+          - [狗狗加速](https://verge.dginv.click/#/register?code=oaxsAGo6)
+
+          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/dev.yml

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

.github/workflows/release.yml

@@ -1,55 +1,374 @@
-name: Release Project
+name: Release Build
 
 on:
-  push:
-    tags:
-      - v*
+  workflow_dispatch:
+permissions: write-all
+env:
+  CARGO_INCREMENTAL: 0
+  RUST_BACKTRACE: short
+concurrency:
+  # only allow per workflow per commit (and not pr) to run at a time
+  group: "${{ github.workflow }} - ${{ github.head_ref || github.ref }}"
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
 
 jobs:
-  build-tauri:
+  release:
     strategy:
       fail-fast: false
       matrix:
-        platform: [windows-latest]
-    runs-on: ${{ matrix.platform }}
+        include:
+          - os: windows-latest
+            target: x86_64-pc-windows-msvc
+          - os: windows-latest
+            target: aarch64-pc-windows-msvc
+          - os: macos-latest
+            target: aarch64-apple-darwin
+          - os: macos-latest
+            target: x86_64-apple-darwin
+          - os: ubuntu-22.04
+            target: x86_64-unknown-linux-gnu
+
+    runs-on: ${{ matrix.os }}
     steps:
-      - uses: actions/checkout@v2
-      - name: setup node
-        uses: actions/setup-node@v1
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      - name: Install Rust Stable
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Add Rust Target
+        run: rustup target add ${{ matrix.target }}
+
+      - name: Rust Cache
+        uses: Swatinem/rust-cache@v2
         with:
-          node-version: 14
-      - name: install Rust stable
-        uses: actions-rs/toolchain@v1
+          workspaces: src-tauri
+          cache-all-crates: true
+          cache-on-failure: true
+
+      - name: Install dependencies (ubuntu only)
+        if: matrix.os == 'ubuntu-22.04'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librsvg2-dev patchelf
+
+      - name: Install Node
+        uses: actions/setup-node@v4
         with:
-          toolchain: stable
-      - name: Get yarn cache directory path
-        id: yarn-cache-dir-path
-        run: echo "::set-output name=dir::$(yarn cache dir)"
-      - uses: actions/cache@v2
-        id: yarn-cache
+          node-version: "22"
+
+      - 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-
-      - uses: actions/cache@v2
-        with:
-          path: |
-            ~/.cargo/bin/
-            ~/.cargo/registry/index/
-            ~/.cargo/registry/cache/
-            ~/.cargo/git/db/
-            src-tauri/target/
-            src-tauri/WixTools/
-          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
-      - name: install app dependencies and build it
-        run: yarn && yarn run predev
-      - uses: tauri-apps/tauri-action@v0
+          run_install: false
+
+      - name: Pnpm install and check
+        run: |
+          pnpm i
+          pnpm check ${{ matrix.target }}
+
+      - name: Tauri build
+        uses: tauri-apps/tauri-action@v0
         env:
+          NODE_OPTIONS: "--max_old_space_size=4096"
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
+          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
+          APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_SIGNING_IDENTITY }}
+          APPLE_ID: ${{ secrets.APPLE_ID }}
+          APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
+          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
         with:
           tagName: v__VERSION__
-          releaseName: "Clash Verge v__VERSION__"
-          releaseBody: "This is a release."
-          releaseDraft: true
-          prerelease: false
+          releaseName: "Clash Verge Rev v__VERSION__"
+          releaseBody: "More new features are now supported."
+          tauriScript: pnpm
+          args: --target ${{ matrix.target }}
+
+  release-for-linux-arm:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-22.04
+            target: aarch64-unknown-linux-gnu
+            arch: arm64
+          - os: ubuntu-22.04
+            target: armv7-unknown-linux-gnueabihf
+            arch: armhf
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      - name: Install Rust Stable
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Add Rust Target
+        run: rustup target add ${{ matrix.target }}
+
+      - name: Rust Cache
+        uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: src-tauri
+          cache-all-crates: true
+
+      - name: Install Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          run_install: false
+
+      - name: Pnpm install and check
+        run: |
+          pnpm i
+          pnpm check ${{ matrix.target }}
+
+      - name: "Setup for linux"
+        run: |-
+          sudo ls -lR /etc/apt/
+
+          cat > /tmp/sources.list << EOF
+          deb [arch=amd64,i386] http://archive.ubuntu.com/ubuntu jammy main multiverse universe restricted
+          deb [arch=amd64,i386] http://archive.ubuntu.com/ubuntu jammy-security main multiverse universe restricted
+          deb [arch=amd64,i386] http://archive.ubuntu.com/ubuntu jammy-updates main multiverse universe restricted
+          deb [arch=amd64,i386] http://archive.ubuntu.com/ubuntu jammy-backports main multiverse universe restricted
+
+          deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy main multiverse universe restricted
+          deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy-security main multiverse universe restricted
+          deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy-updates main multiverse universe restricted
+          deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy-backports main multiverse universe restricted
+          EOF
+
+          sudo mv /etc/apt/sources.list /etc/apt/sources.list.default
+          sudo mv /tmp/sources.list /etc/apt/sources.list
+
+          sudo dpkg --add-architecture ${{ matrix.arch }}
+          sudo apt update
+
+          sudo apt install -y \
+            libwebkit2gtk-4.1-dev:${{ matrix.arch }} \
+            libayatana-appindicator3-dev:${{ matrix.arch }} \
+            libssl-dev:${{ matrix.arch }} \
+            patchelf:${{ matrix.arch }} \
+            librsvg2-dev:${{ matrix.arch }}
+
+      - name: "Install aarch64 tools"
+        if: matrix.target == 'aarch64-unknown-linux-gnu'
+        run: |
+          sudo apt install -y \
+            gcc-aarch64-linux-gnu \
+            g++-aarch64-linux-gnu
+
+      - name: "Install armv7 tools"
+        if: matrix.target == 'armv7-unknown-linux-gnueabihf'
+        run: |
+          sudo apt install -y \
+            gcc-arm-linux-gnueabihf \
+            g++-arm-linux-gnueabihf
+
+      - name: Build for Linux
+        run: |
+          export PKG_CONFIG_ALLOW_CROSS=1
+          if [ "${{ matrix.target }}" == "aarch64-unknown-linux-gnu" ]; then
+            export PKG_CONFIG_PATH=/usr/lib/aarch64-linux-gnu/pkgconfig/:$PKG_CONFIG_PATH
+            export PKG_CONFIG_SYSROOT_DIR=/usr/aarch64-linux-gnu/
+          elif [ "${{ matrix.target }}" == "armv7-unknown-linux-gnueabihf" ]; then
+            export PKG_CONFIG_PATH=/usr/lib/arm-linux-gnueabihf/pkgconfig/:$PKG_CONFIG_PATH
+            export PKG_CONFIG_SYSROOT_DIR=/usr/arm-linux-gnueabihf/
+          fi
+          pnpm build --target ${{ matrix.target }}
+        env:
+          NODE_OPTIONS: "--max_old_space_size=4096"
+          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+
+      - name: Get Version
+        run: |
+          sudo apt-get update
+          sudo apt-get install jq
+          echo "VERSION=$(cat package.json | jq '.version' | tr -d '"')" >> $GITHUB_ENV
+          echo "BUILDTIME=$(TZ=Asia/Shanghai date)" >> $GITHUB_ENV
+
+      - name: Upload Release
+        uses: softprops/action-gh-release@v2
+        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: 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: "22"
+
+      - 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_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+        with:
+          tauriScript: pnpm
+          args: --target ${{ matrix.target }}
+
+      - name: Rename
+        run: |
+          $files = Get-ChildItem ".\src-tauri\target\${{ matrix.target }}\release\bundle\nsis\*-setup.exe"
+          foreach ($file in $files) {
+            $newName = $file.Name -replace "-setup\.exe$", "_fixed_webview2-setup.exe"
+            Rename-Item $file.FullName $newName
+          }
+
+          $files = Get-ChildItem ".\src-tauri\target\${{ matrix.target }}\release\bundle\nsis\*.nsis.zip"
+          foreach ($file in $files) {
+            $newName = $file.Name -replace "-setup\.nsis\.zip$", "_fixed_webview2-setup.nsis.zip"
+            Rename-Item $file.FullName $newName
+          }
+
+          $files = Get-ChildItem ".\src-tauri\target\${{ matrix.target }}\release\bundle\nsis\*-setup.exe.sig"
+          foreach ($file in $files) {
+            $newName = $file.Name -replace "-setup\.exe\.sig$", "_fixed_webview2-setup.exe.sig"
+            Rename-Item $file.FullName $newName
+          }
+
+      - 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-arm]
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Install Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+
+      - 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: "22"
+
+      - 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 }}
+
+  submit-to-winget:
+    runs-on: ubuntu-latest
+    needs: [release-update]
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Get Version
+        run: |
+          sudo apt-get update
+          sudo apt-get install jq
+          echo "VERSION=$(cat package.json | jq '.version' | tr -d '"')" >> $GITHUB_ENV
+      - name: Submit to Winget
+        uses: vedantmgoyal9/winget-releaser@main
+        with:
+          identifier: ClashVergeRev.ClashVergeRev
+          version: ${{env.VERSION}}
+          release-tag: v${{env.VERSION}}
+          installers-regex: '_(arm64|x64|x86)-setup\.exe$'
+          token: ${{ secrets.WINGET_TOKEN  }}

.github/workflows/updater.yml

@@ -0,0 +1,52 @@
+name: Updater CI
+
+on: workflow_dispatch
+permissions: write-all
+jobs:
+  release-update:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Install Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+
+      - 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
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Install Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+
+      - 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,7 +1,11 @@
 node_modules
+.pnpm-store
 .DS_Store
 dist
 dist-ssr
 *.local
-package-lock.json
-yarn.lock
+update.json
+scripts/_env.sh
+.vscode
+.tool-versions
+.idea

.husky/pre-commit

@@ -1,4 +1 @@
-#!/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,106 @@
+# 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
+
+When you setup `Rust` environment, Only use toolchain with `Windows MSVC` , to change settings follow command:
+
+```shell
+rustup target add x86_64-pc-windows-msvc
+rustup set default-host x86_64-pc-windows-msvc
+```
+
+### Install Node.js Package
+
+After installing Rust and Node.js, install the necessary Node.js and Node Package Manager:
+
+```shell
+npm install pnpm -g
+```
+
+### Install Dependencies
+
+```shell
+pnpm install
+```
+
+### Download the Mihomo Core 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 [Mihomo release](https://github.com/MetaCubeX/mihomo/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
+
+To build this project:
+
+```shell
+pnpm build
+```
+
+For a faster build, use the following command
+
+```shell
+pnpm build:fast
+```
+
+This uses Rust's fast-release profile which significantly reduces compilation time by disabling optimization and LTO. The resulting binary will be larger and less performant than the standard build, but it's useful for testing changes quickly.
+
+The `Artifacts` will display in the `log` in the Terminal.
+
+### Build clean
+
+To clean rust build:
+
+```shell
+pnpm clean
+```
+
+### Portable Version (Windows Only)
+
+To package portable version after the build:
+
+```shell
+pnpm portable
+```
+
+## 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,59 +1,91 @@
 <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>
 
+## Preview
+
+| Dark                             | Light                             |
+| -------------------------------- | --------------------------------- |
+| ![预览](./docs/preview_dark.png) | ![预览](./docs/preview_light.png) |
+
+## Install
+
+请到发布页面下载对应的安装包：[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).
+
+### 安装说明和常见问题，请到[文档页](https://clash-verge-rev.github.io/)查看：[Doc](https://clash-verge-rev.github.io/)
+
+---
+
+### TG 频道: [@clash_verge_rev](https://t.me/clash_verge_re)
+
+## Promotion
+
+[狗狗加速 —— 技术流机场 Doggygo VPN](https://verge.dginv.click/#/register?code=oaxsAGo6)
+
+- 高性能海外机场，免费试用，优惠套餐，解锁流媒体，全球首家支持 Hysteria 协议。
+- 使用 Clash Verge 专属邀请链接注册送 3 天，每天 1G 流量免费试用：[点此注册](https://verge.dginv.click/#/register?code=oaxsAGo6)
+- Clash Verge 专属 8 折优惠码: verge20 (仅有 500 份)
+- 优惠套餐每月仅需 15.8 元，160G 流量，年付 8 折
+- 海外团队，无跑路风险，高达 50% 返佣
+- 集群负载均衡设计，高速专线(兼容老客户端)，极低延迟，无视晚高峰，4K 秒开
+- 全球首家 Hysteria 协议机场，现已上线更快的 `Hysteria2` 协议(Clash Verge 客户端最佳搭配)
+- 解锁流媒体及 ChatGPT
+- 官网：[https://狗狗加速.com](https://verge.dginv.click/#/register?code=oaxsAGo6)
+
 ## Features
 
-Now it's no different from the others, even fewer. (WIP)
+- 基于性能强劲的 Rust 和 Tauri 2 框架
+- 内置[Clash.Meta(mihomo)](https://github.com/MetaCubeX/mihomo)内核，并支持切换 `Alpha` 版本内核。
+- 简洁美观的用户界面，支持自定义主题颜色、代理组/托盘图标以及 `CSS Injection`。
+- 配置文件管理和增强（Merge 和 Script），配置文件语法提示。
+- 系统代理和守卫、`TUN(虚拟网卡)` 模式。
+- 可视化节点和规则编辑
+- WebDav 配置备份和同步
+
+### FAQ
+
+Refer to [Doc FAQ Page](https://clash-verge-rev.github.io/faq/windows.html)
+
+### Donation
+
+[捐助Clash Verge Rev的开发](https://github.com/sponsors/clash-verge-rev)
 
 ## Development
 
-You should install Rust and Nodejs. Then install tauri cli and 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
-cargo install tauri-cli --git https://github.com/tauri-apps/tauri
-
-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/en/docs/api/config#tauri.bundle.externalBin).
-
-```shell
-yarn run predev
-```
-
-Then run
-
-```shell
-yarn dev
-```
-
-## Todos
-
-> This keng is a little big...
-
-## Screenshots
-
-<div align="center">
-  <img src="./docs/demo1.png" alt="demo1" width="42%" />
-  <img src="./docs/demo2.png" alt="demo2" width="42%" />
-</div>
-
-## Disclaimer
-
-This is a learning project for Rust practice.
-
 ## Contributions
 
-PR welcome!
+Issue and PR welcome!
+
+## Acknowledgement
+
+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/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!
 
 ## License
 
-GPL-3.0 License
+GPL-3.0 License. See [License here](./LICENSE) for details.

package.json

@@ -1,49 +1,108 @@
 {
   "name": "clash-verge",
-  "version": "0.0.1",
-  "license": "GPL-3.0",
+  "version": "2.1.3-alpha",
+  "license": "GPL-3.0-only",
   "scripts": {
-    "dev": "cargo tauri dev",
-    "build": "cargo tauri build",
+    "dev": "cross-env RUST_BACKTRACE=1 tauri dev -f verge-dev -- --profile fast-dev",
+    "dev:diff": "cross-env RUST_BACKTRACE=1 tauri dev -f verge-dev -- --profile fast-dev",
+    "build": "cross-env NODE_OPTIONS='--max-old-space-size=4096' tauri build",
+    "build:fast": "cross-env NODE_OPTIONS='--max-old-space-size=4096' tauri build -- --profile fast-release",
+    "tauri": "tauri",
     "web:dev": "vite",
-    "web:build": "tsc && vite build",
+    "web:build": "tsc --noEmit && vite build",
     "web:serve": "vite preview",
-    "predev": "node scripts/pre-dev.mjs",
-    "prepare": "husky install"
+    "check": "node scripts/check.mjs",
+    "updater": "node scripts/updater.mjs",
+    "updater-fixed-webview2": "node scripts/updater-fixed-webview2.mjs",
+    "portable": "node scripts/portable.mjs",
+    "portable-fixed-webview2": "node scripts/portable-fixed-webview2.mjs",
+    "fix-alpha-version": "node scripts/alpha_version.mjs",
+    "prepare": "husky",
+    "clean": "cd ./src-tauri && cargo clean && cd -"
   },
   "dependencies": {
-    "@emotion/react": "^11.7.0",
-    "@emotion/styled": "^11.6.0",
-    "@mui/icons-material": "^5.2.1",
-    "@mui/material": "^5.2.3",
-    "@tauri-apps/api": "^1.0.0-beta.8",
-    "axios": "^0.24.0",
-    "dayjs": "^1.10.7",
-    "react": "^17.0.0",
-    "react-dom": "^17.0.0",
-    "react-router-dom": "^6.0.2",
-    "react-virtuoso": "^2.3.1",
-    "recoil": "^0.5.2",
-    "swr": "^1.1.2-beta.0"
+    "@dnd-kit/core": "^6.3.1",
+    "@dnd-kit/sortable": "^10.0.0",
+    "@dnd-kit/utilities": "^3.2.2",
+    "@emotion/react": "^11.14.0",
+    "@emotion/styled": "^11.14.0",
+    "@juggle/resize-observer": "^3.4.0",
+    "@mui/icons-material": "^6.4.2",
+    "@mui/lab": "6.0.0-beta.25",
+    "@mui/material": "^6.4.2",
+    "@mui/x-data-grid": "^7.25.0",
+    "@tauri-apps/api": "2.2.0",
+    "@tauri-apps/plugin-clipboard-manager": "^2.2.1",
+    "@tauri-apps/plugin-dialog": "^2.2.0",
+    "@tauri-apps/plugin-fs": "^2.2.0",
+    "@tauri-apps/plugin-global-shortcut": "^2.2.0",
+    "@tauri-apps/plugin-notification": "^2.2.1",
+    "@tauri-apps/plugin-process": "^2.2.0",
+    "@tauri-apps/plugin-shell": "2.2.0",
+    "@tauri-apps/plugin-updater": "2.3.0",
+    "@types/json-schema": "^7.0.15",
+    "ahooks": "^3.8.4",
+    "axios": "^1.7.9",
+    "cli-color": "^2.0.4",
+    "dayjs": "1.11.13",
+    "foxact": "^0.2.43",
+    "glob": "^11.0.1",
+    "i18next": "^24.2.2",
+    "js-base64": "^3.7.7",
+    "js-yaml": "^4.1.0",
+    "lodash-es": "^4.17.21",
+    "monaco-editor": "^0.52.2",
+    "monaco-yaml": "^5.2.3",
+    "nanoid": "^5.0.9",
+    "peggy": "^4.2.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-error-boundary": "^4.0.12",
+    "react-hook-form": "^7.54.2",
+    "react-i18next": "^13.5.0",
+    "react-markdown": "^9.0.1",
+    "react-monaco-editor": "^0.56.0",
+    "react-router-dom": "^6.22.3",
+    "react-transition-group": "^4.4.5",
+    "react-virtuoso": "^4.6.3",
+    "sockette": "^2.0.6",
+    "swr": "^2.3.0",
+    "tar": "^7.4.3",
+    "types-pac": "^1.0.3",
+    "zustand": "^5.0.3"
   },
   "devDependencies": {
-    "@tauri-apps/cli": "^1.0.0-beta.10",
-    "@types/react": "^17.0.0",
-    "@types/react-dom": "^17.0.0",
-    "@vitejs/plugin-react": "^1.1.1",
-    "adm-zip": "^0.5.9",
-    "fs-extra": "^10.0.0",
-    "husky": "^7.0.0",
-    "node-fetch": "^3.1.0",
-    "pretty-quick": "^3.1.3",
-    "sass": "^1.44.0",
-    "typescript": "^4.5.2",
-    "vite": "^2.7.1"
+    "@actions/github": "^6.0.0",
+    "@tauri-apps/cli": "2.2.7",
+    "@types/js-cookie": "^3.0.6",
+    "@types/js-yaml": "^4.0.9",
+    "@types/lodash-es": "^4.17.12",
+    "@types/react": "^18.3.18",
+    "@types/react-dom": "^18.3.5",
+    "@types/react-transition-group": "^4.4.12",
+    "@vitejs/plugin-legacy": "^6.0.0",
+    "@vitejs/plugin-react": "^4.2.1",
+    "adm-zip": "^0.5.16",
+    "cross-env": "^7.0.3",
+    "https-proxy-agent": "^7.0.6",
+    "husky": "^9.1.7",
+    "meta-json-schema": "^1.19.1",
+    "node-fetch": "^3.3.2",
+    "prettier": "^3.4.2",
+    "pretty-quick": "^4.0.0",
+    "sass": "^1.83.4",
+    "terser": "^5.37.0",
+    "typescript": "^5.7.3",
+    "vite": "^6.0.11",
+    "vite-plugin-monaco-editor": "^1.1.0",
+    "vite-plugin-svgr": "^4.3.0"
   },
   "prettier": {
     "tabWidth": 2,
     "semi": true,
     "singleQuote": false,
     "endOfLine": "lf"
-  }
+  },
+  "type": "module",
+  "packageManager": "pnpm@9.13.2"
 }

scripts/alpha_version.mjs

@@ -0,0 +1,56 @@
+import { exec } from "child_process";
+import { promisify } from "util";
+import fs from "fs/promises";
+import path from "path";
+
+/**
+ *  为Alpha版本重命名版本号
+ */
+const execPromise = promisify(exec);
+
+/**
+ * 标准输出HEAD hash
+ */
+async function getLatestCommitHash() {
+  try {
+    const { stdout } = await execPromise("git rev-parse HEAD");
+    const commitHash = stdout.trim();
+    // 格式化，只截取前7位字符
+    const formathash = commitHash.substring(0, 7);
+    console.log(`Found the latest commit hash code: ${commitHash}`);
+    return formathash;
+  } catch (error) {
+    console.error("pnpm run fix-alpha-version ERROR", error);
+  }
+}
+
+/**
+ * @param string 传入格式化后的hash
+ * 将新的版本号写入文件 package.json
+ */
+async function updatePackageVersion(newVersion) {
+  // 获取内容根目录
+  const _dirname = process.cwd();
+  const packageJsonPath = path.join(_dirname, "package.json");
+  try {
+    // 读取文件
+    const data = await fs.readFile(packageJsonPath, "utf8");
+    const packageJson = JSON.parse(data);
+    // 获取键值替换
+    let result = packageJson.version.replace("alpha", newVersion);
+    console.log("[INFO]: Current version is: ", result);
+    packageJson.version = result;
+    // 写入版本号
+    await fs.writeFile(
+      packageJsonPath,
+      JSON.stringify(packageJson, null, 2),
+      "utf8",
+    );
+    console.log(`[INFO]: Alpha version update to: ${newVersion}`);
+  } catch (error) {
+    console.error("pnpm run fix-alpha-version ERROR", error);
+  }
+}
+
+const newVersion = await getLatestCommitHash();
+updatePackageVersion(newVersion).catch(console.error);

scripts/check.mjs

@@ -0,0 +1,567 @@
+import fs from "fs";
+import fsp from "fs/promises";
+import zlib from "zlib";
+import { extract } from "tar";
+import path from "path";
+import AdmZip from "adm-zip";
+import fetch from "node-fetch";
+import { HttpsProxyAgent } from "https-proxy-agent";
+import { execSync } from "child_process";
+import { log_info, log_debug, log_error, log_success } from "./utils.mjs";
+import { glob } from "glob";
+
+const cwd = process.cwd();
+const TEMP_DIR = path.join(cwd, "node_modules/.verge");
+const FORCE = process.argv.includes("--force");
+
+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",
+};
+
+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 = new HttpsProxyAgent(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
+    log_info(`Latest alpha version: ${META_ALPHA_VERSION}`);
+  } catch (error) {
+    log_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": "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 = new HttpsProxyAgent(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
+    log_info(`Latest release version: ${META_VERSION}`);
+  } catch (error) {
+    log_error("Error fetching latest release version:", error.message);
+    process.exit(1);
+  }
+}
+
+/*
+ * check available
+ */
+if (!META_MAP[`${platform}-${arch}`]) {
+  throw new Error(
+    `clash meta alpha unsupported platform "${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 = `${META_ALPHA_URL_PREFIX}/${name}-${META_ALPHA_VERSION}.${urlExt}`;
+  const exeFile = `${name}${isWin ? ".exe" : ""}`;
+  const zipFile = `${name}-${META_ALPHA_VERSION}.${urlExt}`;
+
+  return {
+    name: "verge-mihomo-alpha",
+    targetFile: `verge-mihomo-alpha-${SIDECAR_HOST}${isWin ? ".exe" : ""}`,
+    exeFile,
+    zipFile,
+    downloadURL,
+  };
+}
+
+function clashMeta() {
+  const name = META_MAP[`${platform}-${arch}`];
+  const isWin = platform === "win32";
+  const urlExt = isWin ? "zip" : "gz";
+  const downloadURL = `${META_URL_PREFIX}/${META_VERSION}/${name}-${META_VERSION}.${urlExt}`;
+  const exeFile = `${name}${isWin ? ".exe" : ""}`;
+  const zipFile = `${name}-${META_VERSION}.${urlExt}`;
+
+  return {
+    name: "verge-mihomo",
+    targetFile: `verge-mihomo-${SIDECAR_HOST}${isWin ? ".exe" : ""}`,
+    exeFile,
+    zipFile,
+    downloadURL,
+  };
+}
+/**
+ * download sidecar and rename
+ */
+async function resolveSidecar(binInfo) {
+  const { name, targetFile, zipFile, exeFile, downloadURL } = binInfo;
+
+  const sidecarDir = path.join(cwd, "src-tauri", "sidecar");
+  const sidecarPath = path.join(sidecarDir, targetFile);
+
+  await fsp.mkdir(sidecarDir, { recursive: true });
+  if (!FORCE && fs.existsSync(sidecarPath)) return;
+
+  const tempDir = path.join(TEMP_DIR, name);
+  const tempZip = path.join(tempDir, zipFile);
+  const tempExe = path.join(tempDir, exeFile);
+
+  await fsp.mkdir(tempDir, { recursive: true });
+  try {
+    if (!fs.existsSync(tempZip)) {
+      await downloadFile(downloadURL, tempZip);
+    }
+
+    if (zipFile.endsWith(".zip")) {
+      const zip = new AdmZip(tempZip);
+      zip.getEntries().forEach((entry) => {
+        log_debug(`"${name}" entry name`, entry.entryName);
+      });
+      zip.extractAllTo(tempDir, true);
+      await fsp.rename(tempExe, sidecarPath);
+      log_success(`unzip finished: "${name}"`);
+    } else if (zipFile.endsWith(".tgz")) {
+      // tgz
+      await fsp.mkdir(tempDir, { recursive: true });
+      await extract({
+        cwd: tempDir,
+        file: tempZip,
+        //strip: 1, // 可能需要根据实际的 .tgz 文件结构调整
+      });
+      const files = await fsp.readdir(tempDir);
+      log_debug(`"${name}" files in tempDir:`, files);
+      const extractedFile = files.find((file) => file.startsWith("虚空终端-"));
+      if (extractedFile) {
+        const extractedFilePath = path.join(tempDir, extractedFile);
+        await fsp.rename(extractedFilePath, sidecarPath);
+        log_success(`"${name}" file renamed to "${sidecarPath}"`);
+        execSync(`chmod 755 ${sidecarPath}`);
+        log_success(`chmod binary finished: "${name}"`);
+      } 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) => {
+          log_error(`"${name}" gz failed:`, error.message);
+          reject(error);
+        };
+        readStream
+          .pipe(zlib.createGunzip().on("error", onError))
+          .pipe(writeStream)
+          .on("finish", () => {
+            execSync(`chmod 755 ${sidecarPath}`);
+            log_success(`chmod binary finished: "${name}"`);
+            resolve();
+          })
+          .on("error", onError);
+      });
+    }
+  } catch (err) {
+    // 需要删除文件
+    await fsp.rm(sidecarPath, { recursive: true, force: true });
+    throw err;
+  } finally {
+    // delete temp dir
+    await fsp.rm(tempDir, { recursive: true, force: true });
+  }
+}
+
+const resolveSetDnsScript = () =>
+  resolveResource({
+    file: "set_dns.sh",
+    localPath: path.join(cwd, "scripts/set_dns.sh"),
+  });
+const resolveUnSetDnsScript = () =>
+  resolveResource({
+    file: "unset_dns.sh",
+    localPath: path.join(cwd, "scripts/unset_dns.sh"),
+  });
+
+/**
+ * download the file to the resources dir
+ */
+async function resolveResource(binInfo) {
+  const { file, downloadURL, localPath } = binInfo;
+
+  const resDir = path.join(cwd, "src-tauri/resources");
+  const targetPath = path.join(resDir, file);
+
+  if (!FORCE && fs.existsSync(targetPath)) return;
+
+  if (downloadURL) {
+    await fsp.mkdir(resDir, { recursive: true });
+    await downloadFile(downloadURL, targetPath);
+  }
+
+  if (localPath) {
+    await fs.copyFile(localPath, targetPath, (err) => {
+      if (err) {
+        console.error("Error copying file:", err);
+      } else {
+        console.log("File was copied successfully");
+      }
+    });
+    log_debug(`copy file finished: "${localPath}"`);
+  }
+
+  log_success(`${file} finished`);
+}
+
+/**
+ * download file and save to `path`
+ */ async function downloadFile(url, path) {
+  const options = {};
+
+  const httpProxy =
+    process.env.HTTP_PROXY ||
+    process.env.http_proxy ||
+    process.env.HTTPS_PROXY ||
+    process.env.https_proxy;
+
+  if (httpProxy) {
+    options.agent = new HttpsProxyAgent(httpProxy);
+  }
+
+  const response = await fetch(url, {
+    ...options,
+    method: "GET",
+    headers: { "Content-Type": "application/octet-stream" },
+  });
+  const buffer = await response.arrayBuffer();
+  await fsp.writeFile(path, new Uint8Array(buffer));
+
+  log_success(`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 fsp.mkdir(pluginDir, { recursive: true });
+  await fsp.mkdir(tempDir, { recursive: true });
+  if (!FORCE && fs.existsSync(pluginPath)) return;
+  try {
+    if (!fs.existsSync(tempZip)) {
+      await downloadFile(url, tempZip);
+    }
+    const zip = new AdmZip(tempZip);
+    zip.getEntries().forEach((entry) => {
+      log_debug(`"SimpleSC" entry name`, entry.entryName);
+    });
+    zip.extractAllTo(tempDir, true);
+    await fsp.cp(tempDll, pluginPath, { recursive: true, force: true });
+    log_success(`unzip finished: "SimpleSC"`);
+  } finally {
+    await fsp.rm(tempDir, { recursive: true, force: true });
+  }
+};
+
+// 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) {
+    // 使用glob模块来处理通配符
+    const files = glob.sync(path.join(resDir, f));
+    for (let filePath of files) {
+      if (fs.existsSync(filePath)) {
+        execSync(`chmod 755 ${filePath}`);
+        log_success(`chmod finished: "${filePath}"`);
+      }
+    }
+  }
+};
+
+// 在 resolveResource 函数后添加新函数
+async function resolveLocales() {
+  const srcLocalesDir = path.join(cwd, "src/locales");
+  const targetLocalesDir = path.join(cwd, "src-tauri/resources/locales");
+
+  try {
+    // 确保目标目录存在
+    await fsp.mkdir(targetLocalesDir, { recursive: true });
+
+    // 读取所有语言文件
+    const files = await fsp.readdir(srcLocalesDir);
+
+    // 复制每个文件
+    for (const file of files) {
+      const srcPath = path.join(srcLocalesDir, file);
+      const targetPath = path.join(targetLocalesDir, file);
+
+      await fsp.copyFile(srcPath, targetPath);
+      log_success(`Copied locale file: ${file}`);
+    }
+
+    log_success("All locale files copied successfully");
+  } catch (err) {
+    log_error("Error copying locale files:", err.message);
+    throw err;
+  }
+}
+
+/**
+ * main
+ */
+const SERVICE_URL = `https://github.com/clash-verge-rev/clash-verge-service/releases/download/${SIDECAR_HOST}`;
+
+const resolveService = () => {
+  let ext = platform === "win32" ? ".exe" : "";
+  let suffix = platform === "linux" ? "-" + SIDECAR_HOST : "";
+  resolveResource({
+    file: "clash-verge-service" + suffix + ext,
+    downloadURL: `${SERVICE_URL}/clash-verge-service${ext}`,
+  });
+};
+
+const resolveInstall = () => {
+  let ext = platform === "win32" ? ".exe" : "";
+  let suffix = platform === "linux" ? "-" + SIDECAR_HOST : "";
+  resolveResource({
+    file: "install-service" + suffix + ext,
+    downloadURL: `${SERVICE_URL}/install-service${ext}`,
+  });
+};
+
+const resolveUninstall = () => {
+  let ext = platform === "win32" ? ".exe" : "";
+  let suffix = platform === "linux" ? "-" + SIDECAR_HOST : "";
+
+  resolveResource({
+    file: "uninstall-service" + suffix + ext,
+    downloadURL: `${SERVICE_URL}/uninstall-service${ext}`,
+  });
+};
+
+const resolveMmdb = () =>
+  resolveResource({
+    file: "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/MetaCubeX/meta-rules-dat/releases/download/latest/geosite.dat`,
+  });
+const resolveGeoIP = () =>
+  resolveResource({
+    file: "geoip.dat",
+    downloadURL: `https://github.com/MetaCubeX/meta-rules-dat/releases/download/latest/geoip.dat`,
+  });
+const resolveEnableLoopback = () =>
+  resolveResource({
+    file: "enableLoopback.exe",
+    downloadURL: `https://github.com/Kuingsmile/uwp-tool/releases/download/latest/enableLoopback.exe`,
+  });
+
+const resolveWinSysproxy = () =>
+  resolveResource({
+    file: "sysproxy.exe",
+    downloadURL: `https://github.com/clash-verge-rev/sysproxy/releases/download/${arch}/sysproxy.exe`,
+  });
+
+const tasks = [
+  // { name: "clash", func: resolveClash, retry: 5 },
+  {
+    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: "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: 5,
+    unixOnly: platform === "linux" || platform === "darwin",
+  },
+  {
+    name: "windows-sysproxy",
+    func: resolveWinSysproxy,
+    retry: 5,
+    winOnly: true,
+  },
+  {
+    name: "set_dns_script",
+    func: resolveSetDnsScript,
+    retry: 5,
+    macosOnly: true,
+  },
+  {
+    name: "unset_dns_script",
+    func: resolveUnSetDnsScript,
+    retry: 5,
+    macosOnly: true,
+  },
+  {
+    name: "locales",
+    func: resolveLocales,
+    retry: 2,
+  },
+];
+
+async function runTask() {
+  const task = tasks.shift();
+  if (!task) return;
+  if (task.unixOnly && platform === "win32") return runTask();
+  if (task.winOnly && platform !== "win32") return runTask();
+  if (task.macosOnly && platform !== "darwin") return runTask();
+  if (task.linuxOnly && platform !== "linux") return runTask();
+
+  for (let i = 0; i < task.retry; i++) {
+    try {
+      await task.func();
+      break;
+    } catch (err) {
+      log_error(`task::${task.name} try ${i} ==`, err.message);
+      if (i === task.retry - 1) throw err;
+    }
+  }
+  return runTask();
+}
+
+runTask();

scripts/portable-fixed-webview2.mjs

@@ -0,0 +1,103 @@
+import fs from "fs";
+import fsp from "fs/promises";
+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 (!fs.existsSync(releaseDir)) {
+    throw new Error("could not found the release dir");
+  }
+
+  await fsp.mkdir(configDir, { recursive: true });
+  if (!fs.existsSync(path.join(configDir, "PORTABLE"))) {
+    await fsp.writeFile(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

@@ -0,0 +1,52 @@
+import fs from "fs";
+import path from "path";
+import AdmZip from "adm-zip";
+import { createRequire } from "module";
+import fsp from "fs/promises";
+
+const target = process.argv.slice(2)[0];
+const ARCH_MAP = {
+  "x86_64-pc-windows-msvc": "x64",
+  "aarch64-pc-windows-msvc": "arm64",
+};
+
+const PROCESS_MAP = {
+  x64: "x64",
+  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 (!fs.existsSync(releaseDir)) {
+    throw new Error("could not found the release dir");
+  }
+
+  await fsp.mkdir(configDir, { recursive: true });
+  if (!fs.existsSync(path.join(configDir, "PORTABLE"))) {
+    await fsp.writeFile(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(configDir, ".config");
+
+  const require = createRequire(import.meta.url);
+  const packageJson = require("../package.json");
+  const { version } = packageJson;
+  const zipFile = `Clash.Verge_${version}_${arch}_portable.zip`;
+  zip.writeZip(zipFile);
+  console.log("[INFO]: create portable zip successfully");
+}
+
+resolvePortable().catch(console.error);

scripts/pre-dev.mjs

@@ -1,104 +0,0 @@
-import fs from "fs-extra";
-import path from "path";
-import AdmZip from "adm-zip";
-import fetch from "node-fetch";
-import { execSync } from "child_process";
-
-const cwd = process.cwd();
-
-const CLASH_URL_PREFIX =
-  "https://github.com/Dreamacro/clash/releases/download/premium/";
-const CLASH_LATEST_DATE = "2021.12.07";
-
-/**
- * get the correct clash release infomation
- */
-function resolveClash() {
-  const { platform, arch } = process;
-
-  let name = "";
-
-  // todo
-  if (platform === "win32" && arch === "x64") {
-    name = `clash-windows-386`;
-  }
-
-  if (!name) {
-    throw new Error("todo");
-  }
-
-  const isWin = platform === "win32";
-  const zip = isWin ? "zip" : "gz";
-  const url = `${CLASH_URL_PREFIX}${name}-${CLASH_LATEST_DATE}.${zip}`;
-  const exefile = `${name}${isWin ? ".exe" : ""}`;
-  const zipfile = `${name}.${zip}`;
-
-  return { url, zip, exefile, zipfile };
-}
-
-/**
- * get the sidecar bin
- */
-async function resolveSidecar() {
-  const sidecarDir = path.join(cwd, "src-tauri", "sidecar");
-
-  const host = execSync("rustc -vV | grep host").toString().slice(6).trim();
-  const ext = process.platform === "win32" ? ".exe" : "";
-  const sidecarFile = `clash-${host}${ext}`;
-  const sidecarPath = path.join(sidecarDir, sidecarFile);
-
-  if (!(await fs.pathExists(sidecarDir))) await fs.mkdir(sidecarDir);
-  if (await fs.pathExists(sidecarPath)) return;
-
-  // download sidecar
-  const binInfo = resolveClash();
-  const tempDir = path.join(cwd, "pre-dev-temp");
-  const tempZip = path.join(tempDir, binInfo.zipfile);
-  const tempExe = path.join(tempDir, binInfo.exefile);
-
-  if (!(await fs.pathExists(tempDir))) await fs.mkdir(tempDir);
-  if (!(await fs.pathExists(tempZip))) await downloadFile(binInfo.url, tempZip);
-
-  // Todo: support gz
-  const zip = new AdmZip(tempZip);
-  zip.getEntries().forEach((entry) => {
-    console.log("[INFO]: entry name", entry.entryName);
-  });
-  zip.extractAllTo(tempDir, true);
-
-  // save as sidecar
-  await fs.rename(tempExe, sidecarPath);
-
-  // delete temp dir
-  await fs.remove(tempDir);
-}
-
-/**
- * get the Country.mmdb (not required)
- */
-async function resolveMmdb() {
-  const url =
-    "https://github.com/Dreamacro/maxmind-geoip/releases/latest/download/Country.mmdb";
-
-  const resPath = path.join(cwd, "src-tauri", "resources", "Country.mmdb");
-  if (await fs.pathExists(resPath)) return;
-  await downloadFile(url, resPath);
-}
-
-/**
- * download file and save to `path`
- */
-async function downloadFile(url, path) {
-  console.log(`[INFO]: downloading from "${url}"`);
-
-  const response = await fetch(url, {
-    method: "GET",
-    headers: { "Content-Type": "application/octet-stream" },
-  });
-  const buffer = await response.arrayBuffer();
-  await fs.writeFile(path, new Uint8Array(buffer));
-}
-
-/// main
-resolveSidecar();
-resolveMmdb();

scripts/set_dns.sh

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

scripts/unset_dns.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+nic=$(route -n get default | grep "interface" | awk '{print $2}')
+
+hardware_port=$(networksetup -listallhardwareports | awk -v dev="$nic" '
+    /Hardware Port:/{
+        port=$0; gsub("Hardware Port: ", "", port)
+    } 
+    /Device: /{
+        if ($2 == dev) {
+            print port; 
+            exit
+        }
+    }
+')
+
+if [ -f .original_dns.txt ]; then
+    original_dns=$(cat .original_dns.txt)
+    networksetup -setdnsservers "$hardware_port" $original_dns
+    rm -rf .original_dns.txt
+fi

scripts/updatelog.mjs

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

scripts/updater-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://download.clashverge.dev/" + 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

@@ -0,0 +1,280 @@
+import fetch from "node-fetch";
+import { getOctokit, context } from "@actions/github";
+import { resolveUpdateLog } from "./updatelog.mjs";
+
+// Add stable update JSON filenames
+const UPDATE_TAG_NAME = "updater";
+const UPDATE_JSON_FILE = "update.json";
+const UPDATE_JSON_PROXY = "update-proxy.json";
+// Add alpha update JSON filenames
+const ALPHA_TAG_NAME = "updater-alpha";
+const ALPHA_UPDATE_JSON_FILE = "update-alpha.json";
+const ALPHA_UPDATE_JSON_PROXY = "update-alpha-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);
+
+  // Fetch all tags using pagination
+  let allTags = [];
+  let page = 1;
+  const perPage = 100;
+
+  while (true) {
+    const { data: pageTags } = await github.rest.repos.listTags({
+      ...options,
+      per_page: perPage,
+      page: page,
+    });
+
+    allTags = allTags.concat(pageTags);
+
+    // Break if we received fewer tags than requested (last page)
+    if (pageTags.length < perPage) {
+      break;
+    }
+
+    page++;
+  }
+
+  const tags = allTags;
+  console.log(`Retrieved ${tags.length} tags in total`);
+
+  // More flexible tag detection with regex patterns
+  const stableTagRegex = /^v\d+\.\d+\.\d+$/; // Matches vX.Y.Z format
+  // const preReleaseRegex = /^v\d+\.\d+\.\d+-(alpha|beta|rc|pre)/i; // Matches vX.Y.Z-alpha/beta/rc format
+  const preReleaseRegex = /^(alpha|beta|rc|pre)$/i; // Matches exact alpha/beta/rc/pre tags
+
+  // Get the latest stable tag and pre-release tag
+  const stableTag = tags.find((t) => stableTagRegex.test(t.name));
+  const preReleaseTag = tags.find((t) => preReleaseRegex.test(t.name));
+
+  console.log("All tags:", tags.map((t) => t.name).join(", "));
+  console.log("Stable tag:", stableTag ? stableTag.name : "None found");
+  console.log(
+    "Pre-release tag:",
+    preReleaseTag ? preReleaseTag.name : "None found",
+  );
+  console.log();
+
+  // Process stable release
+  if (stableTag) {
+    await processRelease(github, options, stableTag, false);
+  }
+
+  // Process pre-release if found
+  if (preReleaseTag) {
+    await processRelease(github, options, preReleaseTag, true);
+  }
+}
+
+// Process a release (stable or alpha) and generate update files
+async function processRelease(github, options, tag, isAlpha) {
+  if (!tag) return;
+
+  const { data: release } = await github.rest.repos.getReleaseByTag({
+    ...options,
+    tag: tag.name,
+  });
+
+  const updateData = {
+    name: tag.name,
+    notes: await resolveUpdateLog(tag.name).catch(
+      () => "No changelog available",
+    ),
+    pub_date: new Date().toISOString(),
+    platforms: {
+      win64: { signature: "", url: "" }, // compatible with older formats
+      linux: { signature: "", url: "" }, // compatible with older formats
+      darwin: { signature: "", url: "" }, // compatible with older formats
+      "darwin-aarch64": { signature: "", url: "" },
+      "darwin-intel": { signature: "", url: "" },
+      "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-aarch64": { signature: "", url: "" },
+      "windows-x86": { signature: "", url: "" },
+      "windows-i686": { signature: "", url: "" },
+    },
+  };
+
+  const promises = release.assets.map(async (asset) => {
+    const { name, browser_download_url } = asset;
+
+    // Process all the platform URL and signature data
+    // win64 url
+    if (name.endsWith("x64-setup.exe")) {
+      updateData.platforms.win64.url = browser_download_url;
+      updateData.platforms["windows-x86_64"].url = browser_download_url;
+    }
+    // win64 signature
+    if (name.endsWith("x64-setup.exe.sig")) {
+      const sig = await getSignature(browser_download_url);
+      updateData.platforms.win64.signature = sig;
+      updateData.platforms["windows-x86_64"].signature = sig;
+    }
+
+    // win32 url
+    if (name.endsWith("x86-setup.exe")) {
+      updateData.platforms["windows-x86"].url = browser_download_url;
+      updateData.platforms["windows-i686"].url = browser_download_url;
+    }
+    // win32 signature
+    if (name.endsWith("x86-setup.exe.sig")) {
+      const sig = await getSignature(browser_download_url);
+      updateData.platforms["windows-x86"].signature = sig;
+      updateData.platforms["windows-i686"].signature = sig;
+    }
+
+    // win arm url
+    if (name.endsWith("arm64-setup.exe")) {
+      updateData.platforms["windows-aarch64"].url = browser_download_url;
+    }
+    // win arm signature
+    if (name.endsWith("arm64-setup.exe.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;
+      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;
+    }
+  });
+
+  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];
+    }
+  });
+
+  // Generate a proxy update file for accelerated GitHub resources
+  const updateDataNew = JSON.parse(JSON.stringify(updateData));
+
+  Object.entries(updateDataNew.platforms).forEach(([key, value]) => {
+    if (value.url) {
+      updateDataNew.platforms[key].url =
+        "https://download.clashverge.dev/" + value.url;
+    } else {
+      console.log(`[Error]: updateDataNew.platforms.${key} is null`);
+    }
+  });
+
+  // Get the appropriate updater release based on isAlpha flag
+  const releaseTag = isAlpha ? ALPHA_TAG_NAME : UPDATE_TAG_NAME;
+  console.log(
+    `Processing ${isAlpha ? "alpha" : "stable"} release:`,
+    releaseTag,
+  );
+
+  try {
+    const { data: updateRelease } = await github.rest.repos.getReleaseByTag({
+      ...options,
+      tag: releaseTag,
+    });
+
+    // File names based on release type
+    const jsonFile = isAlpha ? ALPHA_UPDATE_JSON_FILE : UPDATE_JSON_FILE;
+    const proxyFile = isAlpha ? ALPHA_UPDATE_JSON_PROXY : UPDATE_JSON_PROXY;
+
+    // Delete existing assets with these names
+    for (let asset of updateRelease.assets) {
+      if (asset.name === jsonFile) {
+        await github.rest.repos.deleteReleaseAsset({
+          ...options,
+          asset_id: asset.id,
+        });
+      }
+
+      if (asset.name === proxyFile) {
+        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: jsonFile,
+      data: JSON.stringify(updateData, null, 2),
+    });
+
+    await github.rest.repos.uploadReleaseAsset({
+      ...options,
+      release_id: updateRelease.id,
+      name: proxyFile,
+      data: JSON.stringify(updateDataNew, null, 2),
+    });
+
+    console.log(
+      `Successfully uploaded ${isAlpha ? "alpha" : "stable"} update files to ${releaseTag}`,
+    );
+  } catch (error) {
+    console.error(
+      `Failed to process ${isAlpha ? "alpha" : "stable"} release:`,
+      error.message,
+    );
+  }
+}
+
+// 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/utils.mjs

@@ -0,0 +1,11 @@
+import clc from "cli-color";
+
+export const log_success = (msg, ...optionalParams) =>
+  console.log(clc.green(msg), ...optionalParams);
+export const log_error = (msg, ...optionalParams) =>
+  console.log(clc.red(msg), ...optionalParams);
+export const log_info = (msg, ...optionalParams) =>
+  console.log(clc.bgBlue(msg), ...optionalParams);
+var debugMsg = clc.xterm(245);
+export const log_debug = (msg, ...optionalParams) =>
+  console.log(debugMsg(msg), ...optionalParams);

src-tauri/.gitignore

@@ -1,6 +1,8 @@
 # Generated by Cargo
 # will have compiled files and executables
 /target/
+gen/
 WixTools
-resources/Country.mmdb
+resources
 sidecar
+

src-tauri/Cargo.toml

@@ -1,34 +1,135 @@
 [package]
-name = "app"
-version = "0.1.0"
+name = "clash-verge"
+version = "2.1.2"
 description = "clash verge"
-authors = ["zzzgydi"]
-license = "GPL-3.0"
-repository = ""
-default-run = "app"
+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"
 
+[package.metadata.bundle]
+identifier = "io.github.clash-verge-rev.clash-verge-rev"
+
 [build-dependencies]
-tauri-build = { version = "1.0.0-beta.4" }
+tauri-build = { version = "2.0.6", features = [] }
 
 [dependencies]
-dirs = "4.0.0"
-chrono = "0.4.19"
-serde_json = "1.0"
-serde_yaml = "0.8"
-serde = { version = "1.0", features = ["derive"] }
-tauri = { version = "1.0.0-beta.8", features = ["api-all", "system-tray"] }
-reqwest = { version = "0.11", features = ["json"] }
-tokio = { version = "1", features = ["full"] }
-log = "0.4.14"
-log4rs = "1.0.0"
 warp = "0.3"
+anyhow = "1.0.97"
+dirs = "6.0"
+open = "5.1"
+log = "0.4"
+dunce = "1.0"
+log4rs = "1"
+nanoid = "0.4"
+chrono = "0.4.40"
+sysinfo = "0.33.1"
+boa_engine = "0.20.0"
+serde_json = "1.0"
+serde_yaml = "0.9"
+once_cell = "1.20.3"
 port_scanner = "0.1.5"
+delay_timer = "0.11.6"
+parking_lot = "0.12"
+percent-encoding = "2.3.1"
+window-shadows = { version = "0.2.2" }
+tokio = { version = "1.43", features = ["full"] }
+serde = { version = "1.0", features = ["derive"] }
+reqwest = { version = "0.12", features = ["json", "rustls-tls"] }
+sysproxy = { git = "https://github.com/clash-verge-rev/sysproxy-rs", rev = "3d748b5" }
+image = "0.25.5"
+imageproc = "0.25.0"
+rusttype = "0.9"
+tauri = { version = "2.3.1", features = [
+    "protocol-asset",
+    "devtools",
+    "tray-icon",
+    "image-ico",
+    "image-png",
+] }
+network-interface = { version = "2.0.0", features = ["serde"] }
+tauri-plugin-shell = "2.2.0"
+tauri-plugin-dialog = "2.2.0"
+tauri-plugin-fs = "2.2.0"
+tauri-plugin-notification = "2.2.1"
+tauri-plugin-process = "2.2.0"
+tauri-plugin-clipboard-manager = "2.2.1"
+tauri-plugin-deep-link = "2.2.0"
+tauri-plugin-devtools = "2.0.0-rc"
+url = "2.5.4"
+zip = "2.2.3"
+reqwest_dav = "0.1.14"
+aes-gcm = { version = "0.10.3", features = ["std"] }
+base64 = "0.22.1"
+getrandom = "0.3.1"
+tokio-tungstenite = "0.26.2"
+futures = "0.3"
+sys-locale = "0.3.1"
+async-trait = "0.1.87"
+mihomo_api = { path = "./src/crate_mihomo_api" }
+ab_glyph = "0.2.29"
+tungstenite = "0.26.2"
 
 [target.'cfg(windows)'.dependencies]
-winreg = { version = "0.10", features = ["transactions"] }
+runas = "=1.2.0"
+deelevate = "0.2.0"
+winreg = "0.55.0"
+url = "2.5.4"
+
+[target.'cfg(target_os = "linux")'.dependencies]
+users = "0.11.0"
+
+[target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies]
+tauri-plugin-autostart = "2.2.0"
+tauri-plugin-global-shortcut = "2.2.0"
+tauri-plugin-updater = "2.5.1"
+tauri-plugin-window-state = "2.2.1"
+#openssl
 
 [features]
-default = [ "custom-protocol" ]
-custom-protocol = [ "tauri/custom-protocol" ]
+default = ["custom-protocol"]
+custom-protocol = ["tauri/custom-protocol"]
+verge-dev = []
+
+[profile.release]
+panic = "abort"
+codegen-units = 1
+lto = true
+opt-level = "s"
+strip = true
+
+[profile.dev]
+incremental = true
+
+[profile.fast-release]
+inherits = "release"  # 继承 release 的配置
+panic = "abort"       # 与 release 相同
+codegen-units = 256    # 增加编译单元，提升编译速度
+lto = false           # 禁用 LTO，提升编译速度
+opt-level = 0         # 禁用优化，大幅提升编译速度
+debug = true          # 保留调试信息
+strip = false         # 不剥离符号，保留调试信息
+
+[profile.fast-dev]
+inherits = "dev"      # 继承 dev 的配置
+codegen-units = 256    # 增加编译单元，提升编译速度
+opt-level = 0         # 禁用优化，进一步提升编译速度
+incremental = true    # 启用增量编译
+debug = true          # 保留调试信息
+strip = false         # 不剥离符号，保留调试信息
+
+[lib]
+name = "app_lib"
+crate-type = ["staticlib", "cdylib", "rlib"]
+
+[dev-dependencies]
+env_logger = "0.11.0"
+mockito = "1.7.0"
+tempfile = "3.17.1"
+
+[workspace]
+members = [
+    "src/crate_mihomo_api"
+]

src-tauri/build.rs

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

src-tauri/capabilities/desktop.json

@@ -0,0 +1,21 @@
+{
+  "identifier": "desktop-capability",
+  "platforms": ["macOS", "windows", "linux"],
+  "webviews": ["main"],
+  "windows": ["main"],
+  "permissions": [
+    "global-shortcut:default",
+    "updater:default",
+    "dialog:default",
+    "dialog:allow-ask",
+    "dialog:allow-message",
+    "updater:default",
+    "updater:allow-check",
+    "updater:allow-download-and-install",
+    "process:allow-restart",
+    "deep-link:default",
+    "window-state:default",
+    "window-state:default",
+    "autostart:default"
+  ]
+}

src-tauri/capabilities/migrated.json

@@ -0,0 +1,85 @@
+{
+  "identifier": "migrated",
+  "description": "permissions that were migrated from v1",
+  "local": true,
+  "windows": ["main"],
+  "permissions": [
+    "core:default",
+    "fs:allow-read-file",
+    "fs:allow-exists",
+    {
+      "identifier": "fs:scope",
+      "allow": ["$APPDATA/**", "$RESOURCE/../**", "**"]
+    },
+    "fs:allow-write-file",
+    {
+      "identifier": "fs:scope",
+      "allow": ["$APPDATA/**", "$RESOURCE/../**", "**"]
+    },
+    "fs:allow-app-read",
+    "fs:allow-app-read-recursive",
+    "fs:allow-appcache-read",
+    "fs:allow-appcache-read-recursive",
+    "fs:allow-appconfig-read",
+    "fs:allow-appconfig-read-recursive",
+    "core:window:allow-create",
+    "core:window:allow-center",
+    "core:window:allow-request-user-attention",
+    "core:window:allow-set-resizable",
+    "core:window:allow-set-maximizable",
+    "core:window:allow-set-minimizable",
+    "core:window:allow-set-closable",
+    "core:window:allow-set-title",
+    "core:window:allow-maximize",
+    "core:window:allow-unmaximize",
+    "core:window:allow-minimize",
+    "core:window:allow-unminimize",
+    "core:window:allow-show",
+    "core:window:allow-hide",
+    "core:window:allow-close",
+    "core:window:allow-set-decorations",
+    "core:window:allow-set-always-on-top",
+    "core:window:allow-set-content-protected",
+    "core:window:allow-set-size",
+    "core:window:allow-set-min-size",
+    "core:window:allow-set-max-size",
+    "core:window:allow-set-position",
+    "core:window:allow-set-fullscreen",
+    "core:window:allow-set-focus",
+    "core:window:allow-set-icon",
+    "core:window:allow-set-skip-taskbar",
+    "core:window:allow-set-cursor-grab",
+    "core:window:allow-set-cursor-visible",
+    "core:window:allow-set-cursor-icon",
+    "core:window:allow-set-cursor-position",
+    "core:window:allow-set-ignore-cursor-events",
+    "core:window:allow-start-dragging",
+    "core:window:allow-maximize",
+    "core:window:allow-toggle-maximize",
+    "core:window:allow-unmaximize",
+    "core:window:allow-minimize",
+    "core:window:allow-unminimize",
+    "core:window:allow-set-maximizable",
+    "core:window:allow-set-minimizable",
+    "core:webview:allow-print",
+    "shell:allow-execute",
+    "shell:allow-open",
+    "shell:allow-kill",
+    "shell:allow-spawn",
+    "shell:allow-stdin-write",
+    "dialog:allow-open",
+    "notification:default",
+    "global-shortcut:allow-is-registered",
+    "global-shortcut:allow-register",
+    "global-shortcut:allow-register-all",
+    "global-shortcut:allow-unregister",
+    "global-shortcut:allow-unregister-all",
+    "process:allow-restart",
+    "process:allow-exit",
+    "clipboard-manager:allow-read-text",
+    "clipboard-manager:allow-write-text",
+    "shell:default",
+    "dialog:default",
+    "notification:default"
+  ]
+}

src-tauri/packages/linux/clash-verge.desktop

@@ -0,0 +1,10 @@
+[Desktop Entry]
+Categories={{{categories}}}
+Comment={{{comment}}}
+Exec={{{exec}}} %u
+StartupWMClass={{{exec}}}
+Icon={{{icon}}}
+Name={{{name}}}
+Terminal=false
+Type=Application
+MimeType=x-scheme-handler/clash;

src-tauri/packages/linux/post-install.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+chmod +x /usr/bin/install-service
+chmod +x /usr/bin/uninstall-service
+chmod +x /usr/bin/clash-verge-service

src-tauri/packages/linux/pre-remove.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+/usr/bin/uninstall-service

src-tauri/packages/macos/entitlements.plist

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>com.apple.security.app-sandbox</key>
+    <false/>
+    <key>com.apple.security.application-groups</key>
+    <array>
+        <string>io.github.clash-verge-rev.clash-verge-rev</string>
+    </array>
+    <key>com.apple.security.inherit</key>
+    <true/>
+</dict>
+</plist>

src-tauri/resources/config_tmp.yaml

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

src-tauri/resources/profiles_tmp.yaml

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

src-tauri/resources/verge_tmp.yaml

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

src-tauri/rustfmt.toml

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

src-tauri/src/cmd/app.rs

@@ -0,0 +1,198 @@
+use super::CmdResult;
+use crate::{feat, utils::dirs, wrap_err};
+use tauri::Manager;
+
+/// 打开应用程序所在目录
+#[tauri::command]
+pub fn open_app_dir() -> CmdResult<()> {
+    let app_dir = wrap_err!(dirs::app_home_dir())?;
+    wrap_err!(open::that(app_dir))
+}
+
+/// 打开核心所在目录
+#[tauri::command]
+pub fn open_core_dir() -> CmdResult<()> {
+    let core_dir = wrap_err!(tauri::utils::platform::current_exe())?;
+    let core_dir = core_dir.parent().ok_or("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())?;
+    wrap_err!(open::that(log_dir))
+}
+
+/// 打开网页链接
+#[tauri::command]
+pub fn open_web_url(url: String) -> CmdResult<()> {
+    wrap_err!(open::that(url))
+}
+
+/// 打开/关闭开发者工具
+#[tauri::command]
+pub fn open_devtools(app_handle: tauri::AppHandle) {
+    if let Some(window) = app_handle.get_webview_window("main") {
+        if !window.is_devtools_open() {
+            window.open_devtools();
+        } else {
+            window.close_devtools();
+        }
+    }
+}
+
+/// 退出应用
+#[tauri::command]
+pub fn exit_app() {
+    feat::quit(Some(0));
+}
+
+/// 重启应用
+#[tauri::command]
+pub async fn restart_app() -> CmdResult<()> {
+    feat::restart_app();
+    Ok(())
+}
+
+/// 获取便携版标识
+#[tauri::command]
+pub fn get_portable_flag() -> CmdResult<bool> {
+    Ok(*dirs::PORTABLE_FLAG.get().unwrap_or(&false))
+}
+
+/// 获取应用目录
+#[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_path.exists() {
+        return Ok(icon_path.to_string_lossy().to_string());
+    }
+    
+    // 确保缓存目录存在
+    if !icon_cache_dir.exists() {
+        let _ = std::fs::create_dir_all(&icon_cache_dir);
+    }
+    
+    // 使用临时文件名来下载
+    let temp_path = icon_cache_dir.join(format!("{}.downloading", &name));
+    
+    // 下载文件到临时位置
+    let response = wrap_err!(reqwest::get(&url).await)?;
+    
+    // 检查内容类型是否为图片
+    let content_type = response.headers()
+        .get(reqwest::header::CONTENT_TYPE)
+        .and_then(|v| v.to_str().ok())
+        .unwrap_or("");
+    
+    let is_image = content_type.starts_with("image/");
+    
+    // 获取响应内容
+    let content = wrap_err!(response.bytes().await)?;
+    
+    // 检查内容是否为HTML (针对CDN错误页面)
+    let is_html = content.len() > 15 && 
+        (content.starts_with(b"<!DOCTYPE html") || 
+         content.starts_with(b"<html") || 
+         content.starts_with(b"<?xml"));
+    
+    // 只有当内容确实是图片时才保存
+    if is_image && !is_html {
+        {
+            let mut file = match std::fs::File::create(&temp_path) {
+                Ok(file) => file,
+                Err(_) => {
+                    if icon_path.exists() {
+                        return Ok(icon_path.to_string_lossy().to_string());
+                    } else {
+                        return Err("Failed to create temporary file".into());
+                    }
+                }
+            };
+            
+            wrap_err!(std::io::copy(&mut content.as_ref(), &mut file))?;
+        }
+        
+        // 再次检查目标文件是否已存在，避免重命名覆盖其他线程已完成的文件
+        if !icon_path.exists() {
+            match std::fs::rename(&temp_path, &icon_path) {
+                Ok(_) => {},
+                Err(_) => {
+                    let _ = std::fs::remove_file(&temp_path);
+                    if icon_path.exists() {
+                        return Ok(icon_path.to_string_lossy().to_string());
+                    }
+                }
+            }
+        } else {
+            let _ = std::fs::remove_file(&temp_path);
+        }
+        
+        Ok(icon_path.to_string_lossy().to_string())
+    } else {
+        let _ = std::fs::remove_file(&temp_path);
+        Err(format!("下载的内容不是有效图片: {}", url).into())
+    }
+}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
+pub struct IconInfo {
+    name: String,
+    previous_t: String,
+    current_t: String,
+}
+
+/// 复制图标文件
+#[tauri::command]
+pub fn copy_icon_file(path: String, icon_info: IconInfo) -> CmdResult<String> {
+    use std::fs;
+    use std::path::Path;
+
+    let file_path = Path::new(&path);
+
+    let icon_dir = wrap_err!(dirs::app_home_dir())?.join("icons");
+    if !icon_dir.exists() {
+        let _ = 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 dest_path = icon_dir.join(format!(
+        "{0}-{1}.{ext}",
+        icon_info.name, icon_info.current_t
+    ));
+    if file_path.exists() {
+        if icon_info.previous_t.trim() != "" {
+            fs::remove_file(
+                icon_dir.join(format!("{0}-{1}.png", icon_info.name, icon_info.previous_t)),
+            )
+            .unwrap_or_default();
+            fs::remove_file(
+                icon_dir.join(format!("{0}-{1}.ico", icon_info.name, icon_info.previous_t)),
+            )
+            .unwrap_or_default();
+        }
+
+        match 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())
+    }
+}

src-tauri/src/cmd/clash.rs

@@ -0,0 +1,220 @@
+use super::CmdResult;
+use crate::{config::*, core::*, feat, module::mihomo::MihomoManager, wrap_err};
+use serde_yaml::Mapping;
+
+/// 复制Clash环境变量
+#[tauri::command]
+pub fn copy_clash_env() -> CmdResult {
+    feat::copy_clash_env();
+    Ok(())
+}
+
+/// 获取Clash信息
+#[tauri::command]
+pub fn get_clash_info() -> CmdResult<ClashInfo> {
+    Ok(Config::clash().latest().get_client_info())
+}
+
+/// 修改Clash配置
+#[tauri::command]
+pub async fn patch_clash_config(payload: Mapping) -> CmdResult {
+    wrap_err!(feat::patch_clash(payload).await)
+}
+
+/// 修改Clash模式
+#[tauri::command]
+pub async fn patch_clash_mode(payload: String) -> CmdResult {
+    Ok(feat::change_clash_mode(payload))
+}
+
+/// 切换Clash核心
+#[tauri::command]
+pub async fn change_clash_core(clash_core: String) -> CmdResult<Option<String>> {
+    log::info!(target: "app", "changing core to {clash_core}");
+
+    match CoreManager::global()
+        .change_core(Some(clash_core.clone()))
+        .await
+    {
+        Ok(_) => {
+            log::info!(target: "app", "core changed to {clash_core}");
+            handle::Handle::notice_message("config_core::change_success", &clash_core);
+            handle::Handle::refresh_clash();
+            Ok(None)
+        }
+        Err(err) => {
+            let error_msg = err.to_string();
+            log::error!(target: "app", "failed to change core: {error_msg}");
+            handle::Handle::notice_message("config_core::change_error", &error_msg);
+            Ok(Some(error_msg))
+        }
+    }
+}
+
+/// 重启核心
+#[tauri::command]
+pub async fn restart_core() -> CmdResult {
+    wrap_err!(CoreManager::global().restart_core().await)
+}
+
+/// 获取代理延迟
+#[tauri::command]
+pub async fn clash_api_get_proxy_delay(
+    name: String,
+    url: Option<String>,
+    timeout: i32,
+) -> CmdResult<serde_json::Value> {
+    MihomoManager::global()
+        .test_proxy_delay(&name, url, timeout)
+        .await
+}
+
+/// 测试URL延迟
+#[tauri::command]
+pub async fn test_delay(url: String) -> CmdResult<u32> {
+    Ok(feat::test_delay(url).await.unwrap_or(10000u32))
+}
+
+/// 保存DNS配置到单独文件
+#[tauri::command]
+pub async fn save_dns_config(dns_config: Mapping) -> CmdResult {
+    use crate::utils::dirs;
+    use serde_yaml;
+    use std::fs;
+
+    // 获取DNS配置文件路径
+    let dns_path = dirs::app_home_dir()
+        .map_err(|e| e.to_string())?
+        .join("dns_config.yaml");
+
+    // 保存DNS配置到文件
+    let yaml_str = serde_yaml::to_string(&dns_config).map_err(|e| e.to_string())?;
+    fs::write(&dns_path, yaml_str).map_err(|e| e.to_string())?;
+    log::info!(target: "app", "DNS config saved to {:?}", dns_path);
+
+    Ok(())
+}
+
+/// 应用或撤销DNS配置
+#[tauri::command]
+pub fn apply_dns_config(apply: bool) -> CmdResult {
+    use crate::config::Config;
+    use crate::core::{handle, CoreManager};
+    use crate::utils::dirs;
+    use tauri::async_runtime;
+
+    // 使用spawn来处理异步操作
+    async_runtime::spawn(async move {
+        if apply {
+            // 读取DNS配置文件
+            let dns_path = match dirs::app_home_dir() {
+                Ok(path) => path.join("dns_config.yaml"),
+                Err(e) => {
+                    log::error!(target: "app", "Failed to get home dir: {}", e);
+                    return;
+                }
+            };
+
+            if !dns_path.exists() {
+                log::warn!(target: "app", "DNS config file not found");
+                return;
+            }
+
+            let dns_yaml = match std::fs::read_to_string(&dns_path) {
+                Ok(content) => content,
+                Err(e) => {
+                    log::error!(target: "app", "Failed to read DNS config: {}", e);
+                    return;
+                }
+            };
+
+            // 解析DNS配置并创建patch
+            let patch_config = match serde_yaml::from_str::<serde_yaml::Mapping>(&dns_yaml) {
+                Ok(config) => {
+                    let mut patch = serde_yaml::Mapping::new();
+                    patch.insert("dns".into(), config.into());
+                    patch
+                }
+                Err(e) => {
+                    log::error!(target: "app", "Failed to parse DNS config: {}", e);
+                    return;
+                }
+            };
+
+            log::info!(target: "app", "Applying DNS config from file");
+
+            // 重新生成配置，确保DNS配置被正确应用
+            // 这里不调用patch_clash以避免将DNS配置写入config.yaml
+            Config::runtime()
+                .latest()
+                .patch_config(patch_config.clone());
+
+            // 首先重新生成配置
+            if let Err(err) = Config::generate().await {
+                log::error!(target: "app", "Failed to regenerate config with DNS: {}", err);
+                return;
+            }
+
+            // 然后应用新配置
+            if let Err(err) = CoreManager::global().update_config().await {
+                log::error!(target: "app", "Failed to apply config with DNS: {}", err);
+            } else {
+                log::info!(target: "app", "DNS config successfully applied");
+                handle::Handle::refresh_clash();
+            }
+        } else {
+            // 当关闭DNS设置时，不需要对配置进行任何修改
+            // 直接重新生成配置，让enhance函数自动跳过DNS配置的加载
+            log::info!(target: "app", "DNS settings disabled, regenerating config");
+
+            // 重新生成配置
+            if let Err(err) = Config::generate().await {
+                log::error!(target: "app", "Failed to regenerate config: {}", err);
+                return;
+            }
+
+            // 应用新配置
+            match CoreManager::global().update_config().await {
+                Ok(_) => {
+                    log::info!(target: "app", "Config regenerated successfully");
+                    handle::Handle::refresh_clash();
+                }
+                Err(err) => {
+                    log::error!(target: "app", "Failed to apply regenerated config: {}", err);
+                }
+            }
+        }
+    });
+
+    Ok(())
+}
+
+/// 检查DNS配置文件是否存在
+#[tauri::command]
+pub fn check_dns_config_exists() -> CmdResult<bool> {
+    use crate::utils::dirs;
+
+    let dns_path = dirs::app_home_dir()
+        .map_err(|e| e.to_string())?
+        .join("dns_config.yaml");
+
+    Ok(dns_path.exists())
+}
+
+/// 获取DNS配置文件内容
+#[tauri::command]
+pub async fn get_dns_config_content() -> CmdResult<String> {
+    use crate::utils::dirs;
+    use std::fs;
+
+    let dns_path = dirs::app_home_dir()
+        .map_err(|e| e.to_string())?
+        .join("dns_config.yaml");
+
+    if !dns_path.exists() {
+        return Err("DNS config file not found".into());
+    }
+
+    let content = fs::read_to_string(&dns_path).map_err(|e| e.to_string())?;
+    Ok(content)
+}

src-tauri/src/cmd/mod.rs

@@ -0,0 +1,32 @@
+use anyhow::Result;
+
+// Common result type used by command functions
+pub type CmdResult<T = ()> = Result<T, String>;
+
+// Command modules
+pub mod profile;
+pub mod validate;
+pub mod uwp;
+pub mod webdav;
+pub mod app;
+pub mod network;
+pub mod clash;
+pub mod verge;
+pub mod runtime;
+pub mod save_profile;
+pub mod system;
+pub mod proxy;
+
+// Re-export all command functions for backwards compatibility
+pub use profile::*;
+pub use validate::*;
+pub use uwp::*;
+pub use webdav::*;
+pub use app::*;
+pub use network::*;
+pub use clash::*;
+pub use verge::*;
+pub use runtime::*;
+pub use save_profile::*;
+pub use system::*;
+pub use proxy::*;

src-tauri/src/cmd/network.rs

@@ -0,0 +1,64 @@
+use crate::wrap_err;
+use super::CmdResult;
+use sysproxy::{Autoproxy, Sysproxy};
+use serde_yaml::Mapping;
+use network_interface::NetworkInterface;
+
+/// get the system proxy
+#[tauri::command]
+pub fn get_sys_proxy() -> CmdResult<Mapping> {
+    let current = wrap_err!(Sysproxy::get_system_proxy())?;
+    let mut map = Mapping::new();
+    map.insert("enable".into(), current.enable.into());
+    map.insert(
+        "server".into(),
+        format!("{}:{}", current.host, current.port).into(),
+    );
+    map.insert("bypass".into(), current.bypass.into());
+
+    Ok(map)
+}
+
+/// 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_network_interfaces() -> Vec<String> {
+    use sysinfo::Networks;
+    let mut result = Vec::new();
+    let networks = Networks::new_with_refreshed_list();
+    for (interface_name, _) in &networks {
+        result.push(interface_name.clone());
+    }
+    result
+}
+
+/// 获取网络接口详细信息
+#[tauri::command]
+pub fn get_network_interfaces_info() -> CmdResult<Vec<NetworkInterface>> {
+    use network_interface::NetworkInterface;
+    use network_interface::NetworkInterfaceConfig;
+
+    let names = get_network_interfaces();
+    let interfaces = wrap_err!(NetworkInterface::show())?;
+
+    let mut result = Vec::new();
+
+    for interface in interfaces {
+        if names.contains(&interface.name) {
+            result.push(interface);
+        }
+    }
+
+    Ok(result)
+}

src-tauri/src/cmd/profile.rs

@@ -0,0 +1,176 @@
+use crate::{
+    config::*,
+    core::*,
+    feat,
+    utils::{dirs, help},
+    log_err, ret_err, wrap_err,
+};
+use super::CmdResult;
+
+/// 获取配置文件列表
+#[tauri::command]
+pub fn get_profiles() -> CmdResult<IProfiles> {
+    let _ = tray::Tray::global().update_menu();
+    Ok(Config::profiles().data().clone())
+}
+
+/// 增强配置文件
+#[tauri::command]
+pub async fn enhance_profiles() -> CmdResult {
+    match CoreManager::global().update_config().await {
+        Ok((true, _)) => {
+            println!("[enhance_profiles] 配置更新成功");
+            log_err!(tray::Tray::global().update_tooltip());
+            handle::Handle::refresh_clash();
+            Ok(())
+        }
+        Ok((false, error_msg)) => {
+            println!("[enhance_profiles] 配置验证失败: {}", error_msg);
+            handle::Handle::notice_message("config_validate::error", &error_msg);
+            Ok(())
+        }
+        Err(e) => {
+            println!("[enhance_profiles] 更新过程发生错误: {}", e);
+            handle::Handle::notice_message("config_validate::process_terminated", &e.to_string());
+            Ok(())
+        }
+    }
+}
+
+/// 导入配置文件
+#[tauri::command]
+pub async fn import_profile(url: String, option: Option<PrfOption>) -> CmdResult {
+    let item = wrap_err!(PrfItem::from_url(&url, None, None, option).await)?;
+    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)?;
+    wrap_err!(Config::profiles().data().append_item(item))
+}
+
+/// 更新配置文件
+#[tauri::command]
+pub async fn update_profile(index: String, option: Option<PrfOption>) -> CmdResult {
+    wrap_err!(feat::update_profile(index, option).await)
+}
+
+/// 删除配置文件
+#[tauri::command]
+pub async fn delete_profile(index: String) -> CmdResult {
+    let should_update = wrap_err!({ Config::profiles().data().delete_item(index) })?;
+    if should_update {
+        wrap_err!(CoreManager::global().update_config().await)?;
+        handle::Handle::refresh_clash();
+    }
+    Ok(())
+}
+
+/// 修改profiles的配置
+#[tauri::command]
+pub async fn patch_profiles_config(
+    profiles: IProfiles
+) -> CmdResult<bool> {
+    println!("[cmd配置patch] 开始修改配置文件");
+    
+    // 保存当前配置，以便在验证失败时恢复
+    let current_profile = Config::profiles().latest().current.clone();
+    println!("[cmd配置patch] 当前配置: {:?}", current_profile);
+    
+    // 更新profiles配置
+    println!("[cmd配置patch] 正在更新配置草稿");
+    wrap_err!({ Config::profiles().draft().patch_config(profiles) })?;
+    
+    // 更新配置并进行验证
+    match CoreManager::global().update_config().await {
+        Ok((true, _)) => {
+            println!("[cmd配置patch] 配置更新成功");
+            handle::Handle::refresh_clash();
+            let _ = tray::Tray::global().update_tooltip();
+            Config::profiles().apply();
+            wrap_err!(Config::profiles().data().save_file())?;
+            Ok(true)
+        }
+        Ok((false, error_msg)) => {
+            println!("[cmd配置patch] 配置验证失败: {}", error_msg);
+            Config::profiles().discard();
+            
+            // 如果验证失败，恢复到之前的配置
+            if let Some(prev_profile) = current_profile {
+                println!("[cmd配置patch] 尝试恢复到之前的配置: {}", prev_profile);
+                let restore_profiles = IProfiles {
+                    current: Some(prev_profile),
+                    items: None,
+                };
+                // 静默恢复，不触发验证
+                wrap_err!({ Config::profiles().draft().patch_config(restore_profiles) })?;
+                Config::profiles().apply();
+                wrap_err!(Config::profiles().data().save_file())?;
+                println!("[cmd配置patch] 成功恢复到之前的配置");
+            }
+
+            // 发送验证错误通知
+            handle::Handle::notice_message("config_validate::error", &error_msg);
+            Ok(false)
+        }
+        Err(e) => {
+            println!("[cmd配置patch] 更新过程发生错误: {}", e);
+            Config::profiles().discard();
+            handle::Handle::notice_message("config_validate::boot_error", &e.to_string());
+            Ok(false)
+        }
+    }
+}
+
+/// 根据profile name修改profiles
+#[tauri::command]
+pub async fn patch_profiles_config_by_profile_index(
+    _app_handle: tauri::AppHandle,
+    profile_index: String
+) -> CmdResult<bool> {
+    let profiles = IProfiles{current: Some(profile_index), items: None};
+    patch_profiles_config(profiles).await
+}
+
+/// 修改某个profile item的
+#[tauri::command]
+pub fn patch_profile(index: String, profile: PrfItem) -> CmdResult {
+    wrap_err!(Config::profiles().data().patch_item(index, profile))?;
+    Ok(())
+}
+
+/// 查看配置文件
+#[tauri::command]
+pub fn view_profile(app_handle: tauri::AppHandle, index: String) -> CmdResult {
+    let file = {
+        wrap_err!(Config::profiles().latest().get_item(&index))?
+            .file
+            .clone()
+            .ok_or("the file field is null")
+    }?;
+
+    let path = wrap_err!(dirs::app_profiles_dir())?.join(file);
+    if !path.exists() {
+        ret_err!("the file not found");
+    }
+
+    wrap_err!(help::open_file(app_handle, path))
+}
+
+/// 读取配置文件内容
+#[tauri::command]
+pub fn read_profile_file(index: String) -> CmdResult<String> {
+    let profiles = Config::profiles();
+    let profiles = profiles.latest();
+    let item = wrap_err!(profiles.get_item(&index))?;
+    let data = wrap_err!(item.read_file())?;
+    Ok(data)
+}

src-tauri/src/cmd/proxy.rs

@@ -0,0 +1,16 @@
+use super::CmdResult;
+use crate::module::mihomo::MihomoManager;
+
+#[tauri::command]
+pub async fn get_proxies() -> CmdResult<serde_json::Value> {
+    let mannager = MihomoManager::global();
+    mannager.refresh_proxies().await.unwrap();
+    Ok(mannager.get_proxies())
+}
+
+#[tauri::command]
+pub async fn get_providers_proxies() -> CmdResult<serde_json::Value> {
+    let mannager = MihomoManager::global();
+    mannager.refresh_providers_proxies().await.unwrap();
+    Ok(mannager.get_providers_proxies())
+}

src-tauri/src/cmd/runtime.rs

@@ -0,0 +1,39 @@
+use crate::{
+    config::*,
+    wrap_err,
+};
+use super::CmdResult;
+use anyhow::Context;
+use std::collections::HashMap;
+use serde_yaml::Mapping;
+
+/// 获取运行时配置
+#[tauri::command]
+pub fn get_runtime_config() -> CmdResult<Option<Mapping>> {
+    Ok(Config::runtime().latest().config.clone())
+}
+
+/// 获取运行时YAML配置
+#[tauri::command]
+pub fn get_runtime_yaml() -> CmdResult<String> {
+    let runtime = Config::runtime();
+    let runtime = runtime.latest();
+    let config = runtime.config.as_ref();
+    wrap_err!(config
+        .ok_or(anyhow::anyhow!("failed to parse config to yaml file"))
+        .and_then(
+            |config| serde_yaml::to_string(config).context("failed to convert config to yaml")
+        ))
+}
+
+/// 获取运行时存在的键
+#[tauri::command]
+pub fn get_runtime_exists() -> CmdResult<Vec<String>> {
+    Ok(Config::runtime().latest().exists_keys.clone())
+}
+
+/// 获取运行时日志
+#[tauri::command]
+pub fn get_runtime_logs() -> CmdResult<HashMap<String, Vec<(String, String)>>> {
+    Ok(Config::runtime().latest().chain_logs.clone())
+}

src-tauri/src/cmd/save_profile.rs

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

src-tauri/src/cmd/system.rs

@@ -0,0 +1,35 @@
+use super::CmdResult;
+use crate::core::handle;
+use crate::module::sysinfo::PlatformSpecification;
+use tauri_plugin_clipboard_manager::ClipboardExt;
+use crate::{core::{self, CoreManager, service}, wrap_err};
+
+#[tauri::command]
+pub async fn export_diagnostic_info() -> CmdResult<()> {
+    let sysinfo = PlatformSpecification::new();
+    let info = format!("{:?}", sysinfo);
+
+    let app_handle = handle::Handle::global().app_handle().unwrap();
+    let cliboard = app_handle.clipboard();
+    
+    if let Err(_) = cliboard.write_text(info) {
+        log::error!(target: "app", "Failed to write to clipboard");
+    }
+    Ok(())
+}
+
+/// 获取当前内核运行模式
+#[tauri::command]
+pub async fn get_running_mode() -> Result<String, String> {
+    match CoreManager::global().get_running_mode().await {
+        core::RunningMode::Service => Ok("service".to_string()),
+        core::RunningMode::Sidecar => Ok("sidecar".to_string()),
+        core::RunningMode::NotRunning => Ok("not_running".to_string()),
+    }
+}
+
+/// 安装/重装系统服务
+#[tauri::command]
+pub async fn install_service() -> CmdResult {
+    wrap_err!(service::reinstall_service().await)
+}

src-tauri/src/cmd/uwp.rs

@@ -0,0 +1,29 @@
+use super::CmdResult;
+
+/// Platform-specific implementation for UWP functionality
+#[cfg(windows)]
+mod platform {
+    use super::CmdResult;
+    use crate::core::win_uwp;
+    use crate::wrap_err;
+
+    pub async fn invoke_uwp_tool() -> CmdResult {
+        wrap_err!(win_uwp::invoke_uwptools().await)
+    }
+}
+
+/// Stub implementation for non-Windows platforms
+#[cfg(not(windows))]
+mod platform {
+    use super::CmdResult;
+
+    pub async fn invoke_uwp_tool() -> CmdResult {
+        Ok(())
+    }
+}
+
+/// Command exposed to Tauri
+#[tauri::command]
+pub async fn invoke_uwp_tool() -> CmdResult {
+    platform::invoke_uwp_tool().await
+}

src-tauri/src/cmd/validate.rs

@@ -0,0 +1,101 @@
+use crate::core::*;
+use super::CmdResult;
+
+/// 发送脚本验证通知消息
+#[tauri::command]
+pub async fn script_validate_notice(status: String, msg: String) -> CmdResult {
+    handle::Handle::notice_message(&status, &msg);
+    Ok(())
+}
+
+/// 处理脚本验证相关的所有消息通知
+/// 统一通知接口，保持消息类型一致性
+pub fn handle_script_validation_notice(result: &(bool, String), file_type: &str) {
+    if !result.0 {
+        let error_msg = &result.1;
+        
+        // 根据错误消息内容判断错误类型
+        let status = if error_msg.starts_with("File not found:") {
+            "config_validate::file_not_found"
+        } else if error_msg.starts_with("Failed to read script file:") {
+            "config_validate::script_error"
+        } else if error_msg.starts_with("Script syntax error:") {
+            "config_validate::script_syntax_error"
+        } else if error_msg == "Script must contain a main function" {
+            "config_validate::script_missing_main"
+        } else {
+            // 如果是其他类型错误，作为一般脚本错误处理
+            "config_validate::script_error"
+        };
+        
+        log::warn!(target: "app", "{} 验证失败: {}", file_type, error_msg);
+        handle::Handle::notice_message(status, error_msg);
+    }
+}
+
+/// 验证指定脚本文件
+#[tauri::command]
+pub async fn validate_script_file(file_path: String) -> CmdResult<bool> {
+    log::info!(target: "app", "验证脚本文件: {}", file_path);
+    
+    match CoreManager::global().validate_config_file(&file_path, None).await {
+        Ok(result) => {
+            handle_script_validation_notice(&result, "脚本文件");
+            Ok(result.0)  // 返回验证结果布尔值
+        },
+        Err(e) => {
+            let error_msg = e.to_string();
+            log::error!(target: "app", "验证脚本文件过程发生错误: {}", error_msg);
+            handle::Handle::notice_message("config_validate::process_terminated", &error_msg);
+            Ok(false)
+        }
+    }
+}
+
+/// 处理YAML验证相关的所有消息通知
+/// 统一通知接口，保持消息类型一致性
+pub fn handle_yaml_validation_notice(result: &(bool, String), file_type: &str) {
+    if !result.0 {
+        let error_msg = &result.1;
+        println!("[通知] 处理{}验证错误: {}", file_type, error_msg);
+        
+        // 检查是否为merge文件
+        let is_merge_file = file_type.contains("合并");
+        
+        // 根据错误消息内容判断错误类型
+        let status = if error_msg.starts_with("File not found:") {
+            "config_validate::file_not_found"
+        } else if error_msg.starts_with("Failed to read file:") {
+            "config_validate::yaml_read_error"
+        } else if error_msg.starts_with("YAML syntax error:") {
+            if is_merge_file {
+                "config_validate::merge_syntax_error"
+            } else {
+                "config_validate::yaml_syntax_error"
+            }
+        } else if error_msg.contains("mapping values are not allowed") {
+            if is_merge_file {
+                "config_validate::merge_mapping_error"
+            } else {
+                "config_validate::yaml_mapping_error"
+            }
+        } else if error_msg.contains("did not find expected key") {
+            if is_merge_file {
+                "config_validate::merge_key_error"
+            } else {
+                "config_validate::yaml_key_error"
+            }
+        } else {
+            // 如果是其他类型错误，根据文件类型作为一般错误处理
+            if is_merge_file {
+                "config_validate::merge_error"
+            } else {
+                "config_validate::yaml_error"
+            }
+        };
+        
+        log::warn!(target: "app", "{} 验证失败: {}", file_type, error_msg);
+        println!("[通知] 发送通知: status={}, msg={}", status, error_msg);
+        handle::Handle::notice_message(status, error_msg);
+    }
+}

src-tauri/src/cmd/verge.rs

@@ -0,0 +1,20 @@
+use crate::{
+    config::*,
+    feat,
+    wrap_err,
+};
+use super::CmdResult;
+
+/// 获取Verge配置
+#[tauri::command]
+pub fn get_verge_config() -> CmdResult<IVergeResponse> {
+    let verge = Config::verge();
+    let verge_data = verge.data().clone();
+    Ok(IVergeResponse::from(verge_data))
+}
+
+/// 修改Verge配置
+#[tauri::command]
+pub async fn patch_verge_config(payload: IVerge) -> CmdResult {
+    wrap_err!(feat::patch_verge(payload, false).await)
+}

src-tauri/src/cmd/webdav.rs

@@ -0,0 +1,51 @@
+use crate::{
+    core,
+    config::*,
+    feat,
+    wrap_err,
+};
+use super::CmdResult;
+use reqwest_dav::list_cmd::ListFile;
+
+/// 保存 WebDAV 配置
+#[tauri::command]
+pub async fn save_webdav_config(url: String, username: String, password: String) -> CmdResult<()> {
+    let patch = IVerge {
+        webdav_url: Some(url),
+        webdav_username: Some(username),
+        webdav_password: Some(password),
+        ..IVerge::default()
+    };
+    Config::verge().draft().patch_config(patch.clone());
+    Config::verge().apply();
+    Config::verge()
+        .data()
+        .save_file()
+        .map_err(|err| err.to_string())?;
+    core::backup::WebDavClient::global().reset();
+    Ok(())
+}
+
+/// 创建 WebDAV 备份并上传
+#[tauri::command]
+pub async fn create_webdav_backup() -> CmdResult<()> {
+    wrap_err!(feat::create_backup_and_upload_webdav().await)
+}
+
+/// 列出 WebDAV 上的备份文件
+#[tauri::command]
+pub async fn list_webdav_backup() -> CmdResult<Vec<ListFile>> {
+    wrap_err!(feat::list_wevdav_backup().await)
+}
+
+/// 删除 WebDAV 上的备份文件
+#[tauri::command]
+pub async fn delete_webdav_backup(filename: String) -> CmdResult<()> {
+    wrap_err!(feat::delete_webdav_backup(filename).await)
+}
+
+/// 从 WebDAV 恢复备份文件
+#[tauri::command]
+pub async fn restore_webdav_backup(filename: String) -> CmdResult<()> {
+    wrap_err!(feat::restore_webdav_backup(filename).await)
+}

src-tauri/src/cmds/mod.rs

@@ -1,2 +0,0 @@
-pub mod profile;
-pub mod some;

src-tauri/src/cmds/profile.rs

@@ -1,190 +0,0 @@
-use crate::{
-  config::{ProfileItem, ProfilesConfig},
-  events::state::{ClashInfoState, ProfileLock},
-  utils::{
-    app_home_dir,
-    clash::put_clash_profile,
-    config::{read_profiles, save_profiles},
-    fetch::fetch_profile,
-  },
-};
-use std::fs::File;
-use std::io::Write;
-use std::time::{SystemTime, UNIX_EPOCH};
-use tauri::State;
-
-/// Import the profile from url
-/// and save to `profiles.yaml`
-#[tauri::command]
-pub async fn import_profile(url: String, lock: State<'_, ProfileLock>) -> Result<(), String> {
-  let result = match fetch_profile(&url).await {
-    Some(r) => r,
-    None => {
-      log::error!("failed to fetch profile from `{}`", url);
-      return Err(format!("failed to fetch profile from `{}`", url));
-    }
-  };
-
-  // get lock
-  if lock.0.lock().is_err() {
-    return Err(format!("can not get file lock"));
-  }
-
-  // save the profile file
-  let path = app_home_dir().join("profiles").join(&result.file);
-  let file_data = result.data.as_bytes();
-  File::create(path).unwrap().write(file_data).unwrap();
-
-  // update `profiles.yaml`
-  let mut profiles = read_profiles();
-  let mut items = profiles.items.unwrap_or(vec![]);
-
-  let now = SystemTime::now()
-    .duration_since(UNIX_EPOCH)
-    .unwrap()
-    .as_secs();
-
-  items.push(ProfileItem {
-    name: Some(result.name),
-    file: Some(result.file),
-    mode: Some(format!("rule")),
-    url: Some(url),
-    selected: Some(vec![]),
-    extra: Some(result.extra),
-    updated: Some(now as usize),
-  });
-  profiles.items = Some(items);
-  save_profiles(&profiles)
-}
-
-/// Update the profile
-/// and save to `profiles.yaml`
-/// http request firstly
-/// then acquire the lock of `profiles.yaml`
-#[tauri::command]
-pub async fn update_profile(index: usize, lock: State<'_, ProfileLock>) -> Result<(), String> {
-  // get lock
-  if lock.0.lock().is_err() {
-    return Err(format!("can not get file lock"));
-  }
-
-  // update `profiles.yaml`
-  let mut profiles = read_profiles();
-  let mut items = profiles.items.unwrap_or(vec![]);
-
-  if index >= items.len() {
-    return Err(format!("the index out of bound"));
-  }
-
-  let url = match &items[index].url {
-    Some(u) => u,
-    None => return Err(format!("invalid url")),
-  };
-
-  let result = match fetch_profile(&url).await {
-    Some(r) => r,
-    None => {
-      log::error!("failed to fetch profile from `{}`", url);
-      return Err(format!("failed to fetch profile from `{}`", url));
-    }
-  };
-
-  let now = SystemTime::now()
-    .duration_since(UNIX_EPOCH)
-    .unwrap()
-    .as_secs() as usize;
-
-  // update file
-  let file_path = &items[index].file.as_ref().unwrap();
-  let file_path = app_home_dir().join("profiles").join(file_path);
-  let file_data = result.data.as_bytes();
-  File::create(file_path).unwrap().write(file_data).unwrap();
-
-  items[index].name = Some(result.name);
-  items[index].extra = Some(result.extra);
-  items[index].updated = Some(now);
-  profiles.items = Some(items);
-  save_profiles(&profiles)
-}
-
-/// get all profiles from `profiles.yaml`
-/// do not acquire the lock of ProfileLock
-#[tauri::command]
-pub fn get_profiles() -> Result<ProfilesConfig, String> {
-  Ok(read_profiles())
-}
-
-/// patch the profile config
-#[tauri::command]
-pub fn set_profiles(
-  index: usize,
-  profile: ProfileItem,
-  lock: State<'_, ProfileLock>,
-) -> Result<(), String> {
-  // get lock
-  if lock.0.lock().is_err() {
-    return Err(format!("can not get file lock"));
-  }
-
-  let mut profiles = read_profiles();
-  let mut items = profiles.items.unwrap_or(vec![]);
-
-  if index >= items.len() {
-    return Err(format!("the index out of bound"));
-  }
-
-  if profile.name.is_some() {
-    items[index].name = profile.name;
-  }
-  if profile.file.is_some() {
-    items[index].file = profile.file;
-  }
-  if profile.mode.is_some() {
-    items[index].mode = profile.mode;
-  }
-  if profile.url.is_some() {
-    items[index].url = profile.url;
-  }
-  if profile.selected.is_some() {
-    items[index].selected = profile.selected;
-  }
-  if profile.extra.is_some() {
-    items[index].extra = profile.extra;
-  }
-
-  profiles.items = Some(items);
-  save_profiles(&profiles)
-}
-
-/// change the current profile
-#[tauri::command]
-pub async fn put_profiles(
-  current: usize,
-  lock: State<'_, ProfileLock>,
-  clash_info: State<'_, ClashInfoState>,
-) -> Result<(), String> {
-  if lock.0.lock().is_err() {
-    return Err(format!("can not get file lock"));
-  }
-
-  let clash_info = match clash_info.0.lock() {
-    Ok(arc) => arc.clone(),
-    _ => return Err(format!("can not get clash info")),
-  };
-
-  let mut profiles = read_profiles();
-  let items_len = match &profiles.items {
-    Some(list) => list.len(),
-    None => 0,
-  };
-
-  if current >= items_len {
-    return Err(format!("the index out of bound"));
-  }
-
-  profiles.current = Some(current);
-  match save_profiles(&profiles) {
-    Ok(_) => put_clash_profile(&clash_info).await,
-    Err(err) => Err(err),
-  }
-}

src-tauri/src/cmds/some.rs

@@ -1,154 +0,0 @@
-use crate::{
-  config::VergeConfig,
-  events::{
-    emit::ClashInfoPayload,
-    state::{ClashInfoState, VergeConfLock},
-  },
-  utils::{
-    clash::run_clash_bin,
-    config::{read_clash, save_clash, save_verge},
-    sysopt::{get_proxy_config, set_proxy_config, SysProxyConfig, DEFAULT_BYPASS},
-  },
-};
-use serde_yaml::Mapping;
-use tauri::{api::process::kill_children, AppHandle, State};
-
-/// restart the sidecar
-#[tauri::command]
-pub fn restart_sidecar(app_handle: AppHandle, clash_info: State<'_, ClashInfoState>) {
-  kill_children();
-  let payload = run_clash_bin(&app_handle);
-
-  if let Ok(mut arc) = clash_info.0.lock() {
-    *arc = payload;
-  }
-}
-
-/// get the clash core info from the state
-/// the caller can also get the infomation by clash's api
-#[tauri::command]
-pub fn get_clash_info(clash_info: State<'_, ClashInfoState>) -> Result<ClashInfoPayload, String> {
-  match clash_info.0.lock() {
-    Ok(arc) => Ok(arc.clone()),
-    Err(_) => Err(format!("can not get clash info")),
-  }
-}
-
-/// update the clash core config
-/// after putting the change to the clash core
-/// then we should save the latest config
-#[tauri::command]
-pub fn patch_clash_config(payload: Mapping) -> Result<(), String> {
-  let mut config = read_clash();
-  for (key, value) in payload.iter() {
-    if config.contains_key(key) {
-      config[key] = value.clone();
-    } else {
-      config.insert(key.clone(), value.clone());
-    }
-  }
-  save_clash(&config)
-}
-
-/// set the system proxy
-/// Tips: only support windows now
-#[tauri::command]
-pub fn set_sys_proxy(
-  enable: bool,
-  clash_info: State<'_, ClashInfoState>,
-  verge_lock: State<'_, VergeConfLock>,
-) -> Result<(), String> {
-  let clash_info = match clash_info.0.lock() {
-    Ok(arc) => arc.clone(),
-    _ => return Err(format!("can not get clash info")),
-  };
-
-  let verge_info = match verge_lock.0.lock() {
-    Ok(arc) => arc.clone(),
-    _ => return Err(format!("can not get verge info")),
-  };
-
-  let port = match clash_info.controller {
-    Some(ctrl) => ctrl.port,
-    None => None,
-  };
-
-  if port.is_none() {
-    return Err(format!("can not get clash core's port"));
-  }
-
-  let config = if enable {
-    let server = format!("127.0.0.1:{}", port.unwrap());
-    let bypass = verge_info
-      .system_proxy_bypass
-      .unwrap_or(String::from(DEFAULT_BYPASS));
-    SysProxyConfig {
-      enable,
-      server,
-      bypass,
-    }
-  } else {
-    SysProxyConfig {
-      enable,
-      server: String::from(""),
-      bypass: String::from(""),
-    }
-  };
-
-  match set_proxy_config(&config) {
-    Ok(_) => Ok(()),
-    Err(_) => Err(format!("can not set proxy")),
-  }
-}
-
-/// get the system proxy
-/// Tips: only support windows now
-#[tauri::command]
-pub fn get_sys_proxy() -> Result<SysProxyConfig, String> {
-  match get_proxy_config() {
-    Ok(value) => Ok(value),
-    Err(err) => Err(err.to_string()),
-  }
-}
-
-/// get the verge config
-#[tauri::command]
-pub fn get_verge_config(verge_lock: State<'_, VergeConfLock>) -> Result<VergeConfig, String> {
-  match verge_lock.0.lock() {
-    Ok(arc) => Ok(arc.clone()),
-    Err(_) => Err(format!("can not get the lock")),
-  }
-}
-
-/// patch the verge config
-/// this command only save the config and not responsible for other things
-#[tauri::command]
-pub async fn patch_verge_config(
-  payload: VergeConfig,
-  verge_lock: State<'_, VergeConfLock>,
-) -> Result<(), String> {
-  let mut verge = match verge_lock.0.lock() {
-    Ok(v) => v,
-    Err(_) => return Err(format!("can not get the lock")),
-  };
-
-  if payload.theme_mode.is_some() {
-    verge.theme_mode = payload.theme_mode;
-  }
-
-  // todo
-  if payload.enable_self_startup.is_some() {
-    verge.enable_self_startup = payload.enable_self_startup;
-  }
-
-  // todo
-  if payload.enable_system_proxy.is_some() {
-    verge.enable_system_proxy = payload.enable_system_proxy;
-  }
-
-  if payload.system_proxy_bypass.is_some() {
-    verge.system_proxy_bypass = payload.system_proxy_bypass;
-  }
-
-  save_verge(&verge)
-}

src-tauri/src/config/clash.rs

@@ -1,30 +1,367 @@
+use crate::utils::{dirs, help};
+use anyhow::Result;
 use serde::{Deserialize, Serialize};
+use serde_yaml::{Mapping, Value};
+use std::{
+    net::{IpAddr, Ipv4Addr, SocketAddr},
+    str::FromStr,
+};
 
-/// ### `config.yaml` schema
-/// here should contain all configuration options.
-/// See: https://github.com/Dreamacro/clash/wiki/configuration for details
-#[derive(Default, Debug, Clone, Deserialize, Serialize)]
-pub struct ClashConfig {
-  pub port: Option<u32>,
+#[derive(Default, Debug, Clone)]
+pub struct IClashTemp(pub Mapping);
 
-  /// alias to `mixed-port`
-  pub mixed_port: Option<u32>,
+impl IClashTemp {
+    pub fn new() -> Self {
+        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}");
+                template
+            }
+        }
+    }
 
-  /// alias to `allow-lan`
-  pub allow_lan: Option<bool>,
+    pub fn template() -> Self {
+        let mut map = Mapping::new();
+        let mut tun = Mapping::new();
+        tun.insert("enable".into(), false.into());
+        tun.insert("stack".into(), "mixed".into());
+        tun.insert("auto-route".into(), true.into());
+        tun.insert("strict-route".into(), false.into());
+        tun.insert("auto-detect-interface".into(), true.into());
+        tun.insert("dns-hijack".into(), vec!["any:53"].into());
 
-  /// alias to `external-controller`
-  pub external_ctrl: Option<String>,
+        #[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:9097".into());
+        let mut cors_map = Mapping::new();
+        cors_map.insert("allow-private-network".into(), true.into());
+        cors_map.insert("allow-origins".into(), vec!["*"].into());
+        map.insert("secret".into(), "".into());
+        map.insert("tun".into(), tun.into());
+        map.insert("external-controller-cors".into(), cors_map.into());
+        map.insert("unified-delay".into(), true.into());
+        Self(map)
+    }
 
-  pub secret: Option<String>,
+    fn guard(mut config: Mapping) -> Mapping {
+        #[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);
+        #[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
+    }
+
+    pub fn patch_config(&mut self, patch: Mapping) {
+        for (key, value) in patch.into_iter() {
+            self.0.insert(key, value);
+        }
+    }
+
+    pub fn save_config(&self) -> Result<()> {
+        help::save_yaml(
+            &dirs::clash_path()?,
+            &self.0,
+            Some("# Generated by Clash Verge"),
+        )
+    }
+
+    pub fn get_mixed_port(&self) -> u16 {
+        Self::guard_mixed_port(&self.0)
+    }
+
+    #[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 {
+            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()),
+                Value::Number(val_num) => Some(val_num.to_string()),
+                _ => None,
+            }),
+        }
+    }
+    #[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 raw_value = config.get("mixed-port");
+
+        let mut port = raw_value
+            .and_then(|value| match value {
+                Value::String(val_str) => val_str.parse().ok(),
+                Value::Number(val_num) => val_num.as_u64().map(|u| u as u16),
+                _ => None,
+            })
+            .unwrap_or(7897);
+
+        if port == 0 {
+            port = 7897;
+        }
+
+        port
+    }
+
+    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
+    }
+
+    pub fn guard_server_ctrl(config: &Mapping) -> String {
+        config
+            .get("external-controller")
+            .and_then(|value| match value.as_str() {
+                Some(val_str) => {
+                    let val_str = val_str.trim();
+
+                    let val = match val_str.starts_with(':') {
+                        true => format!("127.0.0.1{val_str}"),
+                        false => val_str.to_owned(),
+                    };
+
+                    SocketAddr::from_str(val.as_str())
+                        .ok()
+                        .map(|s| s.to_string())
+                }
+                None => None,
+            })
+            .unwrap_or("127.0.0.1:9097".into())
+    }
+
+    pub fn guard_client_ctrl(config: &Mapping) -> String {
+        let value = Self::guard_server_ctrl(config);
+        match SocketAddr::from_str(value.as_str()) {
+            Ok(mut socket) => {
+                if socket.ip().is_unspecified() {
+                    socket.set_ip(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)));
+                }
+                socket.to_string()
+            }
+            Err(_) => "127.0.0.1:9097".into(),
+        }
+    }
 }
 
-#[derive(Default, Debug, Clone, Deserialize, Serialize)]
-pub struct ClashController {
-  /// clash core port
-  pub port: Option<String>,
-
-  /// same as `external-controller`
-  pub server: Option<String>,
-  pub secret: Option<String>,
+#[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,
+    /// clash secret
+    pub secret: Option<String>,
+}
+
+#[test]
+fn test_clash_info() {
+    fn get_case<T: Into<Value>, D: Into<Value>>(mp: T, ec: D) -> ClashInfo {
+        let mut map = Mapping::new();
+        map.insert("mixed-port".into(), mp.into());
+        map.insert("external-controller".into(), ec.into());
+
+        IClashTemp(IClashTemp::guard(map)).get_client_info()
+    }
+
+    fn get_result<S: Into<String>>(port: u16, server: S) -> ClashInfo {
+        ClashInfo {
+            mixed_port: port,
+            socks_port: 7898,
+            port: 7899,
+            server: server.into(),
+            secret: None,
+        }
+    }
+
+    assert_eq!(
+        IClashTemp(IClashTemp::guard(Mapping::new())).get_client_info(),
+        get_result(7897, "127.0.0.1:9097")
+    );
+
+    assert_eq!(get_case("", ""), get_result(7897, "127.0.0.1:9097"));
+
+    assert_eq!(get_case(65537, ""), get_result(1, "127.0.0.1:9097"));
+
+    assert_eq!(
+        get_case(8888, "127.0.0.1:8888"),
+        get_result(8888, "127.0.0.1:8888")
+    );
+
+    assert_eq!(
+        get_case(8888, "   :98888 "),
+        get_result(8888, "127.0.0.1:9097")
+    );
+
+    assert_eq!(
+        get_case(8888, "0.0.0.0:8080  "),
+        get_result(8888, "127.0.0.1:8080")
+    );
+
+    assert_eq!(
+        get_case(8888, "0.0.0.0:8080"),
+        get_result(8888, "127.0.0.1:8080")
+    );
+
+    assert_eq!(
+        get_case(8888, "[::]:8080"),
+        get_result(8888, "127.0.0.1:8080")
+    );
+
+    assert_eq!(
+        get_case(8888, "192.168.1.1:8080"),
+        get_result(8888, "192.168.1.1:8080")
+    );
+
+    assert_eq!(
+        get_case(8888, "192.168.1.1:80800"),
+        get_result(8888, "127.0.0.1:9097")
+    );
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "kebab-case")]
+pub struct IClash {
+    pub mixed_port: Option<u16>,
+    pub allow_lan: Option<bool>,
+    pub log_level: Option<String>,
+    pub ipv6: Option<bool>,
+    pub mode: Option<String>,
+    pub external_controller: Option<String>,
+    pub secret: Option<String>,
+    pub dns: Option<IClashDNS>,
+    pub tun: Option<IClashTUN>,
+    pub interface_name: Option<String>,
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "kebab-case")]
+pub struct IClashTUN {
+    pub enable: Option<bool>,
+    pub stack: Option<String>,
+    pub auto_route: Option<bool>,
+    pub auto_detect_interface: Option<bool>,
+    pub dns_hijack: Option<Vec<String>>,
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "kebab-case")]
+pub struct IClashDNS {
+    pub enable: Option<bool>,
+    pub listen: Option<String>,
+    pub default_nameserver: Option<Vec<String>>,
+    pub enhanced_mode: Option<String>,
+    pub fake_ip_range: Option<String>,
+    pub use_hosts: Option<bool>,
+    pub fake_ip_filter: Option<Vec<String>>,
+    pub nameserver: Option<Vec<String>>,
+    pub fallback: Option<Vec<String>>,
+    pub fallback_filter: Option<IClashFallbackFilter>,
+    pub nameserver_policy: Option<Vec<String>>,
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "kebab-case")]
+pub struct IClashFallbackFilter {
+    pub geoip: Option<bool>,
+    pub geoip_code: Option<String>,
+    pub ipcidr: Option<Vec<String>>,
+    pub domain: Option<Vec<String>>,
 }

src-tauri/src/config/config.rs

@@ -0,0 +1,159 @@
+use super::{Draft, IClashTemp, IProfiles, IRuntime, IVerge};
+use crate::{
+    config::PrfItem,
+    enhance,
+    utils::{dirs, help},
+    core::{handle, CoreManager},
+};
+use anyhow::{anyhow, Result};
+use once_cell::sync::OnceCell;
+use std::path::PathBuf;
+use tokio::time::{sleep, Duration};
+
+pub const RUNTIME_CONFIG: &str = "clash-verge.yaml";
+pub const CHECK_CONFIG: &str = "clash-verge-check.yaml";
+
+pub struct Config {
+    clash_config: Draft<IClashTemp>,
+    verge_config: Draft<IVerge>,
+    profiles_config: Draft<IProfiles>,
+    runtime_config: Draft<IRuntime>,
+}
+
+impl Config {
+    pub fn global() -> &'static Config {
+        static CONFIG: OnceCell<Config> = OnceCell::new();
+
+        CONFIG.get_or_init(|| Config {
+            clash_config: Draft::from(IClashTemp::new()),
+            verge_config: Draft::from(IVerge::new()),
+            profiles_config: Draft::from(IProfiles::new()),
+            runtime_config: Draft::from(IRuntime::new()),
+        })
+    }
+
+    pub fn clash() -> Draft<IClashTemp> {
+        Self::global().clash_config.clone()
+    }
+
+    pub fn verge() -> Draft<IVerge> {
+        Self::global().verge_config.clone()
+    }
+
+    pub fn profiles() -> Draft<IProfiles> {
+        Self::global().profiles_config.clone()
+    }
+
+    pub fn runtime() -> Draft<IRuntime> {
+        Self::global().runtime_config.clone()
+    }
+
+    /// 初始化订阅
+    pub 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);
+
+        // 生成运行时配置文件并验证
+        let config_result = Self::generate_file(ConfigType::Run);
+
+        let validation_result = if let Ok(_) = config_result {
+            // 验证配置文件
+            println!("[首次启动] 开始验证配置");
+            
+            match CoreManager::global().validate_config().await {
+                Ok((is_valid, error_msg)) => {
+                    if !is_valid {
+                        println!("[首次启动] 配置验证失败，使用默认最小配置启动: {}", error_msg);
+                        CoreManager::global()
+                            .use_default_config("config_validate::boot_error", &error_msg)
+                            .await?;
+                        Some(("config_validate::boot_error", error_msg))
+                    } else {
+                        println!("[首次启动] 配置验证成功");
+                        Some(("config_validate::success", String::new()))
+                    }
+                }
+                Err(err) => {
+                    println!("[首次启动] 验证进程执行失败: {}", err);
+                    CoreManager::global()
+                        .use_default_config("config_validate::process_terminated", "")
+                        .await?;
+                    Some(("config_validate::process_terminated", String::new()))
+                }
+            }
+        } else {
+            println!("[首次启动] 生成配置文件失败，使用默认配置");
+            CoreManager::global()
+                .use_default_config(
+                    "config_validate::error",
+                    "",
+                )
+                .await?;
+            Some(("config_validate::error", String::new()))
+        };
+
+        // 在单独的任务中发送通知
+        if let Some((msg_type, msg_content)) = validation_result {
+            tauri::async_runtime::spawn(async move {
+                sleep(Duration::from_secs(2)).await;
+                handle::Handle::notice_message(msg_type, &msg_content);
+            });
+        }
+
+        Ok(())
+    }
+
+    /// 将订阅丢到对应的文件中
+    pub fn generate_file(typ: ConfigType) -> Result<PathBuf> {
+        let path = match typ {
+            ConfigType::Run => dirs::app_home_dir()?.join(RUNTIME_CONFIG),
+            ConfigType::Check => dirs::app_home_dir()?.join(CHECK_CONFIG),
+        };
+
+        let runtime = Config::runtime();
+        let runtime = runtime.latest();
+        let config = runtime
+            .config
+            .as_ref()
+            .ok_or(anyhow!("failed to get runtime config"))?;
+
+        help::save_yaml(&path, &config, Some("# Generated by Clash Verge"))?;
+        Ok(path)
+    }
+
+    /// 生成订阅存好
+    pub async fn generate() -> Result<()> {
+        let (config, exists_keys, logs) = enhance::enhance().await;
+
+        *Config::runtime().draft() = IRuntime {
+            config: Some(config),
+            exists_keys,
+            chain_logs: logs,
+        };
+
+        Ok(())
+    }
+}
+
+#[derive(Debug)]
+pub enum ConfigType {
+    Run,
+    Check,
+}

src-tauri/src/config/draft.rs

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

src-tauri/src/config/encrypt.rs

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

src-tauri/src/config/mod.rs

@@ -1,7 +1,23 @@
 mod clash;
+#[allow(clippy::module_inception)]
+mod config;
+mod draft;
+mod encrypt;
+mod prfitem;
 mod profiles;
+mod runtime;
 mod verge;
 
 pub use self::clash::*;
+pub use self::config::*;
+pub use self::draft::*;
+pub use self::encrypt::*;
+pub use self::prfitem::*;
 pub use self::profiles::*;
+pub use self::runtime::*;
 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

@@ -0,0 +1,564 @@
+use crate::utils::{dirs, help, resolve::VERSION, tmpl};
+use anyhow::{bail, Context, Result};
+use reqwest::StatusCode;
+use serde::{Deserialize, Serialize};
+use serde_yaml::Mapping;
+use std::fs;
+use sysproxy::Sysproxy;
+
+use super::Config;
+
+#[derive(Debug, Clone, Deserialize, Serialize, Default)]
+pub struct PrfItem {
+    pub uid: Option<String>,
+
+    /// profile item type
+    /// enum value: remote | local | script | merge
+    #[serde(rename = "type")]
+    pub itype: Option<String>,
+
+    /// profile name
+    pub name: Option<String>,
+
+    /// profile file
+    pub file: Option<String>,
+
+    /// profile description
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub desc: Option<String>,
+
+    /// source url
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub url: Option<String>,
+
+    /// selected information
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub selected: Option<Vec<PrfSelected>>,
+
+    /// subscription user info
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub extra: Option<PrfExtra>,
+
+    /// updated time
+    pub updated: Option<usize>,
+
+    /// some options of the item
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub option: Option<PrfOption>,
+
+    /// 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>,
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct PrfSelected {
+    pub name: Option<String>,
+    pub now: Option<String>,
+}
+
+#[derive(Default, Debug, Clone, Copy, Deserialize, Serialize)]
+pub struct PrfExtra {
+    pub upload: u64,
+    pub download: u64,
+    pub total: u64,
+    pub expire: u64,
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
+pub struct PrfOption {
+    /// for `remote` profile's http request
+    /// see issue #13
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub user_agent: Option<String>,
+
+    /// for `remote` profile
+    /// use system proxy
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub with_proxy: Option<bool>,
+
+    /// for `remote` profile
+    /// use self proxy
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub self_proxy: Option<bool>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub update_interval: Option<u64>,
+
+    /// 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 {
+    pub fn merge(one: Option<Self>, other: Option<Self>) -> Option<Self> {
+        match (one, other) {
+            (Some(mut a), Some(b)) => {
+                a.user_agent = b.user_agent.or(a.user_agent);
+                a.with_proxy = b.with_proxy.or(a.with_proxy);
+                a.self_proxy = b.self_proxy.or(a.self_proxy);
+                a.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 PrfItem {
+    /// From partial item
+    /// must contain `itype`
+    pub async fn from(item: PrfItem, file_data: Option<String>) -> Result<PrfItem> {
+        if item.itype.is_none() {
+            bail!("type should not be null");
+        }
+
+        match item.itype.unwrap().as_str() {
+            "remote" => {
+                if item.url.is_none() {
+                    bail!("url should not be null");
+                }
+                let url = item.url.as_ref().unwrap().as_str();
+                let name = item.name;
+                let desc = item.desc;
+                PrfItem::from_url(url, name, desc, item.option).await
+            }
+            "local" => {
+                let name = item.name.unwrap_or("Local File".into());
+                let desc = item.desc.unwrap_or("".into());
+                PrfItem::from_local(name, desc, file_data, item.option)
+            }
+            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>,
+        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()),
+            name: Some(name),
+            desc: Some(desc),
+            file: Some(file),
+            url: None,
+            selected: None,
+            extra: 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())),
+        })
+    }
+
+    /// ## Remote type
+    /// create a new item from url
+    pub async fn from_url(
+        url: &str,
+        name: Option<String>,
+        desc: Option<String>,
+        option: Option<PrfOption>,
+    ) -> Result<PrfItem> {
+        let opt_ref = option.as_ref();
+        let with_proxy = opt_ref.map_or(false, |o| o.with_proxy.unwrap_or(false));
+        let self_proxy = opt_ref.map_or(false, |o| o.self_proxy.unwrap_or(false));
+        let 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::verge()
+                .latest()
+                .verge_mixed_port
+                .unwrap_or(Config::clash().data().get_mixed_port());
+
+            let proxy_scheme = format!("http://127.0.0.1:{port}");
+
+            if let Ok(proxy) = reqwest::Proxy::http(&proxy_scheme) {
+                builder = builder.proxy(proxy);
+            }
+            if let Ok(proxy) = reqwest::Proxy::https(&proxy_scheme) {
+                builder = builder.proxy(proxy);
+            }
+            if let Ok(proxy) = reqwest::Proxy::all(&proxy_scheme) {
+                builder = builder.proxy(proxy);
+            }
+        }
+        // 使用系统代理
+        else if with_proxy {
+            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);
+                }
+            }
+        }
+
+        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?;
+
+        let status_code = resp.status();
+        if !StatusCode::is_success(&status_code) {
+            bail!("failed to fetch remote profile with status {status_code}")
+        }
+
+        let header = resp.headers();
+
+        // parse the Subscription UserInfo
+        let extra = match header.get("Subscription-Userinfo") {
+            Some(value) => {
+                let sub_info = value.to_str().unwrap_or("");
+                Some(PrfExtra {
+                    upload: help::parse_str(sub_info, "upload").unwrap_or(0),
+                    download: help::parse_str(sub_info, "download").unwrap_or(0),
+                    total: help::parse_str(sub_info, "total").unwrap_or(0),
+                    expire: help::parse_str(sub_info, "expire").unwrap_or(0),
+                })
+            }
+            None => None,
+        };
+
+        // parse the Content-Disposition
+        let filename = match header.get("Content-Disposition") {
+            Some(value) => {
+                let filename = 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,
+        };
+
+        let uid = help::get_uid("R");
+        let file = format!("{uid}.yaml");
+        let name = name.unwrap_or(filename.unwrap_or("Remote File".into()));
+        let data = resp.text_with_charset("utf-8").await?;
+
+        // process the charset "UTF-8 with BOM"
+        let data = data.trim_start_matches('\u{feff}');
+
+        // check the data whether the valid yaml format
+        let yaml = serde_yaml::from_str::<Mapping>(data)
+            .context("the remote profile data is invalid yaml")?;
+
+        if !yaml.contains_key("proxies") && !yaml.contains_key("proxy-providers") {
+            bail!("profile does not contain `proxies` or `proxy-providers`");
+        }
+
+        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()),
+            name: Some(name),
+            desc,
+            file: Some(file),
+            url: Some(url.into()),
+            selected: None,
+            extra,
+            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.into()),
+        })
+    }
+
+    /// ## Merge type (enhance)
+    /// create the enhanced item by using `merge` rule
+    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(id),
+            itype: Some("merge".into()),
+            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(template),
+        })
+    }
+
+    /// ## Script type (enhance)
+    /// create the enhanced item by using javascript quick.js
+    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(id),
+            itype: Some("script".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_SCRIPT.into()),
+        })
+    }
+
+    /// ## 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() {
+            bail!("could not find the file");
+        }
+
+        let file = self.file.clone().unwrap();
+        let path = dirs::app_profiles_dir()?.join(file);
+        fs::read_to_string(path).context("failed to read the file")
+    }
+
+    /// save the file data
+    pub fn save_file(&self, data: String) -> Result<()> {
+        if self.file.is_none() {
+            bail!("could not find the file");
+        }
+
+        let file = self.file.clone().unwrap();
+        let path = dirs::app_profiles_dir()?.join(file);
+        fs::write(path, data.as_bytes()).context("failed to save the file")
+    }
+}

src-tauri/src/config/profiles.rs

@@ -1,52 +1,486 @@
+use super::{prfitem::PrfItem, PrfOption};
+use crate::utils::{dirs, help};
+use anyhow::{bail, Context, Result};
 use serde::{Deserialize, Serialize};
+use serde_yaml::Mapping;
+use std::{fs, io::Write};
 
 /// Define the `profiles.yaml` schema
 #[derive(Default, Debug, Clone, Deserialize, Serialize)]
-pub struct ProfilesConfig {
-  /// current profile's name
-  pub current: Option<usize>,
+pub struct IProfiles {
+    /// same as PrfConfig.current
+    pub current: Option<String>,
 
-  /// profile list
-  pub items: Option<Vec<ProfileItem>>,
+    /// profile list
+    pub items: Option<Vec<PrfItem>>,
 }
 
-#[derive(Default, Debug, Clone, Deserialize, Serialize)]
-pub struct ProfileItem {
-  /// profile name
-  pub name: Option<String>,
-  /// profile file
-  pub file: Option<String>,
-  /// current mode
-  pub mode: Option<String>,
-  /// source url
-  pub url: Option<String>,
-  /// selected infomation
-  pub selected: Option<Vec<ProfileSelected>>,
-  /// user info
-  pub extra: Option<ProfileExtra>,
-  /// updated time
-  pub updated: Option<usize>,
+macro_rules! patch {
+    ($lv: expr, $rv: expr, $key: tt) => {
+        if ($rv.$key).is_some() {
+            $lv.$key = $rv.$key;
+        }
+    };
 }
 
-#[derive(Default, Debug, Clone, Deserialize, Serialize)]
-pub struct ProfileSelected {
-  pub name: Option<String>,
-  pub now: Option<String>,
-}
+impl IProfiles {
+    pub fn new() -> Self {
+        match dirs::profiles_path().and_then(|path| help::read_yaml::<Self>(&path)) {
+            Ok(mut profiles) => {
+                if profiles.items.is_none() {
+                    profiles.items = Some(vec![]);
+                }
+                // compatible with the old old old version
+                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) => {
+                log::error!(target: "app", "{err}");
+                Self::template()
+            }
+        }
+    }
 
-#[derive(Default, Debug, Clone, Copy, Deserialize, Serialize)]
-pub struct ProfileExtra {
-  pub upload: usize,
-  pub download: usize,
-  pub total: usize,
-  pub expire: usize,
-}
+    pub fn template() -> Self {
+        Self {
+            items: Some(vec![]),
+            ..Self::default()
+        }
+    }
 
-#[derive(Default, Debug, Clone, Deserialize, Serialize)]
-/// the result from url
-pub struct ProfileResponse {
-  pub name: String,
-  pub file: String,
-  pub data: String,
-  pub extra: ProfileExtra,
+    pub fn save_file(&self) -> Result<()> {
+        help::save_yaml(
+            &dirs::profiles_path()?,
+            self,
+            Some("# Profiles Config for Clash Verge"),
+        )
+    }
+
+    /// 只修改current，valid和chain
+    pub fn patch_config(&mut self, patch: IProfiles) -> Result<()> {
+        if self.items.is_none() {
+            self.items = Some(vec![]);
+        }
+
+        if let Some(current) = patch.current {
+            let items = self.items.as_ref().unwrap();
+            let some_uid = Some(current);
+            if items.iter().any(|e| e.uid == some_uid) {
+                self.current = some_uid;
+            }
+        }
+
+        Ok(())
+    }
+
+    pub fn get_current(&self) -> Option<String> {
+        self.current.clone()
+    }
+
+    /// get items ref
+    pub fn get_items(&self) -> Option<&Vec<PrfItem>> {
+        self.items.as_ref()
+    }
+
+    /// find the item by the uid
+    pub fn get_item(&self, uid: &String) -> Result<&PrfItem> {
+        if let Some(items) = self.items.as_ref() {
+            let some_uid = Some(uid.clone());
+
+            for each in items.iter() {
+                if each.uid == some_uid {
+                    return Ok(each);
+                }
+            }
+        }
+
+        bail!("failed to get the profile item \"uid:{uid}\"");
+    }
+
+    /// append new item
+    /// if the file_data is some
+    /// then should save the data to file
+    pub fn append_item(&mut self, mut item: PrfItem) -> Result<()> {
+        if item.uid.is_none() {
+            bail!("the uid should not be null");
+        }
+        let uid = item.uid.clone();
+
+        // save the file data
+        // move the field value after save
+        if let Some(file_data) = item.file_data.take() {
+            if item.file.is_none() {
+                bail!("the file should not be null");
+            }
+
+            let file = item.file.clone().unwrap();
+            let path = dirs::app_profiles_dir()?.join(&file);
+
+            fs::File::create(path)
+                .with_context(|| format!("failed to create file \"{}\"", file))?
+                .write(file_data.as_bytes())
+                .with_context(|| format!("failed to write to file \"{}\"", file))?;
+        }
+
+        if self.current.is_none()
+            && (item.itype == Some("remote".to_string()) || item.itype == Some("local".to_string()))
+        {
+            self.current = uid;
+        }
+
+        if self.items.is_none() {
+            self.items = Some(vec![]);
+        }
+
+        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_default();
+
+        for each in items.iter_mut() {
+            if each.uid == Some(uid.clone()) {
+                patch!(each, item, itype);
+                patch!(each, item, name);
+                patch!(each, item, desc);
+                patch!(each, item, file);
+                patch!(each, item, url);
+                patch!(each, item, selected);
+                patch!(each, item, extra);
+                patch!(each, item, updated);
+                patch!(each, item, option);
+
+                self.items = Some(items);
+                return self.save_file();
+            }
+        }
+
+        self.items = Some(items);
+        bail!("failed to find the profile item \"uid:{uid}\"")
+    }
+
+    /// be used to update the remote item
+    /// only patch `updated` `extra` `file_data`
+    pub fn update_item(&mut self, uid: String, mut item: PrfItem) -> Result<()> {
+        if self.items.is_none() {
+            self.items = Some(vec![]);
+        }
+
+        // find the item
+        let _ = self.get_item(&uid)?;
+
+        if let Some(items) = self.items.as_mut() {
+            let some_uid = Some(uid.clone());
+
+            for each in items.iter_mut() {
+                if each.uid == some_uid {
+                    each.extra = item.extra;
+                    each.updated = item.updated;
+                    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() {
+                        let file = each.file.take();
+                        let file =
+                            file.unwrap_or(item.file.take().unwrap_or(format!("{}.yaml", &uid)));
+
+                        // the file must exists
+                        each.file = Some(file.clone());
+
+                        let path = dirs::app_profiles_dir()?.join(&file);
+
+                        fs::File::create(path)
+                            .with_context(|| format!("failed to create file \"{}\"", file))?
+                            .write(file_data.as_bytes())
+                            .with_context(|| format!("failed to write to file \"{}\"", file))?;
+                    }
+
+                    break;
+                }
+            }
+        }
+
+        self.save_file()
+    }
+
+    /// delete item
+    /// if delete the current then return true
+    pub fn delete_item(&mut self, uid: String) -> Result<bool> {
+        let current = self.current.as_ref().unwrap_or(&uid);
+        let current = current.clone();
+        let 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 items.iter().enumerate() {
+            if items[i].uid == Some(uid.clone()) {
+                index = Some(i);
+                break;
+            }
+        }
+        if let Some(index) = 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 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 = None;
+            for item in items.iter() {
+                if item.itype == Some("remote".to_string())
+                    || item.itype == Some("local".to_string())
+                {
+                    self.current = item.uid.clone();
+                    break;
+                }
+            }
+        }
+
+        self.items = Some(items);
+        self.save_file()?;
+        Ok(current == uid)
+    }
+
+    /// 获取current指向的订阅内容
+    pub fn current_mapping(&self) -> Result<Mapping> {
+        match (self.current.as_ref(), self.items.as_ref()) {
+            (Some(current), Some(items)) => {
+                if let Some(item) = items.iter().find(|e| e.uid.as_ref() == Some(current)) {
+                    let file_path = match item.file.as_ref() {
+                        Some(file) => dirs::app_profiles_dir()?.join(file),
+                        None => bail!("failed to get the file field"),
+                    };
+                    return 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,
+        }
+    }
+
+    /// 判断profile是否是current指向的
+    pub fn is_current_profile_index(&self, index: String) -> bool {
+        self.current == Some(index)
+    }
+
+    /// 获取所有的profiles(uid，名称)
+    pub fn all_profile_uid_and_name(&self) -> Option<Vec<(String, String)>> {
+        match self.items.as_ref() {
+            Some(items) => Some(items.iter().filter_map(|e| {
+                if let (Some(uid), Some(name)) = (e.uid.clone(), e.name.clone()) {
+                    Some((uid, name))
+                } else {
+                    None
+                }
+            }).collect()),
+            None => None,
+        }
+    }
 }

src-tauri/src/config/runtime.rs

@@ -0,0 +1,49 @@
+use crate::enhance::field::use_keys;
+use serde::{Deserialize, Serialize};
+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
+    // 这些keys不一定都生效
+    pub exists_keys: Vec<String>,
+    pub chain_logs: HashMap<String, Vec<(String, String)>>,
+}
+
+impl IRuntime {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    // 这里只更改 allow-lan | ipv6 | log-level | tun
+    pub fn patch_config(&mut self, patch: Mapping) {
+        if let Some(config) = self.config.as_mut() {
+            ["allow-lan", "ipv6", "log-level", "unified-delay"]
+                .into_iter()
+                .for_each(|key| {
+                    if let Some(value) = patch.get(key).to_owned() {
+                        config.insert(key.into(), value.clone());
+                    }
+                });
+
+            let patch_tun = patch.get("tun");
+            if patch_tun.is_some() {
+                let tun = config.get("tun");
+                let mut tun = tun.map_or(Mapping::new(), |val| {
+                    val.as_mapping().cloned().unwrap_or(Mapping::new())
+                });
+                let patch_tun = patch_tun.map_or(Mapping::new(), |val| {
+                    val.as_mapping().cloned().unwrap_or(Mapping::new())
+                });
+                use_keys(&patch_tun).into_iter().for_each(|key| {
+                    if let Some(value) = patch_tun.get(&key).to_owned() {
+                        tun.insert(key.into(), value.clone());
+                    }
+                });
+
+                config.insert("tun".into(), Value::from(tun));
+            }
+        }
+    }
+}

src-tauri/src/config/verge.rs

@@ -1,17 +1,533 @@
+use crate::config::DEFAULT_PAC;
+use crate::config::{deserialize_encrypted, serialize_encrypted};
+use crate::utils::i18n;
+use crate::utils::{dirs, help};
+use anyhow::Result;
+use log::LevelFilter;
 use serde::{Deserialize, Serialize};
 
 /// ### `verge.yaml` schema
 #[derive(Default, Debug, Clone, Deserialize, Serialize)]
-pub struct VergeConfig {
-  /// `light` or `dark`
-  pub theme_mode: Option<String>,
+pub struct IVerge {
+    /// app log level
+    /// silent | error | warn | info | debug | trace
+    pub app_log_level: Option<String>,
 
-  /// can the app auto startup
-  pub enable_self_startup: Option<bool>,
+    // i18n
+    pub language: Option<String>,
 
-  /// set system proxy
-  pub enable_system_proxy: Option<bool>,
+    /// `light` or `dark` or `system`
+    pub theme_mode: Option<String>,
 
-  /// set system proxy bypass
-  pub system_proxy_bypass: Option<String>,
+    /// 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>,
+
+    /// can the app auto startup
+    pub enable_auto_launch: Option<bool>,
+
+    /// not show the window on launch
+    pub enable_silent_start: Option<bool>,
+
+    /// set system proxy
+    pub enable_system_proxy: Option<bool>,
+
+    /// enable proxy guard
+    pub enable_proxy_guard: Option<bool>,
+
+    /// enable dns settings - this controls whether dns_config.yaml is applied
+    pub enable_dns_settings: 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>,
+
+    /// web ui list
+    pub web_ui_list: Option<Vec<String>>,
+
+    /// clash core path
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub clash_core: Option<String>,
+
+    /// hotkey map
+    /// format: {func},{key}
+    pub hotkeys: Option<Vec<String>>,
+    
+    /// enable global hotkey
+    pub enable_global_hotkey: Option<bool>,
+
+    /// 切换代理时自动关闭连接
+    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>,
+
+    /// 是否启用随机端口
+    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>,
+
+    /// WebDAV 配置 (加密存储)
+    #[serde(
+        serialize_with = "serialize_encrypted",
+        deserialize_with = "deserialize_encrypted",
+        skip_serializing_if = "Option::is_none",
+        default
+    )]
+    pub webdav_url: Option<String>,
+
+    /// WebDAV 用户名 (加密存储)
+    #[serde(
+        serialize_with = "serialize_encrypted",
+        deserialize_with = "deserialize_encrypted",
+        skip_serializing_if = "Option::is_none",
+        default
+    )]
+    pub webdav_username: Option<String>,
+
+    /// WebDAV 密码 (加密存储)
+    #[serde(
+        serialize_with = "serialize_encrypted",
+        deserialize_with = "deserialize_encrypted",
+        skip_serializing_if = "Option::is_none",
+        default
+    )]
+    pub webdav_password: Option<String>,
+
+    pub enable_tray_speed: Option<bool>,
+
+    /// 轻量模式 - 只保留内核运行
+    pub enable_lite_mode: Option<bool>,
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+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)]
+pub struct IVergeTheme {
+    pub primary_color: Option<String>,
+    pub secondary_color: Option<String>,
+    pub primary_text: Option<String>,
+    pub secondary_text: Option<String>,
+
+    pub info_color: Option<String>,
+    pub error_color: Option<String>,
+    pub warning_color: Option<String>,
+    pub success_color: Option<String>,
+
+    pub font_family: Option<String>,
+    pub css_injection: Option<String>,
+}
+
+impl IVerge {
+    fn get_system_language() -> String {
+        let sys_lang = sys_locale::get_locale()
+            .unwrap_or_else(|| String::from("en"))
+            .to_lowercase();
+
+        let lang_code = sys_lang.split(['_', '-']).next().unwrap_or("en");
+        let supported_languages = i18n::get_supported_languages();
+
+        if supported_languages.contains(&lang_code.to_string()) {
+            lang_code.to_string()
+        } else {
+            String::from("en")
+        }
+    }
+
+    pub fn new() -> Self {
+        match dirs::verge_path().and_then(|path| help::read_yaml::<IVerge>(&path)) {
+            Ok(config) => config,
+            Err(err) => {
+                log::error!(target: "app", "{err}");
+                Self::template()
+            }
+        }
+    }
+
+    pub fn template() -> Self {
+        Self {
+            clash_core: Some("verge-mihomo".into()),
+            language: Some(Self::get_system_language()),
+            theme_mode: Some("system".into()),
+            #[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(false),
+            #[cfg(target_os = "linux")]
+            verge_tproxy_port: Some(7896),
+            #[cfg(target_os = "linux")]
+            verge_tproxy_enabled: Some(false),
+            verge_mixed_port: Some(7897),
+            verge_socks_port: Some(7898),
+            verge_socks_enabled: Some(false),
+            verge_port: Some(7899),
+            verge_http_enabled: Some(false),
+            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),
+            webdav_url: None,
+            webdav_username: None,
+            webdav_password: None,
+            enable_tray_speed: Some(true),
+            enable_global_hotkey: Some(true),
+            enable_lite_mode: Some(false),
+            enable_dns_settings: Some(true),
+            ..Self::default()
+        }
+    }
+
+    /// Save IVerge App Config
+    pub fn save_file(&self) -> Result<()> {
+        help::save_yaml(&dirs::verge_path()?, &self, Some("# Clash Verge Config"))
+    }
+
+    /// patch verge config
+    /// only save to file
+    pub fn patch_config(&mut self, patch: IVerge) {
+        macro_rules! patch {
+            ($key: tt) => {
+                if patch.$key.is_some() {
+                    self.$key = patch.$key;
+                }
+            };
+        }
+
+        patch!(app_log_level);
+        patch!(language);
+        patch!(theme_mode);
+        patch!(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_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);
+        patch!(clash_core);
+        patch!(hotkeys);
+        patch!(enable_global_hotkey);
+
+        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!(webdav_url);
+        patch!(webdav_username);
+        patch!(webdav_password);
+        patch!(enable_tray_speed);
+        patch!(enable_lite_mode);
+        patch!(enable_dns_settings);
+    }
+
+    /// 在初始化前尝试拿到单例端口的值
+    pub fn get_singleton_port() -> u16 {
+        #[cfg(not(feature = "verge-dev"))]
+        const SERVER_PORT: u16 = 33331;
+        #[cfg(feature = "verge-dev")]
+        const SERVER_PORT: u16 = 11233;
+        SERVER_PORT
+    }
+
+    /// 获取日志等级
+    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
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct IVergeResponse {
+    pub app_log_level: Option<String>,
+    pub language: Option<String>,
+    pub theme_mode: Option<String>,
+    pub tray_event: Option<String>,
+    pub env_type: Option<String>,
+    pub start_page: Option<String>,
+    pub startup_script: Option<String>,
+    pub traffic_graph: Option<bool>,
+    pub enable_memory_usage: Option<bool>,
+    pub enable_group_icon: Option<bool>,
+    pub common_tray_icon: Option<bool>,
+    #[cfg(target_os = "macos")]
+    pub tray_icon: Option<String>,
+    pub menu_icon: Option<String>,
+    pub sysproxy_tray_icon: Option<bool>,
+    pub tun_tray_icon: Option<bool>,
+    pub enable_tun_mode: Option<bool>,
+    pub enable_auto_launch: Option<bool>,
+    pub enable_silent_start: Option<bool>,
+    pub enable_system_proxy: Option<bool>,
+    pub enable_proxy_guard: Option<bool>,
+    pub enable_global_hotkey: Option<bool>,
+    pub use_default_bypass: Option<bool>,
+    pub system_proxy_bypass: Option<String>,
+    pub proxy_guard_duration: Option<u64>,
+    pub proxy_auto_config: Option<bool>,
+    pub pac_file_content: Option<String>,
+    pub theme_setting: Option<IVergeTheme>,
+    pub web_ui_list: Option<Vec<String>>,
+    pub clash_core: Option<String>,
+    pub hotkeys: Option<Vec<String>>,
+    pub auto_close_connection: Option<bool>,
+    pub auto_check_update: Option<bool>,
+    pub default_latency_test: Option<String>,
+    pub default_latency_timeout: Option<i32>,
+    pub enable_builtin_enhanced: Option<bool>,
+    pub proxy_layout_column: Option<i32>,
+    pub test_list: Option<Vec<IVergeTestItem>>,
+    pub auto_log_clean: Option<i32>,
+    pub enable_random_port: Option<bool>,
+    #[cfg(not(target_os = "windows"))]
+    pub verge_redir_port: Option<u16>,
+    #[cfg(not(target_os = "windows"))]
+    pub verge_redir_enabled: Option<bool>,
+    #[cfg(target_os = "linux")]
+    pub verge_tproxy_port: Option<u16>,
+    #[cfg(target_os = "linux")]
+    pub verge_tproxy_enabled: Option<bool>,
+    pub verge_mixed_port: Option<u16>,
+    pub verge_socks_port: Option<u16>,
+    pub verge_socks_enabled: Option<bool>,
+    pub verge_port: Option<u16>,
+    pub verge_http_enabled: Option<bool>,
+    pub webdav_url: Option<String>,
+    pub webdav_username: Option<String>,
+    pub webdav_password: Option<String>,
+    pub enable_tray_speed: Option<bool>,
+    pub enable_lite_mode: Option<bool>,
+    pub enable_dns_settings: Option<bool>,
+}
+
+impl From<IVerge> for IVergeResponse {
+    fn from(verge: IVerge) -> Self {
+        Self {
+            app_log_level: verge.app_log_level,
+            language: verge.language,
+            theme_mode: verge.theme_mode,
+            tray_event: verge.tray_event,
+            env_type: verge.env_type,
+            start_page: verge.start_page,
+            startup_script: verge.startup_script,
+            traffic_graph: verge.traffic_graph,
+            enable_memory_usage: verge.enable_memory_usage,
+            enable_group_icon: verge.enable_group_icon,
+            common_tray_icon: verge.common_tray_icon,
+            #[cfg(target_os = "macos")]
+            tray_icon: verge.tray_icon,
+            menu_icon: verge.menu_icon,
+            sysproxy_tray_icon: verge.sysproxy_tray_icon,
+            tun_tray_icon: verge.tun_tray_icon,
+            enable_tun_mode: verge.enable_tun_mode,
+            enable_auto_launch: verge.enable_auto_launch,
+            enable_silent_start: verge.enable_silent_start,
+            enable_system_proxy: verge.enable_system_proxy,
+            enable_proxy_guard: verge.enable_proxy_guard,
+            enable_global_hotkey: verge.enable_global_hotkey,
+            use_default_bypass: verge.use_default_bypass,
+            system_proxy_bypass: verge.system_proxy_bypass,
+            proxy_guard_duration: verge.proxy_guard_duration,
+            proxy_auto_config: verge.proxy_auto_config,
+            pac_file_content: verge.pac_file_content,
+            theme_setting: verge.theme_setting,
+            web_ui_list: verge.web_ui_list,
+            clash_core: verge.clash_core,
+            hotkeys: verge.hotkeys,
+            auto_close_connection: verge.auto_close_connection,
+            auto_check_update: verge.auto_check_update,
+            default_latency_test: verge.default_latency_test,
+            default_latency_timeout: verge.default_latency_timeout,
+            enable_builtin_enhanced: verge.enable_builtin_enhanced,
+            proxy_layout_column: verge.proxy_layout_column,
+            test_list: verge.test_list,
+            auto_log_clean: verge.auto_log_clean,
+            enable_random_port: verge.enable_random_port,
+            #[cfg(not(target_os = "windows"))]
+            verge_redir_port: verge.verge_redir_port,
+            #[cfg(not(target_os = "windows"))]
+            verge_redir_enabled: verge.verge_redir_enabled,
+            #[cfg(target_os = "linux")]
+            verge_tproxy_port: verge.verge_tproxy_port,
+            #[cfg(target_os = "linux")]
+            verge_tproxy_enabled: verge.verge_tproxy_enabled,
+            verge_mixed_port: verge.verge_mixed_port,
+            verge_socks_port: verge.verge_socks_port,
+            verge_socks_enabled: verge.verge_socks_enabled,
+            verge_port: verge.verge_port,
+            verge_http_enabled: verge.verge_http_enabled,
+            webdav_url: verge.webdav_url,
+            webdav_username: verge.webdav_username,
+            webdav_password: verge.webdav_password,
+            enable_tray_speed: verge.enable_tray_speed,
+            enable_lite_mode: verge.enable_lite_mode,
+            enable_dns_settings: verge.enable_dns_settings,
+        }
+    }
 }

src-tauri/src/core/backup.rs

@@ -0,0 +1,226 @@
+use crate::config::Config;
+use crate::utils::dirs;
+use anyhow::Error;
+use once_cell::sync::OnceCell;
+use parking_lot::Mutex;
+use reqwest_dav::list_cmd::{ListEntity, ListFile};
+use std::collections::HashMap;
+use std::env::{consts::OS, temp_dir};
+use std::fs;
+use std::io::Write;
+use std::path::PathBuf;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::time::timeout;
+use zip::write::SimpleFileOptions;
+
+const TIMEOUT_UPLOAD: u64 = 300; // 上传超时 5 分钟
+const TIMEOUT_DOWNLOAD: u64 = 300; // 下载超时 5 分钟
+const TIMEOUT_LIST: u64 = 3; // 列表超时 30 秒
+const TIMEOUT_DELETE: u64 = 3; // 删除超时 30 秒
+
+#[derive(Clone)]
+struct WebDavConfig {
+    url: String,
+    username: String,
+    password: String,
+}
+
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
+enum Operation {
+    Upload,
+    Download,
+    List,
+    Delete,
+}
+
+impl Operation {
+    fn timeout(&self) -> u64 {
+        match self {
+            Operation::Upload => TIMEOUT_UPLOAD,
+            Operation::Download => TIMEOUT_DOWNLOAD,
+            Operation::List => TIMEOUT_LIST,
+            Operation::Delete => TIMEOUT_DELETE,
+        }
+    }
+}
+
+pub struct WebDavClient {
+    config: Arc<Mutex<Option<WebDavConfig>>>,
+    clients: Arc<Mutex<HashMap<Operation, reqwest_dav::Client>>>,
+}
+
+impl WebDavClient {
+    pub fn global() -> &'static WebDavClient {
+        static WEBDAV_CLIENT: OnceCell<WebDavClient> = OnceCell::new();
+        WEBDAV_CLIENT.get_or_init(|| WebDavClient {
+            config: Arc::new(Mutex::new(None)),
+            clients: Arc::new(Mutex::new(HashMap::new())),
+        })
+    }
+
+    async fn get_client(&self, op: Operation) -> Result<reqwest_dav::Client, Error> {
+        // 先尝试从缓存获取
+        {
+            let clients = self.clients.lock();
+            if let Some(client) = clients.get(&op) {
+                return Ok(client.clone());
+            }
+        }
+
+        // 获取或创建配置
+        let config = {
+            let mut lock = self.config.lock();
+            if let Some(cfg) = lock.as_ref() {
+                cfg.clone()
+            } else {
+                let verge = Config::verge().latest().clone();
+                if verge.webdav_url.is_none()
+                    || verge.webdav_username.is_none()
+                    || verge.webdav_password.is_none()
+                {
+                    let msg = "Unable to create web dav client, please make sure the webdav config is correct".to_string();
+                    return Err(anyhow::Error::msg(msg));
+                }
+
+                let config = WebDavConfig {
+                    url: verge
+                        .webdav_url
+                        .unwrap_or_default()
+                        .trim_end_matches('/')
+                        .to_string(),
+                    username: verge.webdav_username.unwrap_or_default(),
+                    password: verge.webdav_password.unwrap_or_default(),
+                };
+
+                *lock = Some(config.clone());
+                config
+            }
+        };
+
+        // 创建新的客户端
+        let client = reqwest_dav::ClientBuilder::new()
+            .set_agent(
+                reqwest::Client::builder()
+                    .danger_accept_invalid_certs(true)
+                    .timeout(Duration::from_secs(op.timeout()))
+                    .build()
+                    .unwrap(),
+            )
+            .set_host(config.url)
+            .set_auth(reqwest_dav::Auth::Basic(config.username, config.password))
+            .build()?;
+
+        // 确保备份目录存在
+        let list_result = client
+            .list(dirs::BACKUP_DIR, reqwest_dav::Depth::Number(0))
+            .await;
+        if list_result.is_err() {
+            client.mkcol(dirs::BACKUP_DIR).await?;
+        }
+
+        // 缓存客户端
+        {
+            let mut clients = self.clients.lock();
+            clients.insert(op, client.clone());
+        }
+
+        Ok(client)
+    }
+
+    pub fn reset(&self) {
+        *self.config.lock() = None;
+        self.clients.lock().clear();
+    }
+
+    pub async fn upload(&self, file_path: PathBuf, file_name: String) -> Result<(), Error> {
+        let client = self.get_client(Operation::Upload).await?;
+        let webdav_path: String = format!("{}/{}", dirs::BACKUP_DIR, file_name);
+        let fut = client.put(webdav_path.as_ref(), fs::read(file_path)?);
+        timeout(Duration::from_secs(TIMEOUT_UPLOAD), fut).await??;
+        Ok(())
+    }
+
+    pub async fn download(&self, filename: String, storage_path: PathBuf) -> Result<(), Error> {
+        let client = self.get_client(Operation::Download).await?;
+        let path = format!("{}/{}", dirs::BACKUP_DIR, filename);
+
+        let fut = async {
+            let response = client.get(path.as_str()).await?;
+            let content = response.bytes().await?;
+            fs::write(&storage_path, &content)?;
+            Ok::<(), Error>(())
+        };
+
+        timeout(Duration::from_secs(TIMEOUT_DOWNLOAD), fut).await??;
+        Ok(())
+    }
+
+    pub async fn list(&self) -> Result<Vec<ListFile>, Error> {
+        let client = self.get_client(Operation::List).await?;
+        let path = format!("{}/", dirs::BACKUP_DIR);
+
+        let fut = async {
+            let files = client
+                .list(path.as_str(), reqwest_dav::Depth::Number(1))
+                .await?;
+            let mut final_files = Vec::new();
+            for file in files {
+                if let ListEntity::File(file) = file {
+                    final_files.push(file);
+                }
+            }
+            Ok::<Vec<ListFile>, Error>(final_files)
+        };
+
+        timeout(Duration::from_secs(TIMEOUT_LIST), fut).await?
+    }
+
+    pub async fn delete(&self, file_name: String) -> Result<(), Error> {
+        let client = self.get_client(Operation::Delete).await?;
+        let path = format!("{}/{}", dirs::BACKUP_DIR, file_name);
+
+        let fut = client.delete(&path);
+        timeout(Duration::from_secs(TIMEOUT_DELETE), fut).await??;
+        Ok(())
+    }
+}
+
+pub fn create_backup() -> Result<(String, PathBuf), Error> {
+    let now = chrono::Local::now().format("%Y-%m-%d_%H-%M-%S").to_string();
+    let zip_file_name = format!("{}-backup-{}.zip", OS, now);
+    let zip_path = temp_dir().join(&zip_file_name);
+
+    let file = fs::File::create(&zip_path)?;
+    let mut zip = zip::ZipWriter::new(file);
+    zip.add_directory("profiles/", SimpleFileOptions::default())?;
+    let options = SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored);
+    if let Ok(entries) = fs::read_dir(dirs::app_profiles_dir()?) {
+        for entry in entries {
+            let entry = entry.unwrap();
+            let path = entry.path();
+            if path.is_file() {
+                let backup_path = format!("profiles/{}", entry.file_name().to_str().unwrap());
+                zip.start_file(backup_path, options)?;
+                zip.write_all(fs::read(path).unwrap().as_slice())?;
+            }
+        }
+    }
+    zip.start_file(dirs::CLASH_CONFIG, options)?;
+    zip.write_all(fs::read(dirs::clash_path()?)?.as_slice())?;
+
+    let mut verge_config: serde_json::Value =
+        serde_yaml::from_str(&fs::read_to_string(dirs::verge_path()?)?)?;
+    if let Some(obj) = verge_config.as_object_mut() {
+        obj.remove("webdav_username");
+        obj.remove("webdav_password");
+        obj.remove("webdav_url");
+    }
+    zip.start_file(dirs::VERGE_CONFIG, options)?;
+    zip.write_all(serde_yaml::to_string(&verge_config)?.as_bytes())?;
+
+    zip.start_file(dirs::PROFILE_YAML, options)?;
+    zip.write_all(fs::read(dirs::profiles_path()?)?.as_slice())?;
+    zip.finish()?;
+    Ok((zip_file_name, zip_path))
+}

src-tauri/src/core/core.rs

@@ -0,0 +1,637 @@
+use crate::config::*;
+#[cfg(target_os = "macos")]
+use crate::core::tray::Tray;
+use crate::core::{handle, service};
+use crate::log_err;
+use crate::module::mihomo::MihomoManager;
+use crate::utils::{dirs, help};
+use anyhow::{bail, Result};
+use once_cell::sync::OnceCell;
+use std::{path::PathBuf, sync::Arc, time::Duration};
+use tauri_plugin_shell::ShellExt;
+use tokio::sync::Mutex;
+use tokio::time::sleep;
+
+#[derive(Debug)]
+pub struct CoreManager {
+    running: Arc<Mutex<bool>>,
+}
+
+/// 内核运行模式
+#[derive(Debug, Clone, serde::Serialize)]
+pub enum RunningMode {
+    /// 服务模式运行
+    Service,
+    /// Sidecar模式运行
+    Sidecar,
+    /// 未运行
+    NotRunning,
+}
+
+impl CoreManager {
+    pub fn global() -> &'static CoreManager {
+        static CORE_MANAGER: OnceCell<CoreManager> = OnceCell::new();
+        CORE_MANAGER.get_or_init(|| CoreManager {
+            running: Arc::new(Mutex::new(false)),
+        })
+    }
+
+    pub async fn init(&self) -> Result<()> {
+        log::trace!("run core start");
+        // 启动clash
+        log_err!(Self::global().start_core().await);
+        log::trace!("run core end");
+        Ok(())
+    }
+
+    /// 停止核心运行
+    pub async fn stop_core(&self) -> Result<()> {
+        let mut running = self.running.lock().await;
+
+        if !*running {
+            log::debug!("core is not running");
+            return Ok(());
+        }
+
+        // 关闭tun模式
+        // Create a JSON object to disable TUN mode
+        let disable = serde_json::json!({
+            "tun": {
+            "enable": false
+            }
+        });
+        log::debug!(target: "app", "disable tun mode");
+        log_err!(MihomoManager::global().patch_configs(disable).await);
+
+        // 服务模式
+        if service::check_service().await.is_ok() {
+            log::info!(target: "app", "stop the core by service");
+            match service::stop_core_by_service().await {
+                Ok(_) => {
+                    log::info!(target: "app", "core stopped successfully by service");
+                }
+                Err(err) => {
+                    log::warn!(target: "app", "failed to stop core by service: {}", err);
+                    // 服务停止失败，尝试停止可能的sidecar进程
+                    self.stop_sidecar_process();
+                }
+            }
+        } else {
+            // 如果没有使用服务，尝试停止sidecar进程
+            self.stop_sidecar_process();
+        }
+
+        *running = false;
+        Ok(())
+    }
+
+    /// 停止通过sidecar启动的进程
+    fn stop_sidecar_process(&self) {
+        if let Some(process) = handle::Handle::global().take_core_process() {
+            log::info!(target: "app", "stopping core process in sidecar mode");
+            if let Err(e) = process.kill() {
+                log::warn!(target: "app", "failed to kill core process: {}", e);
+            } else {
+                log::info!(target: "app", "core process stopped successfully");
+            }
+        }
+    }
+
+    /// 启动核心
+    pub async fn start_core(&self) -> Result<()> {
+        let mut running = self.running.lock().await;
+        if *running {
+            log::info!("core is running");
+            return Ok(());
+        }
+
+        let config_path = Config::generate_file(ConfigType::Run)?;
+
+        // 先尝试服务模式
+        if service::check_service().await.is_ok() {
+            log::info!(target: "app", "try to run core in service mode");
+            match service::run_core_by_service(&config_path).await {
+                Ok(_) => {
+                    log::info!(target: "app", "core started successfully in service mode");
+                }
+                Err(err) => {
+                    // 服务启动失败，尝试sidecar模式
+                    log::warn!(target: "app", "failed to start core in service mode: {}", err);
+                    log::info!(target: "app", "trying to run core in sidecar mode");
+                    self.run_core_by_sidecar(&config_path).await?;
+                }
+            }
+        } else {
+            // 服务不可用，直接使用sidecar模式
+            log::info!(target: "app", "service not available, running core in sidecar mode");
+            self.run_core_by_sidecar(&config_path).await?;
+        }
+
+        // 流量订阅
+        #[cfg(target_os = "macos")]
+        log_err!(Tray::global().subscribe_traffic().await);
+
+        *running = true;
+
+        Ok(())
+    }
+
+    /// 通过sidecar启动内核
+    async fn run_core_by_sidecar(&self, config_path: &PathBuf) -> Result<()> {
+        let clash_core = { Config::verge().latest().clash_core.clone() };
+        let clash_core = clash_core.unwrap_or("verge-mihomo".into());
+
+        log::info!(target: "app", "starting core {} in sidecar mode", clash_core);
+
+        let app_handle = handle::Handle::global()
+            .app_handle()
+            .ok_or(anyhow::anyhow!("failed to get app handle"))?;
+
+        // 获取配置目录
+        let config_dir = dirs::app_home_dir()?;
+        let config_path_str = dirs::path_to_str(config_path)?;
+
+        // 启动核心进程并转入后台运行
+        let (_, child) = app_handle
+            .shell()
+            .sidecar(clash_core)?
+            .args(["-d", dirs::path_to_str(&config_dir)?, "-f", config_path_str])
+            .spawn()?;
+
+        // 保存进程ID以便后续管理
+        handle::Handle::global().set_core_process(child);
+
+        // 等待短暂时间确保启动成功
+        sleep(Duration::from_millis(300)).await;
+
+        log::info!(target: "app", "core started in sidecar mode");
+        Ok(())
+    }
+
+    /// 重启内核
+    pub async fn restart_core(&self) -> Result<()> {
+        // 重新启动app
+        log::info!(target: "app", "restarting core");
+        self.stop_core().await?;
+        self.start_core().await?;
+        log::info!(target: "app", "core restarted successfully");
+        Ok(())
+    }
+
+    /// 使用默认配置
+    pub async fn use_default_config(&self, msg_type: &str, msg_content: &str) -> Result<()> {
+        let runtime_path = dirs::app_home_dir()?.join(RUNTIME_CONFIG);
+        *Config::runtime().draft() = IRuntime {
+            config: Some(Config::clash().latest().0.clone()),
+            exists_keys: vec![],
+            chain_logs: Default::default(),
+        };
+        help::save_yaml(
+            &runtime_path,
+            &Config::clash().latest().0,
+            Some("# Clash Verge Runtime"),
+        )?;
+        handle::Handle::notice_message(msg_type, msg_content);
+        Ok(())
+    }
+
+    /// 切换核心
+    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_CORES.contains(&clash_core.as_str()) {
+            bail!("invalid clash core name \"{clash_core}\"");
+        }
+
+        log::info!(target: "app", "change core to `{clash_core}`");
+
+        // 1. 先更新内核配置（但不应用）
+        Config::verge().draft().clash_core = Some(clash_core);
+
+        // 2. 使用新内核验证配置
+        println!("[切换内核] 使用新内核验证配置");
+        match self.validate_config().await {
+            Ok((true, _)) => {
+                println!("[切换内核] 配置验证通过，开始切换内核");
+                // 3. 验证通过后，应用内核配置并重启
+                Config::verge().apply();
+                log_err!(Config::verge().latest().save_file());
+
+                match self.restart_core().await {
+                    Ok(_) => {
+                        println!("[切换内核] 内核切换成功");
+                        Config::runtime().apply();
+                        Ok(())
+                    }
+                    Err(err) => {
+                        println!("[切换内核] 内核切换失败: {}", err);
+                        // 即使使用服务失败，我们也尝试使用sidecar模式启动
+                        log::info!(target: "app", "trying sidecar mode after service failure");
+                        self.start_core().await?;
+                        Config::runtime().apply();
+                        Ok(())
+                    }
+                }
+            }
+            Ok((false, error_msg)) => {
+                println!("[切换内核] 配置验证失败: {}", error_msg);
+                // 使用默认配置并继续切换内核
+                self.use_default_config("config_validate::core_change", &error_msg)
+                    .await?;
+                Config::verge().apply();
+                log_err!(Config::verge().latest().save_file());
+
+                match self.restart_core().await {
+                    Ok(_) => {
+                        println!("[切换内核] 内核切换成功（使用默认配置）");
+                        Ok(())
+                    }
+                    Err(err) => {
+                        println!("[切换内核] 内核切换失败: {}", err);
+                        // 即使使用服务失败，我们也尝试使用sidecar模式启动
+                        log::info!(target: "app", "trying sidecar mode after service failure with default config");
+                        self.start_core().await?;
+                        Ok(())
+                    }
+                }
+            }
+            Err(err) => {
+                println!("[切换内核] 验证过程发生错误: {}", err);
+                Config::verge().discard();
+                Err(err)
+            }
+        }
+    }
+
+    /// 内部验证配置文件的实现
+    async fn validate_config_internal(&self, config_path: &str) -> Result<(bool, String)> {
+        // 检查程序是否正在退出，如果是则跳过验证
+        if handle::Handle::global().is_exiting() {
+            println!("[core配置验证] 应用正在退出，跳过验证");
+            return Ok((true, String::new()));
+        }
+
+        println!("[core配置验证] 开始验证配置文件: {}", config_path);
+
+        let clash_core = { Config::verge().latest().clash_core.clone() };
+        let clash_core = clash_core.unwrap_or("verge-mihomo".into());
+        println!("[core配置验证] 使用内核: {}", clash_core);
+
+        let app_handle = handle::Handle::global().app_handle().unwrap();
+        let test_dir = dirs::app_home_dir()?.join("test");
+        let test_dir = dirs::path_to_str(&test_dir)?;
+        println!("[core配置验证] 测试目录: {}", test_dir);
+
+        // 使用子进程运行clash验证配置
+        println!("[core配置验证] 运行子进程验证配置");
+        let output = app_handle
+            .shell()
+            .sidecar(clash_core)?
+            .args(["-t", "-d", test_dir, "-f", config_path])
+            .output()
+            .await?;
+
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        let stdout = String::from_utf8_lossy(&output.stdout);
+
+        // 检查进程退出状态和错误输出
+        let error_keywords = ["FATA", "fatal", "Parse config error", "level=fatal"];
+        let has_error =
+            !output.status.success() || error_keywords.iter().any(|&kw| stderr.contains(kw));
+
+        println!("\n[core配置验证] -------- 验证结果 --------");
+        println!("[core配置验证] 进程退出状态: {:?}", output.status);
+
+        if !stderr.is_empty() {
+            println!("[core配置验证] stderr输出:\n{}", stderr);
+        }
+        if !stdout.is_empty() {
+            println!("[core配置验证] stdout输出:\n{}", stdout);
+        }
+
+        if has_error {
+            println!("[core配置验证] 发现错误，开始处理错误信息");
+            let error_msg = if !stdout.is_empty() {
+                stdout.to_string()
+            } else if !stderr.is_empty() {
+                stderr.to_string()
+            } else if let Some(code) = output.status.code() {
+                format!("验证进程异常退出，退出码: {}", code)
+            } else {
+                "验证进程被终止".to_string()
+            };
+
+            println!("[core配置验证] -------- 验证结束 --------\n");
+            Ok((false, error_msg)) // 返回错误消息给调用者处理
+        } else {
+            println!("[core配置验证] 验证成功");
+            println!("[core配置验证] -------- 验证结束 --------\n");
+            Ok((true, String::new()))
+        }
+    }
+
+    /// 验证运行时配置
+    pub async fn validate_config(&self) -> Result<(bool, String)> {
+        let config_path = Config::generate_file(ConfigType::Check)?;
+        let config_path = dirs::path_to_str(&config_path)?;
+        self.validate_config_internal(config_path).await
+    }
+
+    /// 验证指定的配置文件
+    pub async fn validate_config_file(
+        &self,
+        config_path: &str,
+        is_merge_file: Option<bool>,
+    ) -> Result<(bool, String)> {
+        // 检查程序是否正在退出，如果是则跳过验证
+        if handle::Handle::global().is_exiting() {
+            println!("[core配置验证] 应用正在退出，跳过验证");
+            return Ok((true, String::new()));
+        }
+
+        // 检查文件是否存在
+        if !std::path::Path::new(config_path).exists() {
+            let error_msg = format!("File not found: {}", config_path);
+            //handle::Handle::notice_message("config_validate::file_not_found", &error_msg);
+            return Ok((false, error_msg));
+        }
+
+        // 如果是合并文件且不是强制验证，执行语法检查但不进行完整验证
+        if is_merge_file.unwrap_or(false) {
+            println!(
+                "[core配置验证] 检测到Merge文件，仅进行语法检查: {}",
+                config_path
+            );
+            return self.validate_file_syntax(config_path).await;
+        }
+
+        // 检查是否为脚本文件
+        let is_script = if config_path.ends_with(".js") {
+            true
+        } else {
+            match self.is_script_file(config_path) {
+                Ok(result) => result,
+                Err(err) => {
+                    // 如果无法确定文件类型，尝试使用Clash内核验证
+                    log::warn!(target: "app", "无法确定文件类型: {}, 错误: {}", config_path, err);
+                    return self.validate_config_internal(config_path).await;
+                }
+            }
+        };
+
+        if is_script {
+            log::info!(target: "app", "检测到脚本文件，使用JavaScript验证: {}", config_path);
+            return self.validate_script_file(config_path).await;
+        }
+
+        // 对YAML配置文件使用Clash内核验证
+        log::info!(target: "app", "使用Clash内核验证配置文件: {}", config_path);
+        self.validate_config_internal(config_path).await
+    }
+
+    /// 检查文件是否为脚本文件
+    fn is_script_file(&self, path: &str) -> Result<bool> {
+        // 1. 先通过扩展名快速判断
+        if path.ends_with(".yaml") || path.ends_with(".yml") {
+            return Ok(false); // YAML文件不是脚本文件
+        } else if path.ends_with(".js") {
+            return Ok(true); // JS文件是脚本文件
+        }
+
+        // 2. 读取文件内容
+        let content = match std::fs::read_to_string(path) {
+            Ok(content) => content,
+            Err(err) => {
+                log::warn!(target: "app", "无法读取文件以检测类型: {}, 错误: {}", path, err);
+                return Err(anyhow::anyhow!(
+                    "Failed to read file to detect type: {}",
+                    err
+                ));
+            }
+        };
+
+        // 3. 检查是否存在明显的YAML特征
+        let has_yaml_features = content.contains(": ")
+            || content.contains("#")
+            || content.contains("---")
+            || content.lines().any(|line| line.trim().starts_with("- "));
+
+        // 4. 检查是否存在明显的JS特征
+        let has_js_features = content.contains("function ")
+            || content.contains("const ")
+            || content.contains("let ")
+            || content.contains("var ")
+            || content.contains("//")
+            || content.contains("/*")
+            || content.contains("*/")
+            || content.contains("export ")
+            || content.contains("import ");
+
+        // 5. 决策逻辑
+        if has_yaml_features && !has_js_features {
+            // 只有YAML特征，没有JS特征
+            return Ok(false);
+        } else if has_js_features && !has_yaml_features {
+            // 只有JS特征，没有YAML特征
+            return Ok(true);
+        } else if has_yaml_features && has_js_features {
+            // 两种特征都有，需要更精细判断
+            // 优先检查是否有明确的JS结构特征
+            if content.contains("function main")
+                || content.contains("module.exports")
+                || content.contains("export default")
+            {
+                return Ok(true);
+            }
+
+            // 检查冒号后是否有空格（YAML的典型特征）
+            let yaml_pattern_count = content.lines().filter(|line| line.contains(": ")).count();
+
+            if yaml_pattern_count > 2 {
+                return Ok(false); // 多个键值对格式，更可能是YAML
+            }
+        }
+
+        // 默认情况：无法确定时，假设为非脚本文件（更安全）
+        log::debug!(target: "app", "无法确定文件类型，默认当作YAML处理: {}", path);
+        Ok(false)
+    }
+
+    /// 验证脚本文件语法
+    async fn validate_script_file(&self, path: &str) -> Result<(bool, String)> {
+        // 读取脚本内容
+        let content = match std::fs::read_to_string(path) {
+            Ok(content) => content,
+            Err(err) => {
+                let error_msg = format!("Failed to read script file: {}", err);
+                log::warn!(target: "app", "脚本语法错误: {}", err);
+                //handle::Handle::notice_message("config_validate::script_syntax_error", &error_msg);
+                return Ok((false, error_msg));
+            }
+        };
+
+        log::debug!(target: "app", "验证脚本文件: {}", path);
+
+        // 使用boa引擎进行基本语法检查
+        use boa_engine::{Context, Source};
+
+        let mut context = Context::default();
+        let result = context.eval(Source::from_bytes(&content));
+
+        match result {
+            Ok(_) => {
+                log::debug!(target: "app", "脚本语法验证通过: {}", path);
+
+                // 检查脚本是否包含main函数
+                if !content.contains("function main")
+                    && !content.contains("const main")
+                    && !content.contains("let main")
+                {
+                    let error_msg = "Script must contain a main function";
+                    log::warn!(target: "app", "脚本缺少main函数: {}", path);
+                    //handle::Handle::notice_message("config_validate::script_missing_main", error_msg);
+                    return Ok((false, error_msg.to_string()));
+                }
+
+                Ok((true, String::new()))
+            }
+            Err(err) => {
+                let error_msg = format!("Script syntax error: {}", err);
+                log::warn!(target: "app", "脚本语法错误: {}", err);
+                //handle::Handle::notice_message("config_validate::script_syntax_error", &error_msg);
+                Ok((false, error_msg))
+            }
+        }
+    }
+
+    /// 更新proxies等配置
+    pub async fn update_config(&self) -> Result<(bool, String)> {
+        // 检查程序是否正在退出，如果是则跳过完整验证流程
+        if handle::Handle::global().is_exiting() {
+            println!("[core配置更新] 应用正在退出，跳过验证");
+            return Ok((true, String::new()));
+        }
+
+        println!("[core配置更新] 开始更新配置");
+
+        // 1. 先生成新的配置内容
+        println!("[core配置更新] 生成新的配置内容");
+        Config::generate().await?;
+
+        // 2. 生成临时文件并进行验证
+        println!("[core配置更新] 生成临时配置文件用于验证");
+        let temp_config = Config::generate_file(ConfigType::Check)?;
+        let temp_config = dirs::path_to_str(&temp_config)?;
+        println!("[core配置更新] 临时配置文件路径: {}", temp_config);
+
+        // 3. 验证配置
+        match self.validate_config().await {
+            Ok((true, _)) => {
+                println!("[core配置更新] 配置验证通过");
+                // 4. 验证通过后，生成正式的运行时配置
+                println!("[core配置更新] 生成运行时配置");
+                let run_path = Config::generate_file(ConfigType::Run)?;
+                let run_path = dirs::path_to_str(&run_path)?;
+
+                // 5. 应用新配置
+                println!("[core配置更新] 应用新配置");
+                for i in 0..3 {
+                    match MihomoManager::global().put_configs_force(run_path).await {
+                        Ok(_) => {
+                            println!("[core配置更新] 配置应用成功");
+                            Config::runtime().apply();
+                            return Ok((true, String::new()));
+                        }
+                        Err(err) => {
+                            if i < 2 {
+                                println!("[core配置更新] 第{}次重试应用配置", i + 1);
+                                log::info!(target: "app", "{err}");
+                                sleep(Duration::from_millis(100)).await;
+                            } else {
+                                println!("[core配置更新] 配置应用失败: {}", err);
+                                Config::runtime().discard();
+                                return Ok((false, err.to_string()));
+                            }
+                        }
+                    }
+                }
+                Ok((true, String::new()))
+            }
+            Ok((false, error_msg)) => {
+                println!("[core配置更新] 配置验证失败: {}", error_msg);
+                Config::runtime().discard();
+                Ok((false, error_msg))
+            }
+            Err(e) => {
+                println!("[core配置更新] 验证过程发生错误: {}", e);
+                Config::runtime().discard();
+                Err(e)
+            }
+        }
+    }
+
+    /// 只进行文件语法检查，不进行完整验证
+    async fn validate_file_syntax(&self, config_path: &str) -> Result<(bool, String)> {
+        println!("[core配置语法检查] 开始检查文件: {}", config_path);
+
+        // 读取文件内容
+        let content = match std::fs::read_to_string(config_path) {
+            Ok(content) => content,
+            Err(err) => {
+                let error_msg = format!("Failed to read file: {}", err);
+                println!("[core配置语法检查] 无法读取文件: {}", error_msg);
+                return Ok((false, error_msg));
+            }
+        };
+
+        // 对YAML文件尝试解析，只检查语法正确性
+        println!("[core配置语法检查] 进行YAML语法检查");
+        match serde_yaml::from_str::<serde_yaml::Value>(&content) {
+            Ok(_) => {
+                println!("[core配置语法检查] YAML语法检查通过");
+                Ok((true, String::new()))
+            }
+            Err(err) => {
+                // 使用标准化的前缀，以便错误处理函数能正确识别
+                let error_msg = format!("YAML syntax error: {}", err);
+                println!("[core配置语法检查] YAML语法错误: {}", error_msg);
+                Ok((false, error_msg))
+            }
+        }
+    }
+
+    /// 获取当前内核运行模式
+    pub async fn get_running_mode(&self) -> RunningMode {
+        let running = self.running.lock().await;
+        if !*running {
+            return RunningMode::NotRunning;
+        }
+
+        // 检查服务状态
+        match service::check_service().await {
+            Ok(_) => {
+                // 检查服务是否实际运行核心
+                match service::is_service_running().await {
+                    Ok(true) => RunningMode::Service,
+                    _ => {
+                        // 服务存在但可能没有运行，检查是否有sidecar进程
+                        if handle::Handle::global().has_core_process() {
+                            RunningMode::Sidecar
+                        } else {
+                            RunningMode::NotRunning
+                        }
+                    }
+                }
+            }
+            Err(_) => {
+                // 服务不可用，检查是否有sidecar进程
+                if handle::Handle::global().has_core_process() {
+                    RunningMode::Sidecar
+                } else {
+                    RunningMode::NotRunning
+                }
+            }
+        }
+    }
+}

src-tauri/src/core/handle.rs

@@ -0,0 +1,92 @@
+use crate::log_err;
+use once_cell::sync::OnceCell;
+use parking_lot::RwLock;
+use std::sync::Arc;
+use tauri::{AppHandle, Emitter, Manager, WebviewWindow};
+use tauri_plugin_shell::process::CommandChild;
+
+#[derive(Debug, Default, Clone)]
+pub struct Handle {
+    pub app_handle: Arc<RwLock<Option<AppHandle>>>,
+    pub is_exiting: Arc<RwLock<bool>>,
+    pub core_process: Arc<RwLock<Option<CommandChild>>>,
+}
+
+impl Handle {
+    pub fn global() -> &'static Handle {
+        static HANDLE: OnceCell<Handle> = OnceCell::new();
+
+        HANDLE.get_or_init(|| Handle {
+            app_handle: Arc::new(RwLock::new(None)),
+            is_exiting: Arc::new(RwLock::new(false)),
+            core_process: Arc::new(RwLock::new(None)),
+        })
+    }
+
+    pub fn init(&self, app_handle: &AppHandle) {
+        let mut handle = self.app_handle.write();
+        *handle = Some(app_handle.clone());
+    }
+
+    pub fn app_handle(&self) -> Option<AppHandle> {
+        self.app_handle.read().clone()
+    }
+
+    pub fn get_window(&self) -> Option<WebviewWindow> {
+        let app_handle = self.app_handle().unwrap();
+        let window: Option<WebviewWindow> = app_handle.get_webview_window("main");
+        if window.is_none() {
+            log::debug!(target:"app", "main window not found");
+        }
+        window
+    }
+
+    pub fn refresh_clash() {
+        if let Some(window) = Self::global().get_window() {
+            log_err!(window.emit("verge://refresh-clash-config", "yes"));
+        }
+    }
+
+    pub fn refresh_verge() {
+        if let Some(window) = Self::global().get_window() {
+            log_err!(window.emit("verge://refresh-verge-config", "yes"));
+        }
+    }
+
+    #[allow(unused)]
+    pub fn refresh_profiles() {
+        if let Some(window) = Self::global().get_window() {
+            log_err!(window.emit("verge://refresh-profiles-config", "yes"));
+        }
+    }
+
+    pub fn notice_message<S: Into<String>, M: Into<String>>(status: S, msg: M) {
+        if let Some(window) = Self::global().get_window() {
+            log_err!(window.emit("verge://notice-message", (status.into(), msg.into())));
+        }
+    }
+
+    pub fn set_is_exiting(&self) {
+        let mut is_exiting = self.is_exiting.write();
+        *is_exiting = true;
+    }
+
+    pub fn set_core_process(&self, process: CommandChild) {
+        let mut core_process = self.core_process.write();
+        *core_process = Some(process);
+    }
+
+    pub fn take_core_process(&self) -> Option<CommandChild> {
+        let mut core_process = self.core_process.write();
+        core_process.take()
+    }
+
+    /// 检查是否有运行中的核心进程
+    pub fn has_core_process(&self) -> bool {
+        self.core_process.read().is_some()
+    }
+
+    pub fn is_exiting(&self) -> bool {
+        *self.is_exiting.read()
+    }
+}