release v2.2.3

icon

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -12,14 +12,16 @@ body:
         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将会被关闭
+        4. 请 **务必** 查看 [Alpha](https://github.com/clash-verge-rev/clash-verge-rev/releases/tag/alpha) 版本更新日志
+        5. 请 **务必** 尝试 [Alpha](https://github.com/clash-verge-rev/clash-verge-rev/releases/tag/alpha) 版本，确定问题是否仍然存在
+        6. 请 **务必** 按照模板规范详细描述问题以及尝试更新 Alpha 版本，否则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
+        4. Please be sure to check out [Alpha](https://github.com/clash-verge-rev/clash-verge-rev/releases/tag/alpha) version update log
+        5. Please be sure to try the [Alpha](https://github.com/clash-verge-rev/clash-verge-rev/releases/tag/alpha) version to ensure that the problem still exists
+        6. Please describe the problem in detail according to the template specification and try to update the Alpha version, otherwise the issue will be closed
 
   - type: textarea
     id: description
@@ -57,7 +59,7 @@ body:
       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")
+      label: 日志(勿上传日志文件，请粘贴日志内容) / Log (Do not upload the log file, paste the log content directly)
+      description: 请提供完整或相关部分的Debug日志（请在“软件左侧菜单”->“设置”->“日志等级”调整到debug，Verge错误请把“杂项设置”->“app日志等级”调整到debug，并重启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 debug, and restart Verge to take effect. The log file is under "Software left menu" -> "Settings" -> "Log directory")
     validations:
       required: true

.github/workflows/alpha.yml

@@ -3,8 +3,8 @@ 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 * * *"
+    # UTC+8 0,6,12,18
+    - cron: "0 16,22,4,10 * * *"
 permissions: write-all
 env:
   CARGO_INCREMENTAL: 0
@@ -25,7 +25,7 @@ jobs:
         with:
           fetch-depth: 2
 
-      - name: Check if version changed
+      - name: Check if version changed or src changed
         id: check
         run: |
           # For manual workflow_dispatch, always run
@@ -50,326 +50,80 @@ jobs:
           if [ "$CURRENT_VERSION" != "$PREVIOUS_VERSION" ]; then
             echo "Version changed from $PREVIOUS_VERSION to $CURRENT_VERSION"
             echo "should_run=true" >> $GITHUB_OUTPUT
+            exit 0
+          fi
+
+          # Check if src or src-tauri directories changed
+          CURRENT_SRC_HASH=$(git rev-parse HEAD:src)
+          PREVIOUS_SRC_HASH=$(git rev-parse HEAD~1:src 2>/dev/null || echo "")
+          CURRENT_TAURI_HASH=$(git rev-parse HEAD:src-tauri 2>/dev/null || echo "")
+          PREVIOUS_TAURI_HASH=$(git rev-parse HEAD~1:src-tauri 2>/dev/null || echo "")
+
+          echo "Current src hash: $CURRENT_SRC_HASH"
+          echo "Previous src hash: $PREVIOUS_SRC_HASH"
+          echo "Current tauri hash: $CURRENT_TAURI_HASH"
+          echo "Previous tauri hash: $PREVIOUS_TAURI_HASH"
+
+          if [ "$CURRENT_SRC_HASH" != "$PREVIOUS_SRC_HASH" ] || [ "$CURRENT_TAURI_HASH" != "$PREVIOUS_TAURI_HASH" ]; then
+            echo "Source directories changed"
+            echo "should_run=true" >> $GITHUB_OUTPUT
           else
-            echo "Version unchanged: $CURRENT_VERSION"
+            echo "Version and source directories unchanged"
             echo "should_run=false" >> $GITHUB_OUTPUT
           fi
 
-  delete_old_release:
+  delete_old_assets:
     needs: check_commit
     if: ${{ needs.check_commit.outputs.should_run == 'true' }}
     runs-on: ubuntu-latest
     steps:
-      - name: Delete Old Alpha Release
-        uses: dev-drprasad/delete-tag-and-release@v1.1
+      - name: Delete Old Alpha Release Assets
+        uses: actions/github-script@v7
         with:
-          tag_name: alpha
-          delete_release: true
-          repo: ${{ github.repository }}
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          script: |
+            const releaseTag = 'alpha';
 
-  alpha:
-    needs: delete_old_release
-    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
+            try {
+              // Get the release by tag name
+              const { data: release } = await github.rest.repos.getReleaseByTag({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                tag: releaseTag
+              });
 
-    runs-on: ${{ matrix.os }}
-    steps:
-      - name: Checkout Repository
-        uses: actions/checkout@v4
+              console.log(`Found release with ID: ${release.id}`);
 
-      - name: Install Rust Stable
-        uses: dtolnay/rust-toolchain@stable
+              // Delete each asset
+              if (release.assets && release.assets.length > 0) {
+                console.log(`Deleting ${release.assets.length} assets`);
 
-      - name: Add Rust Target
-        run: rustup target add ${{ matrix.target }}
+                for (const asset of release.assets) {
+                  console.log(`Deleting asset: ${asset.name} (${asset.id})`);
+                  await github.rest.repos.deleteReleaseAsset({
+                    owner: context.repo.owner,
+                    repo: context.repo.repo,
+                    asset_id: asset.id
+                  });
+                }
 
-      - 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: 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: delete_old_release
-    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: delete_old_release
-    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 }}
+                console.log('All assets deleted successfully');
+              } else {
+                console.log('No assets found to delete');
+              }
+            } catch (error) {
+              if (error.status === 404) {
+                console.log('Release not found, nothing to delete');
+              } else {
+                console.error('Error:', error);
+                throw error;
+              }
+            }
 
   update_tag:
     name: Update tag
     runs-on: ubuntu-latest
-    needs: [delete_old_release, alpha, alpha-for-linux-arm, alpha-for-fixed-webview2]
+    needs: delete_old_assets
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
@@ -380,7 +134,8 @@ jobs:
           # Check if UPDATELOG.md exists
           if [ -f "UPDATELOG.md" ]; then
             # Extract the section starting with ## and containing -alpha until the next ## or end of file
-            ALPHA_LOGS=$(awk '/^## .*-alpha/{flag=1; print; next} /^## /{flag=0} flag' UPDATELOG.md)
+            # ALPHA_LOGS=$(awk '/^## .*-alpha/{flag=1; print; next} /^## /{flag=0} flag' UPDATELOG.md)
+            ALPHA_LOGS=$(awk '/^## v/{if(flag) exit; flag=1} flag' UPDATELOG.md)
 
             if [ -n "$ALPHA_LOGS" ]; then
               echo "Found alpha update logs"
@@ -452,3 +207,307 @@ jobs:
           prerelease: true
           token: ${{ secrets.GITHUB_TOKEN }}
           generate_release_notes: true
+
+  alpha:
+    needs: update_tag
+    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 libxslt1.1 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: Release Alpha Version
+        run: pnpm release-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: update_tag
+    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: Release Alpha Version
+        run: pnpm release-alpha-version
+
+      - 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 \
+            libxslt1.1:${{ matrix.arch }} \
+            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"
+          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: update_tag
+    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: Release Alpha Version
+        run: pnpm release-alpha-version
+
+      - 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"
+          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 }}

.github/workflows/release.yml

@@ -50,7 +50,7 @@ jobs:
         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
+          sudo apt-get install -y libxslt1.1 libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librsvg2-dev patchelf
 
       - name: Install Node
         uses: actions/setup-node@v4
@@ -153,6 +153,7 @@ jobs:
           sudo apt update
 
           sudo apt install -y \
+            libxslt1.1:${{ matrix.arch }} \
             libwebkit2gtk-4.1-dev:${{ matrix.arch }} \
             libayatana-appindicator3-dev:${{ matrix.arch }} \
             libssl-dev:${{ matrix.arch }} \

.husky/pre-commit

@@ -3,12 +3,12 @@
 #pnpm pretty-quick --staged
 
 # 运行 clippy fmt
-#cargo fmt --manifest-path ./src-tauri/Cargo.toml
+cargo fmt --manifest-path ./src-tauri/Cargo.toml
 
-# if [ $? -ne 0 ]; then
-#     echo "rustfmt failed to format the code. Please fix the issues and try again."
-#     exit 1
-# fi
+if [ $? -ne 0 ]; then
+    echo "rustfmt failed to format the code. Please fix the issues and try again."
+    exit 1
+fi
 
 #git add .
 

.husky/pre-push

@@ -1,13 +1,13 @@
 #!/bin/bash
 
 # 运行 clippy
-#cargo clippy  --manifest-path ./src-tauri/Cargo.toml --fix
+# cargo clippy  --manifest-path ./src-tauri/Cargo.toml --fix
 
 # 如果 clippy 失败，阻止 push
-#if [ $? -ne 0 ]; then
+# if [ $? -ne 0 ]; then
 #    echo "Clippy found issues in sub_crate. Please fix them before pushing."
 #    exit 1
-#fi
+# fi
 
 # 允许 push
 exit 0

UPDATELOG.md

@@ -1,17 +1,105 @@
-## v2.2.1-alpha
-**发行代号：拓**
+## v2.2.3
 
-#### 修复
-1. **系统**
-  - 修复 MacOS 无法使用快捷键粘贴/选择/复制订阅地址。
+#### 已知问题
+ - 仅在Ubuntu 22.04/24.04，Fedora 41 **Gnome桌面环境** 做过简单测试，不保证其他其他Linux发行版可用，将在未来做进一步适配和调优
+ - MacOS 自定义图标与速率显示推荐图标尺寸为 256x256。其他尺寸（可能）会导致不正常图标和速率间隙
+ - MacOS 下 墙贴主要为浅色，Tray 图标深色时图标闪烁；彩色 Tray 速率颜色淡
+ - Linux 下 Clash Verge Rev 内存占用显著高于 Windows / MacOS
 
+### 2.2.3 相对于 2.2.2
+#### 修复了：
+ - 首页“当前代理”因为重复刷新导致的CPU占用过高的问题
+ - “开机自启”和“DNS覆写”开关跳动问题
+ - 自定义托盘图标未能应用更改
+ - MacOS 自定义托盘图标显示速率时图标和文本间隙过大
+ - MacOS 托盘速率显示不全
+ - Linux 在系统服务模式下无法拉起 Mihomo 内核
+ - 使用异步操作，避免获取系统信息和切换代理模式可能带来的崩溃
+ - 相同节点名称可能导致的页面渲染出错
+ - URL Schemes被截断的问题
+ - 首页流量统计卡更好的时间戳范围
+ - 静默启动无法触发自动轻量化计时器
 
-## v2.2.0
+#### 新增了：
+ - Mihomo(Meta)内核升级至 1.19.4
+ - Clash Verge Rev 从现在开始不再强依赖系统服务和管理权限
+ - 支持根据用户偏好选择Sidecar(用户空间)模式或安装服务
+ - 增加载入初始配置文件的错误提示，防止切换到错误的订阅配置
+ - 检测是否以管理员模式运行软件，如果是提示无法使用开机自启
+ - 代理组显示节点数量
+ - 统一运行模式检测，支持管理员模式下开启TUN模式
+ - 托盘切换代理模式会根据设置自动断开之前连接
+ - 如订阅获取失败回退使用Clash内核代理再次尝试
+
+#### 移除了：
+ - 实时保存窗口位置和大小。这个功能可能会导致窗口异常大小和位置，还需观察。
+
+#### 优化了：
+ - 重构了后端内核管理逻辑，更轻量化和有效的管理内核，提高了性能和稳定性
+ - 前端统一刷新应用数据，优化数据获取和刷新逻辑
+ - 优化首页流量图表代码，调整图表文字边距
+ - MacOS 托盘速率更好的显示样式和更新逻辑
+ - 首页仅在有流量图表时显示流量图表区域
+ - 更新DNS默认覆写配置
+ - 移除测试目录，简化资源初始化逻辑
+
+## v2.2.2
 
 **发行代号：拓**
 
+感谢 Tunglies 对 Verge 后端重构，性能优化做出的重大贡献！
+
 代号释义： 本次发布在功能上的大幅扩展。新首页设计为用户带来全新交互体验，DNS 覆写功能增强网络控制能力，解锁测试页面助力内容访问自由度提升，轻量模式提供灵活使用选择。此外，macOS 应用菜单集成、sidecar 模式、诊断信息导出等新特性进一步丰富了软件的适用场景。这些新增功能显著拓宽了 Clash Verge 的功能边界，为用户提供了更强大的工具和可能性。
 
+#### 已知问题
+ - 仅在Ubuntu 22.04/24.04，Fedora 41 **Gnome桌面环境** 做过简单测试，不保证其他其他Linux发行版可用，将在未来做进一步适配和调优
+
+### 2.2.2 相对于 2.2.1(已下架不再提供)
+#### 修复了：
+ - 弹黑框的问题（原因是服务崩溃触发重装机制）
+ - MacOS进入轻量模式以后隐藏Dock图标
+ - 增加轻量模式缺失的tray翻译
+ - Linux下的窗口边框被削掉的问题
+
+#### 新增了:
+ - 加强服务检测和重装逻辑
+ - 增强内核与服务保活机制
+ - 增加服务模式下的僵尸进程清理机制
+ - 新增当服务模式多次尝试失败后自动回退至用户空间模式
+
+### 2.2.1 相对于 2.2.0(已下架不再提供)
+#### 修复了：
+1. **首页**
+   - 修复 Direct 模式首页无法渲染
+   - 修复 首页启用轻量模式导致 ClashVergeRev 从托盘退出
+   - 修复 系统代理标识判断不准的问题
+   - 修复 系统代理地址错误的问题
+   - 代理模式“多余的切换动画”
+2. **系统**
+   - 修复 MacOS 无法使用快捷键粘贴/选择/复制订阅地址。
+   - 修复 代理端口设置同步问题。
+   - 修复 Linux 无法与 Mihomo 核心 和 ClashVergeRev 服务通信
+3. **界面**
+   - 修复 连接详情卡没有跟随主题色
+4. **轻量模式**
+   - 修复 MacOS 轻量模式下 Dock 栏图标无法隐藏。
+
+#### 新增了:
+1. **首页**
+   - 首页文本过长自动截断
+2. **轻量模式**
+   - 新增托盘进入轻量模式支持
+   - 新增进入轻量模式快捷键支持
+3. **系统**
+   - 在 ClashVergeRev 对 Mihomo 进行操作时，总是尝试确保两者运行
+   - 服务器模式下启动mihomo内核的时候查找并停止其他已经存在的内核进程，防止内核假死等问题带来的通信失败
+4. **托盘**
+   - 新增 MacOS 启用托盘速率显示时，可选隐藏托盘图标显示
+
+---
+
+## 2.2.0(已下架不再提供)
+
 #### 新增功能
 1. **首页**
    - 新增首页功能，默认启动页面改为首页。
@@ -21,8 +109,8 @@
    - 限制首页配置文件卡片URL长度。
 
 2. **DNS 设置与覆写**
-   - 默认启用 DNS 设置。
    - 新增 DNS 覆写功能。
+   - 默认启用 DNS 覆写。
 
 3. **解锁测试**
    - 新增解锁测试页面。
@@ -32,10 +120,11 @@
    - 添加自动轻量模式定时器。
 
 5. **系统支持**
+   - Mihomo(meta)内核升级 1.19.3
    - macOS 支持 CMD+W 关闭窗口。
    - 新增 macOS 应用菜单。
-   - 添加管理员权限提示。
-   - 新增 sidecar 模式。
+   - 添加 macOS 安装服务时候的管理员权限提示。
+   - 新增 sidecar(用户空间启动内核) 模式。
 
 6. **其他**
    - 增强延迟测试日志和错误处理。
@@ -47,28 +136,29 @@
    - 修复 Windows 热键崩溃。
    - 修复 macOS 无框标题。
    - 修复 macOS 静默启动崩溃。
+   - 修复 macOS tray图标错位到左上角的问题。
    - 修复 Windows/Linux 运行时崩溃。
-   - 修复 Netflix 检测错误。
-   - 修复服务模式检测失败。
+   - 修复 Win10 阴影和边框问题。
+   - 修复 升级或重装后开机自启状态检测和同步问题。
 
-2. **性能**
-   - 优化小数值速度更新。
-   - 增加请求超时至 60 秒。
-   - 修复代理节点选择同步。
-   - 优化修改verge配置性能。
-
-3. **构建**
+2. **构建**
    - 修复构建失败问题。
 
 #### 优化
 1. **性能**
+   - 重构后端，巨幅性能优化。
    - 优化首页组件性能。
    - 优化流量图表资源使用。
    - 提升代理组列表滚动性能。
    - 加快应用退出速度。
    - 加快进入轻量模式速度。
+   - 优化小数值速度更新。
+   - 增加请求超时至 60 秒。
+   - 修复代理节点选择同步。
+   - 优化修改verge配置性能。
 
 2. **重构**
+   - 重构后端，巨幅性能优化。
    - 优化定时器管理。
    - 重构 MihomoManager 处理流量。
    - 优化 WebSocket 连接。
@@ -87,14 +177,14 @@
 
 感谢 Tychristine 对社区群组管理做出的重大贡献！
 
-##### 2.1.2相对2.1.1(已下架不在提供)更新了：
+##### 2.1.2相对2.1.1(已下架不再提供)更新了：
 
 - 无法更新和签名验证失败的问题(该死的CDN缓存)
 - 设置菜单区分Verge基本设置和高级设置
 - 增加v2 Updater的更多功能和权限
 - 退出Verge后Tun代理状态仍保留的问题
 
-##### 2.1.1相对2.1.0(已下架不在提供)更新了：
+##### 2.1.1相对2.1.0(已下架不再提供)更新了：
 
 - 检测所需的Clash Verge Service版本（杀毒软件误报可能与此有关，因为检测和安装新版本Service需管理员权限）
 - MacOS下支持彩色托盘图标和更好速率显示（感谢Tunglies）

package.json

@@ -1,6 +1,6 @@
 {
   "name": "clash-verge",
-  "version": "2.2.1-alpha",
+  "version": "2.2.3",
   "license": "GPL-3.0-only",
   "scripts": {
     "dev": "cross-env RUST_BACKTRACE=1 tauri dev -f verge-dev -- --profile fast-dev",
@@ -16,9 +16,11 @@
     "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",
+    "fix-alpha-version": "node scripts/fix-alpha_version.mjs",
+    "release-version": "node scripts/release_version.mjs",
+    "release-alpha-version": "node scripts/release-alpha_version.mjs",
     "prepare": "husky",
-    "clean": "cd ./src-tauri && cargo clean && cd -"
+    "clippy": "cargo clippy  --manifest-path ./src-tauri/Cargo.toml"
   },
   "dependencies": {
     "@dnd-kit/core": "^6.3.1",

scripts/release-alpha_version.mjs

@@ -0,0 +1,96 @@
+import fs from "fs/promises";
+import path from "path";
+
+/**
+ * 更新 package.json 文件中的版本号
+ */
+async function updatePackageVersion() {
+  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;
+    if (!result.includes("alpha")) {
+      result = `${result}-alpha`;
+    }
+
+    console.log("[INFO]: Current package.json version is: ", result);
+    packageJson.version = result;
+    await fs.writeFile(
+      packageJsonPath,
+      JSON.stringify(packageJson, null, 2),
+      "utf8",
+    );
+    console.log(`[INFO]: package.json version updated to: ${result}`);
+  } catch (error) {
+    console.error("Error updating package.json version:", error);
+  }
+}
+
+/**
+ * 更新 Cargo.toml 文件中的版本号
+ */
+async function updateCargoVersion() {
+  const _dirname = process.cwd();
+  const cargoTomlPath = path.join(_dirname, "src-tauri", "Cargo.toml");
+  try {
+    const data = await fs.readFile(cargoTomlPath, "utf8");
+    const lines = data.split("\n");
+
+    const updatedLines = lines.map((line) => {
+      if (line.startsWith("version =")) {
+        const versionMatch = line.match(/version\s*=\s*"([^"]+)"/);
+        if (versionMatch && !versionMatch[1].includes("alpha")) {
+          const newVersion = `${versionMatch[1]}-alpha`;
+          return line.replace(versionMatch[1], newVersion);
+        }
+      }
+      return line;
+    });
+
+    await fs.writeFile(cargoTomlPath, updatedLines.join("\n"), "utf8");
+  } catch (error) {
+    console.error("Error updating Cargo.toml version:", error);
+  }
+}
+
+/**
+ * 更新 tauri.conf.json 文件中的版本号
+ */
+async function updateTauriConfigVersion() {
+  const _dirname = process.cwd();
+  const tauriConfigPath = path.join(_dirname, "src-tauri", "tauri.conf.json");
+  try {
+    const data = await fs.readFile(tauriConfigPath, "utf8");
+    const tauriConfig = JSON.parse(data);
+
+    let version = tauriConfig.version;
+    if (!version.includes("alpha")) {
+      version = `${version}-alpha`;
+    }
+
+    console.log("[INFO]: Current tauri.conf.json version is: ", version);
+    tauriConfig.version = version;
+    await fs.writeFile(
+      tauriConfigPath,
+      JSON.stringify(tauriConfig, null, 2),
+      "utf8",
+    );
+    console.log(`[INFO]: tauri.conf.json version updated to: ${version}`);
+  } catch (error) {
+    console.error("Error updating tauri.conf.json version:", error);
+  }
+}
+
+/**
+ * 主函数，依次更新所有文件的版本号
+ */
+async function main() {
+  await updatePackageVersion();
+  await updateCargoVersion();
+  await updateTauriConfigVersion();
+}
+
+main().catch(console.error);

scripts/release_version.mjs

@@ -0,0 +1,197 @@
+import fs from "fs/promises";
+import path from "path";
+import { program } from "commander";
+
+/**
+ * 验证版本号格式
+ * @param {string} version
+ * @returns {boolean}
+ */
+function isValidVersion(version) {
+  return /^v?\d+\.\d+\.\d+(-(alpha|beta|rc)(\.\d+)?)?$/i.test(version);
+}
+
+/**
+ * 标准化版本号（确保v前缀可选）
+ * @param {string} version
+ * @returns {string}
+ */
+function normalizeVersion(version) {
+  return version.startsWith("v") ? version : `v${version}`;
+}
+
+/**
+ * 更新 package.json 文件中的版本号
+ * @param {string} newVersion 新版本号
+ */
+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);
+
+    console.log(
+      "[INFO]: Current package.json version is: ",
+      packageJson.version,
+    );
+    packageJson.version = newVersion.startsWith("v")
+      ? newVersion.slice(1)
+      : newVersion;
+    await fs.writeFile(
+      packageJsonPath,
+      JSON.stringify(packageJson, null, 2),
+      "utf8",
+    );
+    console.log(
+      `[INFO]: package.json version updated to: ${packageJson.version}`,
+    );
+    return packageJson.version;
+  } catch (error) {
+    console.error("Error updating package.json version:", error);
+    throw error;
+  }
+}
+
+/**
+ * 更新 Cargo.toml 文件中的版本号
+ * @param {string} newVersion 新版本号
+ */
+async function updateCargoVersion(newVersion) {
+  const _dirname = process.cwd();
+  const cargoTomlPath = path.join(_dirname, "src-tauri", "Cargo.toml");
+  try {
+    const data = await fs.readFile(cargoTomlPath, "utf8");
+    const lines = data.split("\n");
+
+    const versionWithoutV = newVersion.startsWith("v")
+      ? newVersion.slice(1)
+      : newVersion;
+
+    const updatedLines = lines.map((line) => {
+      if (line.trim().startsWith("version =")) {
+        return line.replace(
+          /version\s*=\s*"[^"]+"/,
+          `version = "${versionWithoutV}"`,
+        );
+      }
+      return line;
+    });
+
+    await fs.writeFile(cargoTomlPath, updatedLines.join("\n"), "utf8");
+    console.log(`[INFO]: Cargo.toml version updated to: ${versionWithoutV}`);
+  } catch (error) {
+    console.error("Error updating Cargo.toml version:", error);
+    throw error;
+  }
+}
+
+/**
+ * 更新 tauri.conf.json 文件中的版本号
+ * @param {string} newVersion 新版本号
+ */
+async function updateTauriConfigVersion(newVersion) {
+  const _dirname = process.cwd();
+  const tauriConfigPath = path.join(_dirname, "src-tauri", "tauri.conf.json");
+  try {
+    const data = await fs.readFile(tauriConfigPath, "utf8");
+    const tauriConfig = JSON.parse(data);
+
+    const versionWithoutV = newVersion.startsWith("v")
+      ? newVersion.slice(1)
+      : newVersion;
+
+    console.log(
+      "[INFO]: Current tauri.conf.json version is: ",
+      tauriConfig.version,
+    );
+    tauriConfig.version = versionWithoutV;
+    await fs.writeFile(
+      tauriConfigPath,
+      JSON.stringify(tauriConfig, null, 2),
+      "utf8",
+    );
+    console.log(
+      `[INFO]: tauri.conf.json version updated to: ${versionWithoutV}`,
+    );
+  } catch (error) {
+    console.error("Error updating tauri.conf.json version:", error);
+    throw error;
+  }
+}
+
+/**
+ * 获取当前版本号（从package.json）
+ */
+async function getCurrentVersion() {
+  const _dirname = process.cwd();
+  const packageJsonPath = path.join(_dirname, "package.json");
+  try {
+    const data = await fs.readFile(packageJsonPath, "utf8");
+    const packageJson = JSON.parse(data);
+    return packageJson.version;
+  } catch (error) {
+    console.error("Error getting current version:", error);
+    throw error;
+  }
+}
+
+/**
+ * 主函数，更新所有文件的版本号
+ * @param {string} versionArg 版本参数（可以是标签或完整版本号）
+ */
+async function main(versionArg) {
+  if (!versionArg) {
+    console.error("Error: Version argument is required");
+    process.exit(1);
+  }
+
+  try {
+    let newVersion;
+    const validTags = ["alpha", "beta", "rc"];
+
+    // 判断参数是标签还是完整版本号
+    if (validTags.includes(versionArg.toLowerCase())) {
+      // 标签模式：在当前版本基础上添加标签
+      const currentVersion = await getCurrentVersion();
+      const baseVersion = currentVersion.replace(
+        /-(alpha|beta|rc)(\.\d+)?$/i,
+        "",
+      );
+      newVersion = `${baseVersion}-${versionArg.toLowerCase()}`;
+    } else {
+      // 完整版本号模式
+      if (!isValidVersion(versionArg)) {
+        console.error(
+          "Error: Invalid version format. Expected format: vX.X.X or vX.X.X-tag (e.g. v2.2.3 or v2.2.3-alpha)",
+        );
+        process.exit(1);
+      }
+      newVersion = normalizeVersion(versionArg);
+    }
+
+    console.log(`[INFO]: Updating versions to: ${newVersion}`);
+    await updatePackageVersion(newVersion);
+    await updateCargoVersion(newVersion);
+    await updateTauriConfigVersion(newVersion);
+    console.log("[SUCCESS]: All version updates completed successfully!");
+  } catch (error) {
+    console.error("[ERROR]: Failed to update versions:", error);
+    process.exit(1);
+  }
+}
+
+// Example:
+// pnpm release-version 2.2.3-alpha
+// 设置命令行界面
+program
+  .name("pnpm release-version")
+  .description(
+    "Update project version numbers. Can add tag (alpha/beta/rc) or set full version (e.g. v2.2.3 or v2.2.3-alpha)",
+  )
+  .argument(
+    "<version>",
+    "version tag (alpha/beta/rc) or full version (e.g. v2.2.3 or v2.2.3-alpha)",
+  )
+  .action(main)
+  .parse(process.argv);

scripts/updatelog.mjs

@@ -43,3 +43,42 @@ export async function resolveUpdateLog(tag) {
 
   return map[tag].join("\n").trim();
 }
+
+export async function resolveUpdateLogDefault() {
+  const cwd = process.cwd();
+  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 reTitle = /^## v[\d\.]+/;
+  const reEnd = /^---/;
+
+  let isCapturing = false;
+  let content = [];
+  let firstTag = "";
+
+  for (const line of data.split("\n")) {
+    if (reTitle.test(line) && !isCapturing) {
+      isCapturing = true;
+      firstTag = line.slice(3).trim();
+      continue;
+    }
+
+    if (isCapturing) {
+      if (reEnd.test(line)) {
+        break;
+      }
+      content.push(line);
+    }
+  }
+
+  if (!firstTag) {
+    throw new Error("could not found any version tag in UPDATELOG.md");
+  }
+
+  return content.join("\n").trim();
+}

scripts/updater.mjs

@@ -1,6 +1,6 @@
 import fetch from "node-fetch";
 import { getOctokit, context } from "@actions/github";
-import { resolveUpdateLog } from "./updatelog.mjs";
+import { resolveUpdateLog, resolveUpdateLogDefault } from "./updatelog.mjs";
 
 // Add stable update JSON filenames
 const UPDATE_TAG_NAME = "updater";
@@ -8,8 +8,8 @@ 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";
+const ALPHA_UPDATE_JSON_FILE = "update.json";
+const ALPHA_UPDATE_JSON_PROXY = "update-proxy.json";
 
 /// generate update.json
 /// upload to update tag's release asset
@@ -78,224 +78,235 @@ async function resolveUpdater() {
 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 {
-    let updateRelease;
+    const { data: release } = await github.rest.repos.getReleaseByTag({
+      ...options,
+      tag: tag.name,
+    });
+
+    const updateData = {
+      name: tag.name,
+      notes: await resolveUpdateLog(tag.name).catch(() =>
+        resolveUpdateLogDefault().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 {
-      // Try to get the existing release
-      const response = await github.rest.repos.getReleaseByTag({
+      let updateRelease;
+
+      try {
+        // Try to get the existing release
+        const response = await github.rest.repos.getReleaseByTag({
+          ...options,
+          tag: releaseTag,
+        });
+        updateRelease = response.data;
+        console.log(
+          `Found existing ${releaseTag} release with ID: ${updateRelease.id}`,
+        );
+      } catch (error) {
+        // If release doesn't exist, create it
+        if (error.status === 404) {
+          console.log(
+            `Release with tag ${releaseTag} not found, creating new release...`,
+          );
+          const createResponse = await github.rest.repos.createRelease({
+            ...options,
+            tag_name: releaseTag,
+            name: isAlpha
+              ? "Auto-update Alpha Channel"
+              : "Auto-update Stable Channel",
+            body: `This release contains the update information for ${isAlpha ? "alpha" : "stable"} channel.`,
+            prerelease: isAlpha,
+          });
+          updateRelease = createResponse.data;
+          console.log(
+            `Created new ${releaseTag} release with ID: ${updateRelease.id}`,
+          );
+        } else {
+          // If it's another error, throw it
+          throw error;
+        }
+      }
+
+      // 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,
-        tag: releaseTag,
+        release_id: updateRelease.id,
+        name: jsonFile,
+        data: JSON.stringify(updateData, null, 2),
       });
-      updateRelease = response.data;
+
+      await github.rest.repos.uploadReleaseAsset({
+        ...options,
+        release_id: updateRelease.id,
+        name: proxyFile,
+        data: JSON.stringify(updateDataNew, null, 2),
+      });
+
       console.log(
-        `Found existing ${releaseTag} release with ID: ${updateRelease.id}`,
+        `Successfully uploaded ${isAlpha ? "alpha" : "stable"} update files to ${releaseTag}`,
       );
     } catch (error) {
-      // If release doesn't exist, create it
-      if (error.status === 404) {
-        console.log(
-          `Release with tag ${releaseTag} not found, creating new release...`,
-        );
-        const createResponse = await github.rest.repos.createRelease({
-          ...options,
-          tag_name: releaseTag,
-          name: isAlpha
-            ? "Auto-update Alpha Channel"
-            : "Auto-update Stable Channel",
-          body: `This release contains the update information for ${isAlpha ? "alpha" : "stable"} channel.`,
-          prerelease: isAlpha,
-        });
-        updateRelease = createResponse.data;
-        console.log(
-          `Created new ${releaseTag} release with ID: ${updateRelease.id}`,
-        );
-      } else {
-        // If it's another error, throw it
-        throw error;
-      }
+      console.error(
+        `Failed to process ${isAlpha ? "alpha" : "stable"} release:`,
+        error.message,
+      );
     }
-
-    // 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,
-    );
+    if (error.status === 404) {
+      console.log(`Release not found for tag: ${tag.name}, skipping...`);
+    } else {
+      console.error(
+        `Failed to get release for tag: ${tag.name}`,
+        error.message,
+      );
+    }
   }
 }
 

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "clash-verge"
-version = "2.2.1-alpha"
+version = "2.2.3"
 description = "clash verge"
 authors = ["zzzgydi", "wonfen", "MystiPanda"]
 license = "GPL-3.0-only"
@@ -13,72 +13,72 @@ build = "build.rs"
 identifier = "io.github.clash-verge-rev.clash-verge-rev"
 
 [build-dependencies]
-tauri-build = { version = "2.0.6", features = [] }
+tauri-build = { version = "2.1.0", features = [] }
 
 [dependencies]
 warp = "0.3"
 anyhow = "1.0.97"
 dirs = "6.0"
-open = "5.1"
+open = "5.3"
 log = "0.4"
 dunce = "1.0"
 log4rs = "1"
 nanoid = "0.4"
 chrono = "0.4.40"
-sysinfo = "0.33.1"
+sysinfo = "0.34"
 boa_engine = "0.20.0"
 serde_json = "1.0"
 serde_yaml = "0.9"
-once_cell = "1.20.3"
+once_cell = "1.21.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"] }
+tokio = { version = "1.44", features = [
+  "rt-multi-thread",
+  "macros",
+  "time",
+  "sync",
+] }
 serde = { version = "1.0", features = ["derive"] }
 reqwest = { version = "0.12", features = ["json", "rustls-tls", "cookies"] }
-regex = "1.10.5"
+regex = "1.11.1"
 sysproxy = { git = "https://github.com/clash-verge-rev/sysproxy-rs", rev = "3d748b5" }
-image = "0.25.5"
+image = "0.25.6"
 imageproc = "0.25.0"
-rusttype = "0.9"
-tauri = { version = "2.3.1", features = [
-    "protocol-asset",
-    "devtools",
-    "tray-icon",
-    "image-ico",
-    "image-png",
+tauri = { version = "2.4.0", features = [
+  "protocol-asset",
+  "devtools",
+  "tray-icon",
+  "image-ico",
+  "image-png",
 ] }
-network-interface = { version = "2.0.0", features = ["serde"] }
+network-interface = { version = "2.0.1", 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-clipboard-manager = "2.2.2"
 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"
+tauri-plugin-devtools = "2.0.0"
+zip = "2.5.0"
+reqwest_dav = "0.1.15"
 aes-gcm = { version = "0.10.3", features = ["std"] }
 base64 = "0.22.1"
-getrandom = "0.3.1"
+getrandom = "0.3.2"
 tokio-tungstenite = "0.26.2"
 futures = "0.3"
-sys-locale = "0.3.1"
-async-trait = "0.1.87"
+sys-locale = "0.3.2"
+async-trait = "0.1.88"
 mihomo_api = { path = "src_crates/crate_mihomo_api" }
 ab_glyph = "0.2.29"
 tungstenite = "0.26.2"
-
+libc = "0.2"
 
 [target.'cfg(windows)'.dependencies]
 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"
@@ -86,9 +86,8 @@ 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-updater = "2.6.1"
 tauri-plugin-window-state = "2.2.1"
-#openssl
 
 [features]
 default = ["custom-protocol"]
@@ -106,31 +105,33 @@ strip = true
 incremental = true
 
 [profile.fast-release]
-inherits = "release"  # 继承 release 的配置
-panic = "abort"       # 与 release 相同
-codegen-units = 256    # 增加编译单元，提升编译速度
-lto = false           # 禁用 LTO，提升编译速度
-opt-level = 0         # 禁用优化，大幅提升编译速度
-debug = true          # 保留调试信息
-strip = false         # 不剥离符号，保留调试信息
+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         # 不剥离符号，保留调试信息
+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"
+tempfile = "3.19.1"
 
 [workspace]
-members = [
-    "src_crates/crate_mihomo_api",]
+members = ["src_crates/crate_mihomo_api"]
+
+# [patch.crates-io]
+# bitflags = { git = "https://github.com/bitflags/bitflags", rev = "2.9.0" }
+# zerocopy = { git = "https://github.com/google/zerocopy", rev = "v0.8.24" }
+# tungstenite = { git = "https://github.com/snapview/tungstenite-rs", rev = "v0.26.2" }

src-tauri/capabilities/migrated.json

@@ -68,7 +68,6 @@
     "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",
@@ -79,7 +78,6 @@
     "clipboard-manager:allow-read-text",
     "clipboard-manager:allow-write-text",
     "shell:default",
-    "dialog:default",
-    "notification:default"
+    "dialog:default"
   ]
 }

src-tauri/src/cmd/app.rs

@@ -1,5 +1,9 @@
 use super::CmdResult;
-use crate::{feat, utils::dirs, wrap_err};
+use crate::{
+    feat, logging,
+    utils::{dirs, logging::Type},
+    wrap_err,
+};
 use tauri::Manager;
 
 /// 打开应用程序所在目录
@@ -194,7 +198,14 @@ pub fn copy_icon_file(path: String, icon_info: IconInfo) -> CmdResult<String> {
             )
             .unwrap_or_default();
         }
-
+        logging!(
+            info,
+            Type::Cmd,
+            true,
+            "Copying icon file path: {:?} -> file dist: {:?}",
+            path,
+            dest_path
+        );
         match fs::copy(file_path, &dest_path) {
             Ok(_) => Ok(dest_path.to_string_lossy().to_string()),
             Err(err) => Err(err.to_string()),

src-tauri/src/cmd/media_unlock_checker.rs

@@ -2,11 +2,9 @@ use chrono::Local;
 use regex::Regex;
 use reqwest::Client;
 use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-use std::sync::Arc;
+use std::{collections::HashMap, sync::Arc};
 use tauri::command;
-use tokio::sync::Mutex;
-use tokio::task::JoinSet;
+use tokio::{sync::Mutex, task::JoinSet};
 
 // 定义解锁测试项目的结构
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -464,9 +462,11 @@ async fn check_netflix(client: &Client) -> UnlockItem {
     let url2 = "https://www.netflix.com/title/70143836"; // Breaking Bad
 
     // 创建简单的请求（不添加太多头部信息）
-    let result1 = client.get(url1)
+    let result1 = client
+        .get(url1)
         .timeout(std::time::Duration::from_secs(30))
-        .send().await;
+        .send()
+        .await;
 
     // 检查连接失败情况
     if let Err(e) = &result1 {
@@ -480,9 +480,11 @@ async fn check_netflix(client: &Client) -> UnlockItem {
     }
 
     // 如果第一个请求成功，尝试第二个请求
-    let result2 = client.get(url2)
+    let result2 = client
+        .get(url2)
         .timeout(std::time::Duration::from_secs(30))
-        .send().await;
+        .send()
+        .await;
 
     if let Err(e) = &result2 {
         eprintln!("Netflix请求错误: {}", e);
@@ -521,7 +523,8 @@ async fn check_netflix(client: &Client) -> UnlockItem {
         // 成功解锁，尝试获取地区信息
         // 使用Netflix测试内容获取区域
         let test_url = "https://www.netflix.com/title/80018499";
-        match client.get(test_url)
+        match client
+            .get(test_url)
             .timeout(std::time::Duration::from_secs(30))
             .send()
             .await
@@ -561,7 +564,7 @@ async fn check_netflix(client: &Client) -> UnlockItem {
                     region: None,
                     check_time: Some(get_local_date_string()),
                 }
-            },
+            }
         }
     } else {
         // 其他未知错误状态
@@ -579,9 +582,11 @@ async fn check_netflix_cdn(client: &Client) -> UnlockItem {
     // Fast.com API URL
     let url = "https://api.fast.com/netflix/speedtest/v2?https=true&token=YXNkZmFzZGxmbnNkYWZoYXNkZmhrYWxm&urlCount=5";
 
-    let result = client.get(url)
+    let result = client
+        .get(url)
         .timeout(std::time::Duration::from_secs(30))
-        .send().await;
+        .send()
+        .await;
 
     match result {
         Ok(response) => {
@@ -602,7 +607,9 @@ async fn check_netflix_cdn(client: &Client) -> UnlockItem {
                     if let Some(targets) = data.get("targets").and_then(|t| t.as_array()) {
                         if !targets.is_empty() {
                             if let Some(location) = targets[0].get("location") {
-                                if let Some(country) = location.get("country").and_then(|c| c.as_str()) {
+                                if let Some(country) =
+                                    location.get("country").and_then(|c| c.as_str())
+                                {
                                     let emoji = country_code_to_emoji(country);
                                     return UnlockItem {
                                         name: "Netflix".to_string(),
@@ -616,12 +623,12 @@ async fn check_netflix_cdn(client: &Client) -> UnlockItem {
                     }
 
                     // 如果无法解析区域信息
-                    return UnlockItem {
+                    UnlockItem {
                         name: "Netflix".to_string(),
                         status: "Unknown".to_string(),
                         region: None,
                         check_time: Some(get_local_date_string()),
-                    };
+                    }
                 }
                 Err(e) => {
                     eprintln!("解析Fast.com API响应失败: {}", e);

src-tauri/src/cmd/mod.rs

@@ -6,31 +6,33 @@ pub type CmdResult<T = ()> = Result<T, String>;
 // Command modules
 pub mod app;
 pub mod clash;
+pub mod lightweight;
 pub mod media_unlock_checker;
 pub mod network;
 pub mod profile;
 pub mod proxy;
 pub mod runtime;
 pub mod save_profile;
+pub mod service;
 pub mod system;
 pub mod uwp;
 pub mod validate;
 pub mod verge;
 pub mod webdav;
-pub mod lighteweight;
 
 // Re-export all command functions for backwards compatibility
 pub use app::*;
 pub use clash::*;
+pub use lightweight::*;
 pub use media_unlock_checker::*;
 pub use network::*;
 pub use profile::*;
 pub use proxy::*;
 pub use runtime::*;
 pub use save_profile::*;
+pub use service::*;
 pub use system::*;
 pub use uwp::*;
 pub use validate::*;
 pub use verge::*;
 pub use webdav::*;
-pub use lighteweight::*;

src-tauri/src/cmd/profile.rs

@@ -1,40 +1,25 @@
 use super::CmdResult;
 use crate::{
-    config::*,
-    core::*,
-    feat, log_err, ret_err,
-    utils::{dirs, help},
+    config::{Config, IProfiles, PrfItem, PrfOption},
+    core::{handle, tray::Tray, CoreManager},
+    feat, logging, ret_err,
+    utils::{dirs, help, logging::Type},
     wrap_err,
 };
 
 /// 获取配置文件列表
 #[tauri::command]
 pub fn get_profiles() -> CmdResult<IProfiles> {
-    let _ = tray::Tray::global().update_menu();
+    let _ = 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(())
-        }
-    }
+    wrap_err!(feat::enhance_profiles().await)?;
+    handle::Handle::refresh_clash();
+    Ok(())
 }
 
 /// 导入配置文件
@@ -77,33 +62,113 @@ pub async fn delete_profile(index: String) -> CmdResult {
 /// 修改profiles的配置
 #[tauri::command]
 pub async fn patch_profiles_config(profiles: IProfiles) -> CmdResult<bool> {
-    println!("[cmd配置patch] 开始修改配置文件");
+    logging!(info, Type::Cmd, true, "开始修改配置文件");
 
     // 保存当前配置，以便在验证失败时恢复
     let current_profile = Config::profiles().latest().current.clone();
-    println!("[cmd配置patch] 当前配置: {:?}", current_profile);
+    logging!(info, Type::Cmd, true, "当前配置: {:?}", current_profile);
+
+    // 如果要切换配置，先检查目标配置文件是否有语法错误
+    if let Some(new_profile) = profiles.current.as_ref() {
+        if current_profile.as_ref() != Some(new_profile) {
+            logging!(info, Type::Cmd, true, "正在切换到新配置: {}", new_profile);
+
+            // 获取目标配置文件路径
+            let profiles_config = Config::profiles();
+            let profiles_data = profiles_config.latest();
+            let config_file_result = match profiles_data.get_item(new_profile) {
+                Ok(item) => {
+                    if let Some(file) = &item.file {
+                        let path = dirs::app_profiles_dir().map(|dir| dir.join(file));
+                        path.ok()
+                    } else {
+                        None
+                    }
+                }
+                Err(e) => {
+                    logging!(error, Type::Cmd, true, "获取目标配置信息失败: {}", e);
+                    None
+                }
+            };
+
+            // 如果获取到文件路径，检查YAML语法
+            if let Some(file_path) = config_file_result {
+                if !file_path.exists() {
+                    logging!(
+                        error,
+                        Type::Cmd,
+                        true,
+                        "目标配置文件不存在: {}",
+                        file_path.display()
+                    );
+                    handle::Handle::notice_message(
+                        "config_validate::file_not_found",
+                        format!("{}", file_path.display()),
+                    );
+                    return Ok(false);
+                }
+
+                match std::fs::read_to_string(&file_path) {
+                    Ok(content) => match serde_yaml::from_str::<serde_yaml::Value>(&content) {
+                        Ok(_) => {
+                            logging!(info, Type::Cmd, true, "目标配置文件语法正确");
+                        }
+                        Err(err) => {
+                            let error_msg = format!(" {}", err);
+                            logging!(
+                                error,
+                                Type::Cmd,
+                                true,
+                                "目标配置文件存在YAML语法错误:{}",
+                                error_msg
+                            );
+                            handle::Handle::notice_message(
+                                "config_validate::yaml_syntax_error",
+                                &error_msg,
+                            );
+                            return Ok(false);
+                        }
+                    },
+                    Err(err) => {
+                        let error_msg = format!("无法读取目标配置文件: {}", err);
+                        logging!(error, Type::Cmd, true, "{}", error_msg);
+                        handle::Handle::notice_message(
+                            "config_validate::file_read_error",
+                            &error_msg,
+                        );
+                        return Ok(false);
+                    }
+                }
+            }
+        }
+    }
 
     // 更新profiles配置
-    println!("[cmd配置patch] 正在更新配置草稿");
-    wrap_err!({ Config::profiles().draft().patch_config(profiles) })?;
+    logging!(info, Type::Cmd, true, "正在更新配置草稿");
+    let _ = Config::profiles().draft().patch_config(profiles);
 
     // 更新配置并进行验证
     match CoreManager::global().update_config().await {
         Ok((true, _)) => {
-            println!("[cmd配置patch] 配置更新成功");
+            logging!(info, Type::Cmd, true, "配置更新成功");
             handle::Handle::refresh_clash();
-            let _ = tray::Tray::global().update_tooltip();
+            let _ = 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);
+            logging!(warn, Type::Cmd, true, "配置验证失败: {}", error_msg);
             Config::profiles().discard();
-
             // 如果验证失败，恢复到之前的配置
             if let Some(prev_profile) = current_profile {
-                println!("[cmd配置patch] 尝试恢复到之前的配置: {}", prev_profile);
+                logging!(
+                    info,
+                    Type::Cmd,
+                    true,
+                    "尝试恢复到之前的配置: {}",
+                    prev_profile
+                );
                 let restore_profiles = IProfiles {
                     current: Some(prev_profile),
                     items: None,
@@ -112,7 +177,7 @@ pub async fn patch_profiles_config(profiles: IProfiles) -> CmdResult<bool> {
                 wrap_err!({ Config::profiles().draft().patch_config(restore_profiles) })?;
                 Config::profiles().apply();
                 wrap_err!(Config::profiles().data().save_file())?;
-                println!("[cmd配置patch] 成功恢复到之前的配置");
+                logging!(info, Type::Cmd, true, "成功恢复到之前的配置");
             }
 
             // 发送验证错误通知
@@ -120,7 +185,7 @@ pub async fn patch_profiles_config(profiles: IProfiles) -> CmdResult<bool> {
             Ok(false)
         }
         Err(e) => {
-            println!("[cmd配置patch] 更新过程发生错误: {}", e);
+            logging!(warn, Type::Cmd, true, "更新过程发生错误: {}", e);
             Config::profiles().discard();
             handle::Handle::notice_message("config_validate::boot_error", e.to_string());
             Ok(false)
@@ -134,6 +199,8 @@ pub async fn patch_profiles_config_by_profile_index(
     _app_handle: tauri::AppHandle,
     profile_index: String,
 ) -> CmdResult<bool> {
+    logging!(info, Type::Cmd, true, "切换配置到: {}", profile_index);
+
     let profiles = IProfiles {
         current: Some(profile_index),
         items: None,

src-tauri/src/cmd/proxy.rs

@@ -4,21 +4,21 @@ use crate::module::mihomo::MihomoManager;
 #[tauri::command]
 pub async fn get_proxies() -> CmdResult<serde_json::Value> {
     let mannager = MihomoManager::global();
-    let proxies = mannager
+
+    mannager
         .refresh_proxies()
         .await
         .map(|_| mannager.get_proxies())
-        .or_else(|_| Ok(mannager.get_proxies()));
-    proxies
+        .or_else(|_| Ok(mannager.get_proxies()))
 }
 
 #[tauri::command]
 pub async fn get_providers_proxies() -> CmdResult<serde_json::Value> {
     let mannager = MihomoManager::global();
-    let providers = mannager
+
+    mannager
         .refresh_providers_proxies()
         .await
         .map(|_| mannager.get_providers_proxies())
-        .or_else(|_| Ok(mannager.get_providers_proxies()));
-    providers
+        .or_else(|_| Ok(mannager.get_providers_proxies()))
 }

src-tauri/src/cmd/service.rs

@@ -0,0 +1,40 @@
+use super::CmdResult;
+use crate::{
+    core::{service, CoreManager},
+    utils::i18n::t,
+};
+
+async fn execute_service_operation(
+    service_op: impl std::future::Future<Output = Result<(), impl ToString + std::fmt::Debug>>,
+    op_type: &str,
+) -> CmdResult {
+    if service_op.await.is_err() {
+        let emsg = format!("{} {} failed", op_type, "Service");
+        return Err(t(emsg.as_str()));
+    }
+    if CoreManager::global().restart_core().await.is_err() {
+        let emsg = format!("{} {} failed", "Restart", "Core");
+        return Err(t(emsg.as_str()));
+    }
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn install_service() -> CmdResult {
+    execute_service_operation(service::install_service(), "Install").await
+}
+
+#[tauri::command]
+pub async fn uninstall_service() -> CmdResult {
+    execute_service_operation(service::uninstall_service(), "Uninstall").await
+}
+
+#[tauri::command]
+pub async fn reinstall_service() -> CmdResult {
+    execute_service_operation(service::reinstall_service(), "Reinstall").await
+}
+
+#[tauri::command]
+pub async fn repair_service() -> CmdResult {
+    execute_service_operation(service::force_reinstall_service(), "Repair").await
+}

src-tauri/src/cmd/system.rs

@@ -1,8 +1,7 @@
 use super::CmdResult;
 use crate::{
-    core::{self, handle, service, CoreManager},
+    core::{handle, CoreManager},
     module::sysinfo::PlatformSpecification,
-    wrap_err,
 };
 use once_cell::sync::Lazy;
 use std::{
@@ -24,7 +23,7 @@ static APP_START_TIME: Lazy<AtomicI64> = Lazy::new(|| {
 
 #[tauri::command]
 pub async fn export_diagnostic_info() -> CmdResult<()> {
-    let sysinfo = PlatformSpecification::new();
+    let sysinfo = PlatformSpecification::new_async().await;
     let info = format!("{:?}", sysinfo);
 
     let app_handle = handle::Handle::global().app_handle().unwrap();
@@ -37,7 +36,7 @@ pub async fn export_diagnostic_info() -> CmdResult<()> {
 
 #[tauri::command]
 pub async fn get_system_info() -> CmdResult<String> {
-    let sysinfo = PlatformSpecification::new();
+    let sysinfo = PlatformSpecification::new_async().await;
     let info = format!("{:?}", sysinfo);
     Ok(info)
 }
@@ -45,17 +44,7 @@ pub async fn get_system_info() -> CmdResult<String> {
 /// 获取当前内核运行模式
 #[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)
+    Ok(CoreManager::global().get_running_mode().await.to_string())
 }
 
 /// 获取应用的运行时间（毫秒）
@@ -69,3 +58,37 @@ pub fn get_app_uptime() -> CmdResult<i64> {
 
     Ok(now - start_time)
 }
+
+/// 检查应用是否以管理员身份运行
+#[tauri::command]
+#[cfg(target_os = "windows")]
+pub fn is_admin() -> CmdResult<bool> {
+    use deelevate::{PrivilegeLevel, Token};
+
+    let result = Token::with_current_process()
+        .and_then(|token| token.privilege_level())
+        .map(|level| level != PrivilegeLevel::NotPrivileged)
+        .unwrap_or(false);
+
+    Ok(result)
+}
+
+/// 非Windows平台检测是否以管理员身份运行
+#[tauri::command]
+#[cfg(not(target_os = "windows"))]
+pub fn is_admin() -> CmdResult<bool> {
+    #[cfg(target_os = "macos")]
+    {
+        Ok(unsafe { libc::geteuid() } == 0)
+    }
+
+    #[cfg(target_os = "linux")]
+    {
+        Ok(unsafe { libc::geteuid() } == 0)
+    }
+
+    #[cfg(not(any(target_os = "macos", target_os = "linux")))]
+    {
+        Ok(false)
+    }
+}

src-tauri/src/config/config.rs

@@ -2,8 +2,8 @@ use super::{Draft, IClashTemp, IProfiles, IRuntime, IVerge};
 use crate::{
     config::PrfItem,
     core::{handle, CoreManager},
-    enhance,
-    utils::{dirs, help},
+    enhance, logging,
+    utils::{dirs, help, logging::Type},
 };
 use anyhow::{anyhow, Result};
 use once_cell::sync::OnceCell;
@@ -66,21 +66,27 @@ impl Config {
             let script_item = PrfItem::from_script(Some("Script".to_string()))?;
             Self::profiles().data().append_item(script_item.clone())?;
         }
-
         // 生成运行时配置
-        crate::log_err!(Self::generate().await);
+        if let Err(err) = Self::generate().await {
+            logging!(error, Type::Config, true, "生成运行时配置失败: {}", err);
+        } else {
+            logging!(info, Type::Config, true, "生成运行时配置成功");
+        }
 
         // 生成运行时配置文件并验证
         let config_result = Self::generate_file(ConfigType::Run);
 
         let validation_result = if config_result.is_ok() {
             // 验证配置文件
-            println!("[首次启动] 开始验证配置");
+            logging!(info, Type::Config, true, "开始验证配置");
 
             match CoreManager::global().validate_config().await {
                 Ok((is_valid, error_msg)) => {
                     if !is_valid {
-                        println!(
+                        logging!(
+                            warn,
+                            Type::Config,
+                            true,
                             "[首次启动] 配置验证失败，使用默认最小配置启动: {}",
                             error_msg
                         );
@@ -89,12 +95,12 @@ impl Config {
                             .await?;
                         Some(("config_validate::boot_error", error_msg))
                     } else {
-                        println!("[首次启动] 配置验证成功");
+                        logging!(info, Type::Config, true, "配置验证成功");
                         Some(("config_validate::success", String::new()))
                     }
                 }
                 Err(err) => {
-                    println!("[首次启动] 验证进程执行失败: {}", err);
+                    logging!(warn, Type::Config, true, "验证进程执行失败: {}", err);
                     CoreManager::global()
                         .use_default_config("config_validate::process_terminated", "")
                         .await?;
@@ -102,7 +108,7 @@ impl Config {
                 }
             }
         } else {
-            println!("[首次启动] 生成配置文件失败，使用默认配置");
+            logging!(warn, Type::Config, true, "生成配置文件失败，使用默认配置");
             CoreManager::global()
                 .use_default_config("config_validate::error", "")
                 .await?;

src-tauri/src/config/verge.rs

@@ -189,11 +189,16 @@ pub struct IVerge {
 
     pub enable_tray_speed: Option<bool>,
 
+    pub enable_tray_icon: Option<bool>,
+
     /// 自动进入轻量模式
     pub enable_auto_light_weight_mode: Option<bool>,
 
     /// 自动进入轻量模式的延迟（分钟）
     pub auto_light_weight_minutes: Option<u64>,
+
+    /// 服务状态跟踪
+    pub service_state: Option<crate::core::service::ServiceState>,
 }
 
 #[derive(Default, Debug, Clone, Deserialize, Serialize)]
@@ -295,11 +300,13 @@ impl IVerge {
             webdav_username: None,
             webdav_password: None,
             enable_tray_speed: Some(true),
+            enable_tray_icon: Some(true),
             enable_global_hotkey: Some(true),
             enable_auto_light_weight_mode: Some(false),
             auto_light_weight_minutes: Some(10),
             enable_dns_settings: Some(true),
             home_cards: None,
+            service_state: None,
             ..Self::default()
         }
     }
@@ -381,10 +388,12 @@ impl IVerge {
         patch!(webdav_username);
         patch!(webdav_password);
         patch!(enable_tray_speed);
+        patch!(enable_tray_icon);
         patch!(enable_auto_light_weight_mode);
         patch!(auto_light_weight_minutes);
         patch!(enable_dns_settings);
         patch!(home_cards);
+        patch!(service_state);
     }
 
     /// 在初始化前尝试拿到单例端口的值
@@ -473,10 +482,12 @@ pub struct IVergeResponse {
     pub webdav_username: Option<String>,
     pub webdav_password: Option<String>,
     pub enable_tray_speed: Option<bool>,
+    pub enable_tray_icon: Option<bool>,
     pub enable_auto_light_weight_mode: Option<bool>,
     pub auto_light_weight_minutes: Option<u64>,
     pub enable_dns_settings: Option<bool>,
     pub home_cards: Option<serde_json::Value>,
+    pub service_state: Option<crate::core::service::ServiceState>,
 }
 
 impl From<IVerge> for IVergeResponse {
@@ -539,10 +550,12 @@ impl From<IVerge> for IVergeResponse {
             webdav_username: verge.webdav_username,
             webdav_password: verge.webdav_password,
             enable_tray_speed: verge.enable_tray_speed,
+            enable_tray_icon: verge.enable_tray_icon,
             enable_auto_light_weight_mode: verge.enable_auto_light_weight_mode,
             auto_light_weight_minutes: verge.auto_light_weight_minutes,
             enable_dns_settings: verge.enable_dns_settings,
             home_cards: verge.home_cards,
+            service_state: verge.service_state,
         }
     }
 }

src-tauri/src/core/handle.rs

@@ -1,15 +1,24 @@
-use crate::log_err;
 use once_cell::sync::OnceCell;
 use parking_lot::RwLock;
-use std::sync::Arc;
+use std::{sync::Arc, time::Duration};
 use tauri::{AppHandle, Emitter, Manager, WebviewWindow};
-use tauri_plugin_shell::process::CommandChild;
+
+use crate::{logging, logging_error, utils::logging::Type};
+
+/// 存储启动期间的错误消息
+#[derive(Debug, Clone)]
+struct ErrorMessage {
+    status: String,
+    message: String,
+}
 
 #[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>>>,
+    /// 存储启动过程中产生的错误消息队列
+    startup_errors: Arc<RwLock<Vec<ErrorMessage>>>,
+    startup_completed: Arc<RwLock<bool>>,
 }
 
 impl Handle {
@@ -19,7 +28,8 @@ impl Handle {
         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)),
+            startup_errors: Arc::new(RwLock::new(Vec::new())),
+            startup_completed: Arc::new(RwLock::new(false)),
         })
     }
 
@@ -43,26 +53,115 @@ impl Handle {
 
     pub fn refresh_clash() {
         if let Some(window) = Self::global().get_window() {
-            log_err!(window.emit("verge://refresh-clash-config", "yes"));
+            logging_error!(
+                Type::Frontend,
+                true,
+                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"));
+            logging_error!(
+                Type::Frontend,
+                true,
+                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"));
+            logging_error!(
+                Type::Frontend,
+                true,
+                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())));
+        let handle = Self::global();
+        let status_str = status.into();
+        let msg_str = msg.into();
+
+        // 检查是否正在启动过程中
+        if !*handle.startup_completed.read() {
+            logging!(
+                info,
+                Type::Frontend,
+                true,
+                "启动过程中发现错误，加入消息队列: {} - {}",
+                status_str,
+                msg_str
+            );
+
+            // 将消息添加到启动错误队列
+            let mut errors = handle.startup_errors.write();
+            errors.push(ErrorMessage {
+                status: status_str,
+                message: msg_str,
+            });
+            return;
+        }
+
+        // 已经完成启动，直接发送消息
+        if let Some(window) = handle.get_window() {
+            logging_error!(
+                Type::Frontend,
+                true,
+                window.emit("verge://notice-message", (status_str, msg_str))
+            );
+        }
+    }
+
+    /// 标记启动已完成，并发送所有启动阶段累积的错误消息
+    pub fn mark_startup_completed(&self) {
+        {
+            let mut completed = self.startup_completed.write();
+            *completed = true;
+        }
+
+        self.send_startup_errors();
+    }
+
+    /// 发送启动时累积的所有错误消息
+    fn send_startup_errors(&self) {
+        let errors = {
+            let mut errors = self.startup_errors.write();
+            std::mem::take(&mut *errors)
+        };
+
+        if errors.is_empty() {
+            return;
+        }
+
+        logging!(
+            info,
+            Type::Frontend,
+            true,
+            "发送{}条启动时累积的错误消息",
+            errors.len()
+        );
+
+        // 等待2秒以确保前端已完全加载，延迟发送错误通知
+        if let Some(window) = self.get_window() {
+            let window_clone = window.clone();
+            let errors_clone = errors.clone();
+
+            tauri::async_runtime::spawn(async move {
+                tokio::time::sleep(Duration::from_secs(2)).await;
+
+                for error in errors_clone {
+                    let _ =
+                        window_clone.emit("verge://notice-message", (error.status, error.message));
+                    // 每条消息之间间隔500ms，避免消息堆积
+                    tokio::time::sleep(Duration::from_millis(500)).await;
+                }
+            });
         }
     }
 
@@ -71,21 +170,6 @@ impl Handle {
         *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()
     }

src-tauri/src/core/hotkey.rs

@@ -1,4 +1,10 @@
-use crate::{config::Config, core::handle, feat, log_err, utils::resolve};
+use crate::{
+    config::Config,
+    core::handle,
+    feat, logging, logging_error,
+    module::lightweight::entry_lightweight_mode,
+    utils::{logging::Type, resolve},
+};
 use anyhow::{bail, Result};
 use once_cell::sync::OnceCell;
 use parking_lot::Mutex;
@@ -23,22 +29,27 @@ impl Hotkey {
         let verge = Config::verge();
         let enable_global_hotkey = verge.latest().enable_global_hotkey.unwrap_or(true);
 
-        println!(
-            "Initializing hotkeys, global hotkey enabled: {}",
+        logging!(
+            debug,
+            Type::Hotkey,
+            true,
+            "Initializing hotkeys with enable: {}",
             enable_global_hotkey
         );
-        log::info!(target: "app", "Initializing hotkeys, global hotkey enabled: {}", enable_global_hotkey);
 
         // 如果全局热键被禁用，则不注册热键
         if !enable_global_hotkey {
-            println!("Global hotkey is disabled, skipping registration");
-            log::info!(target: "app", "Global hotkey is disabled, skipping registration");
             return Ok(());
         }
 
         if let Some(hotkeys) = verge.latest().hotkeys.as_ref() {
-            println!("Found {} hotkeys to register", hotkeys.len());
-            log::info!(target: "app", "Found {} hotkeys to register", hotkeys.len());
+            logging!(
+                debug,
+                Type::Hotkey,
+                true,
+                "Has {} hotkeys need to register",
+                hotkeys.len()
+            );
 
             for hotkey in hotkeys.iter() {
                 let mut iter = hotkey.split(',');
@@ -47,28 +58,52 @@ impl Hotkey {
 
                 match (key, func) {
                     (Some(key), Some(func)) => {
-                        println!("Registering hotkey: {} -> {}", key, func);
-                        log::info!(target: "app", "Registering hotkey: {} -> {}", key, func);
+                        logging!(
+                            debug,
+                            Type::Hotkey,
+                            true,
+                            "Registering hotkey: {} -> {}",
+                            key,
+                            func
+                        );
                         if let Err(e) = self.register(key, func) {
-                            println!("Failed to register hotkey {} -> {}: {:?}", key, func, e);
-                            log::error!(target: "app", "Failed to register hotkey {} -> {}: {:?}", key, func, e);
+                            logging!(
+                                error,
+                                Type::Hotkey,
+                                true,
+                                "Failed to register hotkey {} -> {}: {:?}",
+                                key,
+                                func,
+                                e
+                            );
                         } else {
-                            println!("Successfully registered hotkey {} -> {}", key, func);
-                            log::info!(target: "app", "Successfully registered hotkey {} -> {}", key, func);
+                            logging!(
+                                debug,
+                                Type::Hotkey,
+                                true,
+                                "Successfully registered hotkey {} -> {}",
+                                key,
+                                func
+                            );
                         }
                     }
                     _ => {
                         let key = key.unwrap_or("None");
                         let func = func.unwrap_or("None");
-                        println!("Invalid hotkey configuration: `{key}`:`{func}`");
-                        log::error!(target: "app", "Invalid hotkey configuration: `{key}`:`{func}`");
+                        logging!(
+                            error,
+                            Type::Hotkey,
+                            true,
+                            "Invalid hotkey configuration: `{}`:`{}`",
+                            key,
+                            func
+                        );
                     }
                 }
             }
             self.current.lock().clone_from(hotkeys);
         } else {
-            println!("No hotkeys configured");
-            log::info!(target: "app", "No hotkeys configured");
+            logging!(debug, Type::Hotkey, true, "No hotkeys configured");
         }
 
         Ok(())
@@ -85,45 +120,60 @@ impl Hotkey {
         let app_handle = handle::Handle::global().app_handle().unwrap();
         let manager = app_handle.global_shortcut();
 
-        println!(
+        logging!(
+            debug,
+            Type::Hotkey,
+            true,
             "Attempting to register hotkey: {} for function: {}",
-            hotkey, func
+            hotkey,
+            func
         );
-        log::info!(target: "app", "Attempting to register hotkey: {} for function: {}", hotkey, func);
 
         if manager.is_registered(hotkey) {
-            println!(
+            logging!(
+                debug,
+                Type::Hotkey,
+                true,
                 "Hotkey {} was already registered, unregistering first",
                 hotkey
             );
-            log::info!(target: "app", "Hotkey {} was already registered, unregistering first", hotkey);
             manager.unregister(hotkey)?;
         }
 
         let f = match func.trim() {
             "open_or_close_dashboard" => {
-                println!("Registering open_or_close_dashboard function");
-                log::info!(target: "app", "Registering open_or_close_dashboard function");
+                logging!(
+                    debug,
+                    Type::Hotkey,
+                    true,
+                    "Registering open_or_close_dashboard function"
+                );
                 || {
-                    println!("=== Hotkey Dashboard Window Operation Start ===");
-                    log::info!(target: "app", "=== Hotkey Dashboard Window Operation Start ===");
+                    logging!(
+                        debug,
+                        Type::Hotkey,
+                        true,
+                        "=== Hotkey Dashboard Window Operation Start ==="
+                    );
 
                     // 使用 spawn_blocking 来确保在正确的线程上执行
                     async_runtime::spawn_blocking(|| {
-                        println!("Toggle dashboard window visibility");
-                        log::info!(target: "app", "Toggle dashboard window visibility");
+                        logging!(
+                            debug,
+                            Type::Hotkey,
+                            true,
+                            "Toggle dashboard window visibility"
+                        );
 
                         // 检查窗口是否存在
                         if let Some(window) = handle::Handle::global().get_window() {
                             // 如果窗口可见，则隐藏它
                             if window.is_visible().unwrap_or(false) {
-                                println!("Window is visible, hiding it");
-                                log::info!(target: "app", "Window is visible, hiding it");
+                                logging!(info, Type::Window, true, "Window is visible, hiding it");
                                 let _ = window.hide();
                             } else {
                                 // 如果窗口不可见，则显示它
-                                println!("Window is hidden, showing it");
-                                log::info!(target: "app", "Window is hidden, showing it");
+                                logging!(info, Type::Window, true, "Window is hidden, showing it");
                                 if window.is_minimized().unwrap_or(false) {
                                     let _ = window.unminimize();
                                 }
@@ -132,14 +182,22 @@ impl Hotkey {
                             }
                         } else {
                             // 如果窗口不存在，创建一个新窗口
-                            println!("Window does not exist, creating a new one");
-                            log::info!(target: "app", "Window does not exist, creating a new one");
-                            resolve::create_window();
+                            logging!(
+                                info,
+                                Type::Window,
+                                true,
+                                "Window does not exist, creating a new one"
+                            );
+                            resolve::create_window(true);
                         }
                     });
 
-                    println!("=== Hotkey Dashboard Window Operation End ===");
-                    log::info!(target: "app", "=== Hotkey Dashboard Window Operation End ===");
+                    logging!(
+                        debug,
+                        Type::Hotkey,
+                        true,
+                        "=== Hotkey Dashboard Window Operation End ==="
+                    );
                 }
             }
             "clash_mode_rule" => || feat::change_clash_mode("rule".into()),
@@ -147,13 +205,13 @@ impl Hotkey {
             "clash_mode_direct" => || feat::change_clash_mode("direct".into()),
             "toggle_system_proxy" => || feat::toggle_system_proxy(),
             "toggle_tun_mode" => || feat::toggle_tun_mode(None),
+            "entry_lightweight_mode" => || entry_lightweight_mode(),
             "quit" => || feat::quit(Some(0)),
             #[cfg(target_os = "macos")]
             "hide" => || feat::hide(),
 
             _ => {
-                println!("Invalid function: {}", func);
-                log::error!(target: "app", "Invalid function: {}", func);
+                logging!(error, Type::Hotkey, true, "Invalid function: {}", func);
                 bail!("invalid function \"{func}\"");
             }
         };
@@ -162,21 +220,18 @@ impl Hotkey {
 
         let _ = manager.on_shortcut(hotkey, move |app_handle, hotkey, event| {
             if event.state == ShortcutState::Pressed {
-                println!("Hotkey pressed: {:?}", hotkey);
-                log::info!(target: "app", "Hotkey pressed: {:?}", hotkey);
+                logging!(debug, Type::Hotkey, true, "Hotkey pressed: {:?}", hotkey);
 
                 if hotkey.key == Code::KeyQ && is_quit {
                     if let Some(window) = app_handle.get_webview_window("main") {
                         if window.is_focused().unwrap_or(false) {
-                            println!("Executing quit function");
-                            log::info!(target: "app", "Executing quit function");
+                            logging!(debug, Type::Hotkey, true, "Executing quit function");
                             f();
                         }
                     }
                 } else {
                     // 直接执行函数，不做任何状态检查
-                    println!("Executing function directly");
-                    log::info!(target: "app", "Executing function directly");
+                    logging!(debug, Type::Hotkey, true, "Executing function directly");
 
                     // 获取全局热键状态
                     let is_enable_global_hotkey = Config::verge()
@@ -199,8 +254,14 @@ impl Hotkey {
             }
         });
 
-        println!("Successfully registered hotkey {} for {}", hotkey, func);
-        log::info!(target: "app", "Successfully registered hotkey {} for {}", hotkey, func);
+        logging!(
+            debug,
+            Type::Hotkey,
+            true,
+            "Successfully registered hotkey {} for {}",
+            hotkey,
+            func
+        );
         Ok(())
     }
 
@@ -208,7 +269,7 @@ impl Hotkey {
         let app_handle = handle::Handle::global().app_handle().unwrap();
         let manager = app_handle.global_shortcut();
         manager.unregister(hotkey)?;
-        log::debug!(target: "app", "unregister hotkey {hotkey}");
+        logging!(debug, Type::Hotkey, true, "Unregister hotkey {}", hotkey);
         Ok(())
     }
 
@@ -224,7 +285,7 @@ impl Hotkey {
         });
 
         add.iter().for_each(|(key, func)| {
-            log_err!(self.register(key, func));
+            logging_error!(Type::Hotkey, true, self.register(key, func));
         });
 
         *current = new_hotkeys;
@@ -281,7 +342,13 @@ impl Drop for Hotkey {
     fn drop(&mut self) {
         let app_handle = handle::Handle::global().app_handle().unwrap();
         if let Err(e) = app_handle.global_shortcut().unregister_all() {
-            log::error!(target:"app", "Error unregistering all hotkeys: {:?}", e);
+            logging!(
+                error,
+                Type::Hotkey,
+                true,
+                "Error unregistering all hotkeys: {:?}",
+                e
+            );
         }
     }
 }

src-tauri/src/core/service.rs

@@ -1,13 +1,95 @@
-use crate::{config::Config, utils::dirs};
+use crate::{
+    config::Config,
+    logging,
+    utils::{dirs, logging::Type},
+};
 use anyhow::{bail, Context, Result};
 use serde::{Deserialize, Serialize};
-use std::{collections::HashMap, env::current_exe, path::PathBuf, process::Command as StdCommand};
+use std::{
+    collections::HashMap,
+    env::current_exe,
+    path::PathBuf,
+    process::Command as StdCommand,
+    time::{SystemTime, UNIX_EPOCH},
+};
 use tokio::time::Duration;
 
 // Windows only
 
 const SERVICE_URL: &str = "http://127.0.0.1:33211";
-const REQUIRED_SERVICE_VERSION: &str = "1.0.2"; // 定义所需的服务版本号
+const REQUIRED_SERVICE_VERSION: &str = "1.0.5"; // 定义所需的服务版本号
+
+// 限制重装时间和次数的常量
+const REINSTALL_COOLDOWN_SECS: u64 = 300; // 5分钟冷却期
+const MAX_REINSTALLS_PER_DAY: u32 = 3; // 每24小时最多重装3次
+const ONE_DAY_SECS: u64 = 86400; // 24小时的秒数
+
+#[derive(Debug, Deserialize, Serialize, Clone, Default)]
+pub struct ServiceState {
+    pub last_install_time: u64,     // 上次安装时间戳 (Unix 时间戳，秒)
+    pub install_count: u32,         // 24小时内安装次数
+    pub last_check_time: u64,       // 上次检查时间
+    pub last_error: Option<String>, // 上次错误信息
+    pub prefer_sidecar: bool,       // 用户是否偏好sidecar模式，如拒绝安装服务或安装失败
+}
+
+impl ServiceState {
+    // 获取当前的服务状态
+    pub fn get() -> Self {
+        if let Some(state) = Config::verge().latest().service_state.clone() {
+            return state;
+        }
+        Self::default()
+    }
+
+    // 保存服务状态
+    pub fn save(&self) -> Result<()> {
+        let config = Config::verge();
+        let mut latest = config.latest().clone();
+        latest.service_state = Some(self.clone());
+        *config.draft() = latest;
+        config.apply();
+        Config::verge().latest().save_file()
+    }
+
+    // 更新安装信息
+    pub fn record_install(&mut self) {
+        let now = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_secs();
+
+        // 检查是否需要重置计数器（24小时已过）
+        if now - self.last_install_time > ONE_DAY_SECS {
+            self.install_count = 0;
+        }
+
+        self.last_install_time = now;
+        self.install_count += 1;
+    }
+
+    // 检查是否可以重新安装
+    pub fn can_reinstall(&self) -> bool {
+        let now = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_secs();
+
+        // 如果在冷却期内，不允许重装
+        if now - self.last_install_time < REINSTALL_COOLDOWN_SECS {
+            return false;
+        }
+
+        // 如果24小时内安装次数过多，也不允许
+        if now - self.last_install_time < ONE_DAY_SECS
+            && self.install_count >= MAX_REINSTALLS_PER_DAY
+        {
+            return false;
+        }
+
+        true
+    }
+}
 
 #[derive(Debug, Deserialize, Serialize, Clone)]
 pub struct ResponseBody {
@@ -38,34 +120,56 @@ pub struct VersionJsonResponse {
 }
 
 #[cfg(target_os = "windows")]
-pub async fn reinstall_service() -> Result<()> {
-    log::info!(target:"app", "reinstall service");
+pub async fn uninstall_service() -> Result<()> {
+    logging!(info, Type::Service, true, "uninstall service");
 
     use deelevate::{PrivilegeLevel, Token};
     use runas::Command as RunasCommand;
     use std::os::windows::process::CommandExt;
 
     let binary_path = dirs::service_path()?;
-    let install_path = binary_path.with_file_name("install-service.exe");
     let uninstall_path = binary_path.with_file_name("uninstall-service.exe");
 
-    if !install_path.exists() {
-        bail!(format!("installer not found: {install_path:?}"));
-    }
-
     if !uninstall_path.exists() {
         bail!(format!("uninstaller not found: {uninstall_path:?}"));
     }
 
     let token = Token::with_current_process()?;
     let level = token.privilege_level()?;
-    let _ = match level {
+    let status = match level {
         PrivilegeLevel::NotPrivileged => RunasCommand::new(uninstall_path).show(false).status()?,
         _ => StdCommand::new(uninstall_path)
             .creation_flags(0x08000000)
             .status()?,
     };
 
+    if !status.success() {
+        bail!(
+            "failed to uninstall service with status {}",
+            status.code().unwrap()
+        );
+    }
+
+    Ok(())
+}
+
+#[cfg(target_os = "windows")]
+pub async fn install_service() -> Result<()> {
+    logging!(info, Type::Service, true, "install service");
+
+    use deelevate::{PrivilegeLevel, Token};
+    use runas::Command as RunasCommand;
+    use std::os::windows::process::CommandExt;
+
+    let binary_path = dirs::service_path()?;
+    let install_path = binary_path.with_file_name("install-service.exe");
+
+    if !install_path.exists() {
+        bail!(format!("installer not found: {install_path:?}"));
+    }
+
+    let token = Token::with_current_process()?;
+    let level = token.privilege_level()?;
     let status = match level {
         PrivilegeLevel::NotPrivileged => RunasCommand::new(install_path).show(false).status()?,
         _ => StdCommand::new(install_path)
@@ -83,24 +187,64 @@ pub async fn reinstall_service() -> Result<()> {
     Ok(())
 }
 
-#[cfg(target_os = "linux")]
+#[cfg(target_os = "windows")]
 pub async fn reinstall_service() -> Result<()> {
-    log::info!(target:"app", "reinstall service");
+    logging!(info, Type::Service, true, "reinstall service");
+
+    // 获取当前服务状态
+    let mut service_state = ServiceState::get();
+
+    // 检查是否允许重装
+    if !service_state.can_reinstall() {
+        logging!(
+            warn,
+            Type::Service,
+            true,
+            "service reinstall rejected: cooldown period or max attempts reached"
+        );
+        bail!("Service reinstallation is rate limited. Please try again later.");
+    }
+
+    // 先卸载服务
+    if let Err(err) = uninstall_service().await {
+        logging!(
+            warn,
+            Type::Service,
+            true,
+            "failed to uninstall service: {}",
+            err
+        );
+    }
+
+    // 再安装服务
+    match install_service().await {
+        Ok(_) => {
+            // 记录安装信息并保存
+            service_state.record_install();
+            service_state.last_error = None;
+            service_state.save()?;
+            Ok(())
+        }
+        Err(err) => {
+            let error = format!("failed to install service: {}", err);
+            service_state.last_error = Some(error.clone());
+            service_state.save()?;
+            bail!(error)
+        }
+    }
+}
+
+#[cfg(target_os = "linux")]
+pub async fn uninstall_service() -> Result<()> {
+    logging!(info, Type::Service, true, "uninstall service");
     use users::get_effective_uid;
 
-    let install_path = tauri::utils::platform::current_exe()?.with_file_name("install-service");
-
     let uninstall_path = tauri::utils::platform::current_exe()?.with_file_name("uninstall-service");
 
-    if !install_path.exists() {
-        bail!(format!("installer not found: {install_path:?}"));
-    }
-
     if !uninstall_path.exists() {
         bail!(format!("uninstaller not found: {uninstall_path:?}"));
     }
 
-    let install_shell: String = install_path.to_string_lossy().replace(" ", "\\ ");
     let uninstall_shell: String = uninstall_path.to_string_lossy().replace(" ", "\\ ");
 
     let elevator = crate::utils::help::linux_elevator();
@@ -112,8 +256,38 @@ pub async fn reinstall_service() -> Result<()> {
             .arg(uninstall_shell)
             .status()?,
     };
-    log::info!(target:"app", "status code:{}", status.code().unwrap());
+    logging!(
+        info,
+        Type::Service,
+        true,
+        "uninstall status code:{}",
+        status.code().unwrap()
+    );
 
+    if !status.success() {
+        bail!(
+            "failed to uninstall service with status {}",
+            status.code().unwrap()
+        );
+    }
+
+    Ok(())
+}
+
+#[cfg(target_os = "linux")]
+pub async fn install_service() -> Result<()> {
+    logging!(info, Type::Service, true, "install service");
+    use users::get_effective_uid;
+
+    let install_path = tauri::utils::platform::current_exe()?.with_file_name("install-service");
+
+    if !install_path.exists() {
+        bail!(format!("installer not found: {install_path:?}"));
+    }
+
+    let install_shell: String = install_path.to_string_lossy().replace(" ", "\\ ");
+
+    let elevator = crate::utils::help::linux_elevator();
     let status = match get_effective_uid() {
         0 => StdCommand::new(install_shell).status()?,
         _ => StdCommand::new(elevator.clone())
@@ -122,6 +296,132 @@ pub async fn reinstall_service() -> Result<()> {
             .arg(install_shell)
             .status()?,
     };
+    logging!(
+        info,
+        Type::Service,
+        true,
+        "install status code:{}",
+        status.code().unwrap()
+    );
+
+    if !status.success() {
+        bail!(
+            "failed to install service with status {}",
+            status.code().unwrap()
+        );
+    }
+
+    Ok(())
+}
+
+#[cfg(target_os = "linux")]
+pub async fn reinstall_service() -> Result<()> {
+    logging!(info, Type::Service, true, "reinstall service");
+
+    // 获取当前服务状态
+    let mut service_state = ServiceState::get();
+
+    // 检查是否允许重装
+    if !service_state.can_reinstall() {
+        logging!(
+            warn,
+            Type::Service,
+            true,
+            "service reinstall rejected: cooldown period or max attempts reached"
+        );
+        bail!("Service reinstallation is rate limited. Please try again later.");
+    }
+
+    // 先卸载服务
+    if let Err(err) = uninstall_service().await {
+        logging!(
+            warn,
+            Type::Service,
+            true,
+            "failed to uninstall service: {}",
+            err
+        );
+    }
+
+    // 再安装服务
+    match install_service().await {
+        Ok(_) => {
+            // 记录安装信息并保存
+            service_state.record_install();
+            service_state.last_error = None;
+            service_state.save()?;
+            Ok(())
+        }
+        Err(err) => {
+            let error = format!("failed to install service: {}", err);
+            service_state.last_error = Some(error.clone());
+            service_state.save()?;
+            bail!(error)
+        }
+    }
+}
+
+#[cfg(target_os = "macos")]
+pub async fn uninstall_service() -> Result<()> {
+    use crate::utils::i18n::t;
+
+    logging!(info, Type::Service, true, "uninstall service");
+
+    let binary_path = dirs::service_path()?;
+    let uninstall_path = binary_path.with_file_name("uninstall-service");
+
+    if !uninstall_path.exists() {
+        bail!(format!("uninstaller not found: {uninstall_path:?}"));
+    }
+
+    let uninstall_shell: String = uninstall_path.to_string_lossy().into_owned();
+
+    let prompt = t("Service Administrator Prompt");
+    let command = format!(
+        r#"do shell script "sudo '{uninstall_shell}'" with administrator privileges with prompt "{prompt}""#
+    );
+
+    logging!(debug, Type::Service, true, "uninstall command: {}", command);
+
+    let status = StdCommand::new("osascript")
+        .args(vec!["-e", &command])
+        .status()?;
+
+    if !status.success() {
+        bail!(
+            "failed to uninstall service with status {}",
+            status.code().unwrap()
+        );
+    }
+
+    Ok(())
+}
+
+#[cfg(target_os = "macos")]
+pub async fn install_service() -> Result<()> {
+    use crate::utils::i18n::t;
+
+    logging!(info, Type::Service, true, "install service");
+
+    let binary_path = dirs::service_path()?;
+    let install_path = binary_path.with_file_name("install-service");
+
+    if !install_path.exists() {
+        bail!(format!("installer not found: {install_path:?}"));
+    }
+
+    let install_shell: String = install_path.to_string_lossy().into_owned();
+
+    let prompt = t("Service Administrator Prompt");
+    let command = format!(
+        r#"do shell script "sudo '{install_shell}'" with administrator privileges with prompt "{prompt}""#
+    );
+
+    logging!(debug, Type::Service, true, "install command: {}", command);
+
+    let status = StdCommand::new("osascript")
+        .args(vec!["-e", &command])
+        .status()?;
 
     if !status.success() {
         bail!(
@@ -135,54 +435,49 @@ pub async fn reinstall_service() -> Result<()> {
 
 #[cfg(target_os = "macos")]
 pub async fn reinstall_service() -> Result<()> {
-    log::info!(target:"app", "reinstall service");
+    logging!(info, Type::Service, true, "reinstall service");
 
-    let binary_path = dirs::service_path()?;
-    let install_path = binary_path.with_file_name("install-service");
-    let uninstall_path = binary_path.with_file_name("uninstall-service");
+    // 获取当前服务状态
+    let mut service_state = ServiceState::get();
 
-    if !install_path.exists() {
-        bail!(format!("installer not found: {install_path:?}"));
+    // 检查是否允许重装
+    if !service_state.can_reinstall() {
+        logging!(
+            warn,
+            Type::Service,
+            true,
+            "service reinstall rejected: cooldown period or max attempts reached"
+        );
+        bail!("Service reinstallation is rate limited. Please try again later.");
     }
 
-    if !uninstall_path.exists() {
-        bail!(format!("uninstaller not found: {uninstall_path:?}"));
-    }
-
-    let install_shell: String = install_path.to_string_lossy().into_owned();
-    let uninstall_shell: String = uninstall_path.to_string_lossy().into_owned();
-
-    // 获取提示文本，如果 i18n 失败则使用硬编码默认值
-    let prompt = crate::utils::i18n::t("Service Administrator Prompt");
-    let prompt = if prompt == "Service Administrator Prompt" {
-        if Config::verge().latest().language.as_deref() == Some("zh")
-            || Config::verge().latest().language.is_none()
-        {
-            "Clash Verge 需要使用管理员权限来重新安装系统服务"
-        } else {
-            "Clash Verge needs administrator privileges to reinstall the system service"
-        }
-    } else {
-        &prompt
-    };
-
-    let command = format!(
-        r#"do shell script "sudo '{uninstall_shell}' && sudo '{install_shell}'" with administrator privileges with prompt "{prompt}""#
-    );
-
-    log::debug!(target: "app", "command: {}", command);
-
-    let status = StdCommand::new("osascript")
-        .args(vec!["-e", &command])
-        .status()?;
-
-    if !status.success() {
-        bail!(
-            "failed to install service with status {}",
-            status.code().unwrap()
+    // 先卸载服务
+    if let Err(err) = uninstall_service().await {
+        logging!(
+            warn,
+            Type::Service,
+            true,
+            "failed to uninstall service: {}",
+            err
         );
     }
-    Ok(())
+
+    // 再安装服务
+    match install_service().await {
+        Ok(_) => {
+            // 记录安装信息并保存
+            service_state.record_install();
+            service_state.last_error = None;
+            service_state.save()?;
+            Ok(())
+        }
+        Err(err) => {
+            let error = format!("failed to install service: {}", err);
+            service_state.last_error = Some(error.clone());
+            service_state.save()?;
+            bail!(error)
+        }
+    }
 }
 
 /// check the windows service status
@@ -226,19 +521,54 @@ pub async fn check_service_version() -> Result<String> {
 
 /// check if service needs to be reinstalled
 pub async fn check_service_needs_reinstall() -> bool {
+    // 获取当前服务状态
+    let service_state = ServiceState::get();
+
+    // 首先检查是否在冷却期或超过重装次数限制
+    if !service_state.can_reinstall() {
+        log::info!(target: "app", "service reinstall check: in cooldown period or max attempts reached");
+        return false;
+    }
+
+    // 然后才检查版本和可用性
     match check_service_version().await {
-        Ok(version) => version != REQUIRED_SERVICE_VERSION,
-        Err(_) => true, // 如果无法获取版本或服务未运行，也需要重新安装
+        Ok(version) => {
+            // 打印更详细的日志，方便排查问题
+            log::info!(target: "app", "服务版本检测：当前={}, 要求={}", version, REQUIRED_SERVICE_VERSION);
+
+            let needs_reinstall = version != REQUIRED_SERVICE_VERSION;
+            if needs_reinstall {
+                log::warn!(target: "app", "发现服务版本不匹配，需要重装! 当前={}, 要求={}",
+                    version, REQUIRED_SERVICE_VERSION);
+
+                // 打印版本字符串的原始字节，确认没有隐藏字符
+                log::debug!(target: "app", "当前版本字节: {:?}", version.as_bytes());
+                log::debug!(target: "app", "要求版本字节: {:?}", REQUIRED_SERVICE_VERSION.as_bytes());
+            } else {
+                log::info!(target: "app", "服务版本匹配，无需重装");
+            }
+
+            needs_reinstall
+        }
+        Err(err) => {
+            // 检查服务是否可用，如果可用但版本检查失败，可能只是版本API有问题
+            match is_service_running().await {
+                Ok(true) => {
+                    log::info!(target: "app", "service is running but version check failed: {}", err);
+                    false // 服务在运行，不需要重装
+                }
+                _ => {
+                    log::info!(target: "app", "service is not running or unavailable");
+                    true // 服务不可用，需要重装
+                }
+            }
+        }
     }
 }
 
-/// start the clash by service
-pub(super) async fn run_core_by_service(config_file: &PathBuf) -> Result<()> {
-    // 检查服务版本，如果不匹配则重新安装
-    if check_service_needs_reinstall().await {
-        log::info!(target: "app", "service version mismatch, reinstalling");
-        reinstall_service().await?;
-    }
+/// 尝试使用现有服务启动核心，不进行重装
+pub(super) async fn start_with_existing_service(config_file: &PathBuf) -> Result<()> {
+    log::info!(target:"app", "attempting to start core with existing service");
 
     let clash_core = { Config::verge().latest().clash_core.clone() };
     let clash_core = clash_core.unwrap_or("verge-mihomo".into());
@@ -278,6 +608,106 @@ pub(super) async fn run_core_by_service(config_file: &PathBuf) -> Result<()> {
     Ok(())
 }
 
+/// start the clash by service
+pub(super) async fn run_core_by_service(config_file: &PathBuf) -> Result<()> {
+    log::info!(target: "app", "正在尝试通过服务启动核心");
+
+    // 先检查服务版本，不受冷却期限制
+    let version_check = match check_service_version().await {
+        Ok(version) => {
+            log::info!(target: "app", "检测到服务版本: {}, 要求版本: {}",
+                version, REQUIRED_SERVICE_VERSION);
+
+            // 通过字节比较确保完全匹配
+            if version.as_bytes() != REQUIRED_SERVICE_VERSION.as_bytes() {
+                log::warn!(target: "app", "服务版本不匹配，需要重装");
+                false // 版本不匹配
+            } else {
+                log::info!(target: "app", "服务版本匹配");
+                true // 版本匹配
+            }
+        }
+        Err(err) => {
+            log::warn!(target: "app", "无法获取服务版本: {}", err);
+            false // 无法获取版本
+        }
+    };
+
+    // 先尝试直接启动服务，如果服务可用且版本匹配
+    if version_check {
+        if let Ok(true) = is_service_running().await {
+            // 服务正在运行且版本匹配，直接使用
+            log::info!(target: "app", "服务已在运行且版本匹配，尝试使用");
+            return start_with_existing_service(config_file).await;
+        }
+    }
+
+    // 强制执行版本检查，如果版本不匹配则重装
+    if !version_check {
+        log::info!(target: "app", "服务版本不匹配，尝试重装");
+
+        // 获取服务状态，检查是否可以重装
+        let service_state = ServiceState::get();
+        if !service_state.can_reinstall() {
+            log::warn!(target: "app", "由于限制无法重装服务");
+            // 尝试直接启动，即使版本不匹配
+            if let Ok(()) = start_with_existing_service(config_file).await {
+                log::info!(target: "app", "尽管版本不匹配，但成功启动了服务");
+                return Ok(());
+            } else {
+                bail!("服务版本不匹配且无法重装，启动失败");
+            }
+        }
+
+        // 尝试重装
+        log::info!(target: "app", "开始重装服务");
+        if let Err(err) = reinstall_service().await {
+            log::warn!(target: "app", "服务重装失败: {}", err);
+
+            // 尝试使用现有服务
+            log::info!(target: "app", "尝试使用现有服务");
+            return start_with_existing_service(config_file).await;
+        }
+
+        // 重装成功，尝试启动
+        log::info!(target: "app", "服务重装成功，尝试启动");
+        return start_with_existing_service(config_file).await;
+    }
+
+    // 检查服务状态
+    match check_service().await {
+        Ok(_) => {
+            // 服务可访问但可能没有运行核心，尝试直接启动
+            log::info!(target: "app", "服务可用但未运行核心，尝试启动");
+            if let Ok(()) = start_with_existing_service(config_file).await {
+                return Ok(());
+            }
+        }
+        Err(err) => {
+            log::warn!(target: "app", "服务检查失败: {}", err);
+        }
+    }
+
+    // 服务不可用或启动失败，检查是否需要重装
+    if check_service_needs_reinstall().await {
+        log::info!(target: "app", "服务需要重装");
+
+        // 尝试重装
+        if let Err(err) = reinstall_service().await {
+            log::warn!(target: "app", "服务重装失败: {}", err);
+            bail!("Failed to reinstall service: {}", err);
+        }
+
+        // 重装后再次尝试启动
+        log::info!(target: "app", "服务重装完成，尝试启动核心");
+        start_with_existing_service(config_file).await
+    } else {
+        // 不需要或不能重装，返回错误
+        log::warn!(target: "app", "服务不可用且无法重装");
+        bail!("Service is not available and cannot be reinstalled at this time")
+    }
+}
+
 /// stop the clash by service
 pub(super) async fn stop_core_by_service() -> Result<()> {
     let url = format!("{SERVICE_URL}/stop_clash");
@@ -298,8 +728,41 @@ pub async fn is_service_running() -> Result<bool> {
 
     // 检查服务状态码和消息
     if resp.code == 0 && resp.msg == "ok" && resp.data.is_some() {
+        logging!(debug, Type::Service, "Service is running");
         Ok(true)
     } else {
+        logging!(debug, Type::Service, "Service is not running");
         Ok(false)
     }
 }
+
+pub async fn is_service_available() -> Result<()> {
+    let resp = check_service().await?;
+    if resp.code == 0 && resp.msg == "ok" && resp.data.is_some() {
+        logging!(debug, Type::Service, "Service is available");
+    }
+    Ok(())
+}
+
+/// 强制重装服务（用于UI中的修复服务按钮）
+pub async fn force_reinstall_service() -> Result<()> {
+    log::info!(target: "app", "用户请求强制重装服务");
+
+    // 创建默认服务状态（重置所有限制）
+    let service_state = ServiceState::default();
+    service_state.save()?;
+
+    log::info!(target: "app", "已重置服务状态，开始执行重装");
+
+    // 执行重装
+    match reinstall_service().await {
+        Ok(()) => {
+            log::info!(target: "app", "服务重装成功");
+            Ok(())
+        }
+        Err(err) => {
+            log::error!(target: "app", "强制重装服务失败: {}", err);
+            bail!("强制重装服务失败: {}", err)
+        }
+    }
+}

src-tauri/src/core/sysopt.rs

@@ -1,7 +1,8 @@
 use crate::{
     config::{Config, IVerge},
     core::handle::Handle,
-    log_err,
+    logging_error,
+    utils::logging::Type,
 };
 use anyhow::Result;
 use once_cell::sync::OnceCell;
@@ -231,8 +232,8 @@ impl Sysopt {
                 } else {
                     log::info!(target: "app", "Auto launch enabled successfully");
                 }
-                log_err!(result)
-            },
+                logging_error!(Type::System, true, result);
+            }
             false => {
                 let result = autostart_manager.disable();
                 if let Err(ref e) = result {
@@ -240,8 +241,8 @@ impl Sysopt {
                 } else {
                     log::info!(target: "app", "Auto launch disabled successfully");
                 }
-                log_err!(result)
-            },
+                logging_error!(Type::System, true, result);
+            }
         };
 
         Ok(())
@@ -256,7 +257,7 @@ impl Sysopt {
             Ok(status) => {
                 log::info!(target: "app", "Auto launch status: {}", status);
                 Ok(status)
-            },
+            }
             Err(e) => {
                 log::error!(target: "app", "Failed to get auto launch status: {}", e);
                 Err(anyhow::anyhow!("Failed to get auto launch status: {}", e))
@@ -323,7 +324,7 @@ impl Sysopt {
                             enable: true,
                             url: format!("http://127.0.0.1:{pac_port}/commands/pac"),
                         };
-                        log_err!(autoproxy.set_auto_proxy());
+                        logging_error!(Type::System, true, autoproxy.set_auto_proxy());
                     } else {
                         let sysproxy = Sysproxy {
                             enable: true,
@@ -332,7 +333,7 @@ impl Sysopt {
                             bypass: get_bypass(),
                         };
 
-                        log_err!(sysproxy.set_system_proxy());
+                        logging_error!(Type::System, true, sysproxy.set_system_proxy());
                     }
                 }
 

src-tauri/src/core/timer.rs

@@ -1,4 +1,6 @@
-use crate::{config::Config, core::CoreManager, feat};
+use crate::{
+    config::Config, core::CoreManager, feat, logging, logging_error, utils::logging::Type,
+};
 use anyhow::{Context, Result};
 use delay_timer::prelude::{DelayTimer, DelayTimerBuilder, TaskBuilder};
 use once_cell::sync::OnceCell;
@@ -54,18 +56,18 @@ impl Timer {
             )
             .is_err()
         {
-            log::debug!(target: "app", "Timer already initialized, skipping...");
+            logging!(debug, Type::Timer, "Timer already initialized, skipping...");
             return Ok(());
         }
 
-        log::info!(target: "app", "Initializing timer...");
+        logging!(info, Type::Timer, true, "Initializing timer...");
 
         // Initialize timer tasks
         if let Err(e) = self.refresh() {
             // Reset initialization flag on error
             self.initialized
                 .store(false, std::sync::atomic::Ordering::SeqCst);
-            log::error!(target: "app", "Failed to initialize timer: {}", e);
+            logging_error!(Type::Timer, false, "Failed to initialize timer: {}", e);
             return Err(e);
         }
 
@@ -98,15 +100,15 @@ impl Timer {
 
             for uid in profiles_to_update {
                 if let Some(task) = timer_map.get(&uid) {
-                    log::info!(target: "app", "Advancing task for uid: {}", uid);
+                    logging!(info, Type::Timer, "Advancing task for uid: {}", uid);
                     if let Err(e) = delay_timer.advance_task(task.task_id) {
-                        log::warn!(target: "app", "Failed to advance task {}: {}", uid, e);
+                        logging!(warn, Type::Timer, "Failed to advance task {}: {}", uid, e);
                     }
                 }
             }
         }
 
-        log::info!(target: "app", "Timer initialization completed");
+        logging!(info, Type::Timer, "Timer initialization completed");
         Ok(())
     }
 
@@ -116,11 +118,16 @@ impl Timer {
         let diff_map = self.gen_diff();
 
         if diff_map.is_empty() {
-            log::debug!(target: "app", "No timer changes needed");
+            logging!(debug, Type::Timer, "No timer changes needed");
             return Ok(());
         }
 
-        log::info!(target: "app", "Refreshing {} timer tasks", diff_map.len());
+        logging!(
+            info,
+            Type::Timer,
+            "Refreshing {} timer tasks",
+            diff_map.len()
+        );
 
         // Apply changes while holding locks
         let mut timer_map = self.timer_map.write();
@@ -131,9 +138,16 @@ impl Timer {
                 DiffFlag::Del(tid) => {
                     timer_map.remove(&uid);
                     if let Err(e) = delay_timer.remove_task(tid) {
-                        log::warn!(target: "app", "Failed to remove task {} for uid {}: {}", tid, uid, e);
+                        logging!(
+                            warn,
+                            Type::Timer,
+                            "Failed to remove task {} for uid {}: {}",
+                            tid,
+                            uid,
+                            e
+                        );
                     } else {
-                        log::debug!(target: "app", "Removed task {} for uid {}", tid, uid);
+                        logging!(debug, Type::Timer, "Removed task {} for uid {}", tid, uid);
                     }
                 }
                 DiffFlag::Add(tid, interval) => {
@@ -146,16 +160,23 @@ impl Timer {
                     timer_map.insert(uid.clone(), task);
 
                     if let Err(e) = self.add_task(&mut delay_timer, uid.clone(), tid, interval) {
-                        log::error!(target: "app", "Failed to add task for uid {}: {}", uid, e);
+                        logging_error!(Type::Timer, "Failed to add task for uid {}: {}", uid, e);
                         timer_map.remove(&uid); // Rollback on failure
                     } else {
-                        log::debug!(target: "app", "Added task {} for uid {}", tid, uid);
+                        logging!(debug, Type::Timer, "Added task {} for uid {}", tid, uid);
                     }
                 }
                 DiffFlag::Mod(tid, interval) => {
                     // Remove old task first
                     if let Err(e) = delay_timer.remove_task(tid) {
-                        log::warn!(target: "app", "Failed to remove old task {} for uid {}: {}", tid, uid, e);
+                        logging!(
+                            warn,
+                            Type::Timer,
+                            "Failed to remove old task {} for uid {}: {}",
+                            tid,
+                            uid,
+                            e
+                        );
                     }
 
                     // Then add the new one
@@ -168,10 +189,10 @@ impl Timer {
                     timer_map.insert(uid.clone(), task);
 
                     if let Err(e) = self.add_task(&mut delay_timer, uid.clone(), tid, interval) {
-                        log::error!(target: "app", "Failed to update task for uid {}: {}", uid, e);
+                        logging_error!(Type::Timer, "Failed to update task for uid {}: {}", uid, e);
                         timer_map.remove(&uid); // Rollback on failure
                     } else {
-                        log::debug!(target: "app", "Updated task {} for uid {}", tid, uid);
+                        logging!(debug, Type::Timer, "Updated task {} for uid {}", tid, uid);
                     }
                 }
             }
@@ -250,7 +271,14 @@ impl Timer {
         tid: TaskID,
         minutes: u64,
     ) -> Result<()> {
-        log::info!(target: "app", "Adding task: uid={}, id={}, interval={}min", uid, tid, minutes);
+        logging!(
+            info,
+            Type::Timer,
+            "Adding task: uid={}, id={}, interval={}min",
+            uid,
+            tid,
+            minutes
+        );
 
         // Create a task with reasonable retries and backoff
         let task = TaskBuilder::default()
@@ -275,7 +303,7 @@ impl Timer {
     /// Async task with better error handling and logging
     async fn async_task(uid: String) {
         let task_start = std::time::Instant::now();
-        log::info!(target: "app", "Running timer task for profile: {}", uid);
+        logging!(info, Type::Timer, "Running timer task for profile: {}", uid);
 
         // Update profile
         let profile_result = feat::update_profile(uid.clone(), None).await;
@@ -286,23 +314,26 @@ impl Timer {
                 match CoreManager::global().update_config().await {
                     Ok(_) => {
                         let duration = task_start.elapsed().as_millis();
-                        log::info!(
-                            target: "app",
+                        logging!(
+                            info,
+                            Type::Timer,
                             "Timer task completed successfully for uid: {} (took {}ms)",
-                            uid, duration
+                            uid,
+                            duration
                         );
                     }
                     Err(e) => {
-                        log::error!(
-                            target: "app",
+                        logging_error!(
+                            Type::Timer,
                             "Failed to refresh config after profile update for uid {}: {}",
-                            uid, e
+                            uid,
+                            e
                         );
                     }
                 }
             }
             Err(e) => {
-                log::error!(target: "app", "Failed to update profile uid {}: {}", uid, e);
+                logging_error!(Type::Timer, "Failed to update profile uid {}: {}", uid, e);
             }
         }
     }

src-tauri/src/core/tray/mod.rs

@@ -6,9 +6,9 @@ use crate::{
     cmd,
     config::Config,
     feat,
-    module::mihomo::Rate,
+    module::{lightweight::entry_lightweight_mode, mihomo::Rate},
     resolve,
-    utils::{dirs, i18n::t, resolve::VERSION},
+    utils::{dirs::find_target_icons, i18n::t, logging::Type, resolve::VERSION},
 };
 
 use anyhow::Result;
@@ -20,6 +20,7 @@ use parking_lot::Mutex;
 use parking_lot::RwLock;
 #[cfg(target_os = "macos")]
 pub use speed_rate::{SpeedRate, Traffic};
+use std::fs;
 #[cfg(target_os = "macos")]
 use std::sync::Arc;
 use tauri::{
@@ -31,16 +32,124 @@ use tauri::{
 use tokio::sync::broadcast;
 
 use super::handle;
+
+#[derive(Clone)]
+struct TrayState {}
+
 #[cfg(target_os = "macos")]
 pub struct Tray {
     pub speed_rate: Arc<Mutex<Option<SpeedRate>>>,
     shutdown_tx: Arc<RwLock<Option<broadcast::Sender<()>>>>,
     is_subscribed: Arc<RwLock<bool>>,
+    pub rate_cache: Arc<Mutex<Option<Rate>>>,
 }
 
 #[cfg(not(target_os = "macos"))]
 pub struct Tray {}
 
+impl TrayState {
+    pub fn get_common_tray_icon() -> (bool, Vec<u8>) {
+        let verge = Config::verge().latest().clone();
+        let is_common_tray_icon = verge.common_tray_icon.unwrap_or(false);
+        if is_common_tray_icon {
+            if let Some(common_icon_path) = find_target_icons("common").unwrap() {
+                let icon_data = fs::read(common_icon_path).unwrap();
+                return (true, icon_data);
+            }
+        }
+        #[cfg(target_os = "macos")]
+        {
+            let tray_icon_colorful = verge.tray_icon.unwrap_or("monochrome".to_string());
+            if tray_icon_colorful == "monochrome" {
+                (
+                    false,
+                    include_bytes!("../../../icons/tray-icon-mono.ico").to_vec(),
+                )
+            } else {
+                (
+                    false,
+                    include_bytes!("../../../icons/tray-icon.ico").to_vec(),
+                )
+            }
+        }
+
+        #[cfg(not(target_os = "macos"))]
+        {
+            (
+                false,
+                include_bytes!("../../../icons/tray-icon.ico").to_vec(),
+            )
+        }
+    }
+
+    pub fn get_sysproxy_tray_icon() -> (bool, Vec<u8>) {
+        let verge = Config::verge().latest().clone();
+        let is_sysproxy_tray_icon = verge.sysproxy_tray_icon.unwrap_or(false);
+        if is_sysproxy_tray_icon {
+            if let Some(sysproxy_icon_path) = find_target_icons("sysproxy").unwrap() {
+                let icon_data = fs::read(sysproxy_icon_path).unwrap();
+                return (true, icon_data);
+            }
+        }
+        #[cfg(target_os = "macos")]
+        {
+            let tray_icon_colorful = verge.tray_icon.clone().unwrap_or("monochrome".to_string());
+            if tray_icon_colorful == "monochrome" {
+                (
+                    false,
+                    include_bytes!("../../../icons/tray-icon-sys-mono.ico").to_vec(),
+                )
+            } else {
+                (
+                    false,
+                    include_bytes!("../../../icons/tray-icon-sys.ico").to_vec(),
+                )
+            }
+        }
+
+        #[cfg(not(target_os = "macos"))]
+        {
+            (
+                false,
+                include_bytes!("../../../icons/tray-icon-sys.ico").to_vec(),
+            )
+        }
+    }
+
+    pub fn get_tun_tray_icon() -> (bool, Vec<u8>) {
+        let verge = Config::verge().latest().clone();
+        let is_tun_tray_icon = verge.tun_tray_icon.unwrap_or(false);
+        if is_tun_tray_icon {
+            if let Some(tun_icon_path) = find_target_icons("tun").unwrap() {
+                let icon_data = fs::read(tun_icon_path).unwrap();
+                return (true, icon_data);
+            }
+        }
+        #[cfg(target_os = "macos")]
+        {
+            let tray_icon_colorful = verge.tray_icon.clone().unwrap_or("monochrome".to_string());
+            if tray_icon_colorful == "monochrome" {
+                (
+                    false,
+                    include_bytes!("../../../icons/tray-icon-tun-mono.ico").to_vec(),
+                )
+            } else {
+                (
+                    false,
+                    include_bytes!("../../../icons/tray-icon-tun.ico").to_vec(),
+                )
+            }
+        }
+        #[cfg(not(target_os = "macos"))]
+        {
+            (
+                false,
+                include_bytes!("../../../icons/tray-icon-tun.ico").to_vec(),
+            )
+        }
+    }
+}
+
 impl Tray {
     pub fn global() -> &'static Tray {
         static TRAY: OnceCell<Tray> = OnceCell::new();
@@ -50,6 +159,7 @@ impl Tray {
             speed_rate: Arc::new(Mutex::new(None)),
             shutdown_tx: Arc::new(RwLock::new(None)),
             is_subscribed: Arc::new(RwLock::new(false)),
+            rate_cache: Arc::new(Mutex::new(None)),
         });
 
         #[cfg(not(target_os = "macos"))]
@@ -84,6 +194,7 @@ impl Tray {
         tray.on_tray_icon_event(|_, event| {
             let tray_event = { Config::verge().latest().tray_event.clone() };
             let tray_event: String = tray_event.unwrap_or("main_window".into());
+            log::debug!(target: "app","tray event: {:?}", tray_event);
 
             if let TrayIconEvent::Click {
                 button: MouseButton::Left,
@@ -94,7 +205,7 @@ impl Tray {
                 match tray_event.as_str() {
                     "system_proxy" => feat::toggle_system_proxy(),
                     "tun_mode" => feat::toggle_tun_mode(None),
-                    "main_window" => resolve::create_window(),
+                    "main_window" => resolve::create_window(true),
                     _ => {}
                 }
             }
@@ -148,114 +259,67 @@ impl Tray {
     }
 
     /// 更新托盘图标
-    #[allow(unused_variables)]
     pub fn update_icon(&self, rate: Option<Rate>) -> Result<()> {
-        let app_handle = handle::Handle::global().app_handle().unwrap();
         let verge = Config::verge().latest().clone();
-        let system_proxy = verge.enable_system_proxy.as_ref().unwrap_or(&false);
+        let system_mode = verge.enable_system_proxy.as_ref().unwrap_or(&false);
         let tun_mode = verge.enable_tun_mode.as_ref().unwrap_or(&false);
 
-        let common_tray_icon = verge.common_tray_icon.as_ref().unwrap_or(&false);
-        let sysproxy_tray_icon = verge.sysproxy_tray_icon.as_ref().unwrap_or(&false);
-        let tun_tray_icon = verge.tun_tray_icon.as_ref().unwrap_or(&false);
-
+        let app_handle = handle::Handle::global().app_handle().unwrap();
         let tray = app_handle.tray_by_id("main").unwrap();
 
-        #[cfg(target_os = "macos")]
-        let tray_icon = verge.tray_icon.clone().unwrap_or("monochrome".to_string());
-
-        let icon_bytes = if *system_proxy && !*tun_mode {
-            #[cfg(target_os = "macos")]
-            let mut icon = match tray_icon.as_str() {
-                "colorful" => include_bytes!("../../../icons/tray-icon-sys.ico").to_vec(),
-                _ => include_bytes!("../../../icons/tray-icon-sys-mono.ico").to_vec(),
-            };
-
-            #[cfg(not(target_os = "macos"))]
-            let mut icon = include_bytes!("../../../icons/tray-icon-sys.ico").to_vec();
-            if *sysproxy_tray_icon {
-                let icon_dir_path = dirs::app_home_dir()?.join("icons");
-                let png_path = icon_dir_path.join("sysproxy.png");
-                let ico_path = icon_dir_path.join("sysproxy.ico");
-                if ico_path.exists() {
-                    icon = std::fs::read(ico_path).unwrap();
-                } else if png_path.exists() {
-                    icon = std::fs::read(png_path).unwrap();
-                }
-            }
-            icon
-        } else if *tun_mode {
-            #[cfg(target_os = "macos")]
-            let mut icon = match tray_icon.as_str() {
-                "colorful" => include_bytes!("../../../icons/tray-icon-tun.ico").to_vec(),
-                _ => include_bytes!("../../../icons/tray-icon-tun-mono.ico").to_vec(),
-            };
-
-            #[cfg(not(target_os = "macos"))]
-            let mut icon = include_bytes!("../../../icons/tray-icon-tun.ico").to_vec();
-            if *tun_tray_icon {
-                let icon_dir_path = dirs::app_home_dir()?.join("icons");
-                let png_path = icon_dir_path.join("tun.png");
-                let ico_path = icon_dir_path.join("tun.ico");
-                if ico_path.exists() {
-                    icon = std::fs::read(ico_path).unwrap();
-                } else if png_path.exists() {
-                    icon = std::fs::read(png_path).unwrap();
-                }
-            }
-            icon
-        } else {
-            #[cfg(target_os = "macos")]
-            let mut icon = match tray_icon.as_str() {
-                "colorful" => include_bytes!("../../../icons/tray-icon.ico").to_vec(),
-                _ => include_bytes!("../../../icons/tray-icon-mono.ico").to_vec(),
-            };
-
-            #[cfg(not(target_os = "macos"))]
-            let mut icon = include_bytes!("../../../icons/tray-icon.ico").to_vec();
-            if *common_tray_icon {
-                let icon_dir_path = dirs::app_home_dir()?.join("icons");
-                let png_path = icon_dir_path.join("common.png");
-                let ico_path = icon_dir_path.join("common.ico");
-                if ico_path.exists() {
-                    icon = std::fs::read(ico_path).unwrap();
-                } else if png_path.exists() {
-                    icon = std::fs::read(png_path).unwrap();
-                }
-            }
-            icon
+        let (is_custom_icon, icon_bytes) = match (*system_mode, *tun_mode) {
+            (true, true) => TrayState::get_tun_tray_icon(),
+            (true, false) => TrayState::get_sysproxy_tray_icon(),
+            (false, true) => TrayState::get_tun_tray_icon(),
+            (false, false) => TrayState::get_common_tray_icon(),
         };
-
         #[cfg(target_os = "macos")]
         {
-            let enable_tray_speed = Config::verge().latest().enable_tray_speed.unwrap_or(true);
-            let is_colorful = tray_icon == "colorful";
+            let enable_tray_speed = verge.enable_tray_speed.unwrap_or(true);
+            let enable_tray_icon = verge.enable_tray_icon.unwrap_or(true);
+            let colorful = verge.tray_icon.clone().unwrap_or("monochrome".to_string());
+            let is_colorful = colorful == "colorful";
 
-            // 处理图标和速率
-            let final_icon_bytes = if enable_tray_speed {
-                let rate = rate.or_else(|| {
-                    self.speed_rate
-                        .lock()
-                        .as_ref()
-                        .and_then(|speed_rate| speed_rate.get_curent_rate())
-                });
+            if !enable_tray_speed {
+                let _ = tray.set_icon(Some(tauri::image::Image::from_bytes(&icon_bytes)?));
+                let _ = tray.set_icon_as_template(!is_colorful);
+                return Ok(());
+            }
 
-                // 使用新的方法渲染图标和速率
-                SpeedRate::add_speed_text(icon_bytes, rate)?
+            let rate = if let Some(rate) = rate {
+                Some(rate)
             } else {
-                icon_bytes
+                let guard = self.speed_rate.lock();
+                if let Some(rate) = guard.as_ref().unwrap().get_curent_rate() {
+                    Some(rate)
+                } else {
+                    Some(Rate::default())
+                }
             };
 
-            // 设置系统托盘图标
-            let _ = tray.set_icon(Some(tauri::image::Image::from_bytes(&final_icon_bytes)?));
-            // 只对单色图标使用 template 模式
-            let _ = tray.set_icon_as_template(!is_colorful);
+            let mut rate_guard = self.rate_cache.lock();
+            if *rate_guard != rate {
+                *rate_guard = rate;
+
+                let bytes = if enable_tray_icon {
+                    Some(icon_bytes)
+                } else {
+                    None
+                };
+
+                let rate = rate_guard.as_ref();
+                let rate_bytes = SpeedRate::add_speed_text(is_custom_icon, bytes, rate).unwrap();
+                let _ = tray.set_icon(Some(tauri::image::Image::from_bytes(&rate_bytes)?));
+                let _ = tray.set_icon_as_template(!is_custom_icon && !is_colorful);
+            }
+            Ok(())
         }
 
         #[cfg(not(target_os = "macos"))]
-        let _ = tray.set_icon(Some(tauri::image::Image::from_bytes(&icon_bytes)?));
-
-        Ok(())
+        {
+            let _ = tray.set_icon(Some(tauri::image::Image::from_bytes(&icon_bytes)?));
+            Ok(())
+        }
     }
 
     /// 更新托盘提示
@@ -490,6 +554,15 @@ fn create_tray_menu(
     )
     .unwrap();
 
+    let lighteweight_mode = &MenuItem::with_id(
+        app_handle,
+        "entry_lightweight_mode",
+        t("LightWeight Mode"),
+        true,
+        hotkeys.get("entry_lightweight_mode").map(|s| s.as_str()),
+    )
+    .unwrap();
+
     let copy_env =
         &MenuItem::with_id(app_handle, "copy_env", t("Copy Env"), true, None::<&str>).unwrap();
 
@@ -582,6 +655,8 @@ fn create_tray_menu(
             separator,
             system_proxy,
             tun_mode,
+            separator,
+            lighteweight_mode,
             copy_env,
             open_dir,
             more,
@@ -600,17 +675,17 @@ fn on_menu_event(_: &AppHandle, event: MenuEvent) {
             println!("change mode to: {}", mode);
             feat::change_clash_mode(mode.into());
         }
-        "open_window" => resolve::create_window(),
+        "open_window" => resolve::create_window(true),
         "system_proxy" => feat::toggle_system_proxy(),
         "tun_mode" => feat::toggle_tun_mode(None),
         "copy_env" => feat::copy_clash_env(),
-        "open_app_dir" => crate::log_err!(cmd::open_app_dir()),
-        "open_core_dir" => crate::log_err!(cmd::open_core_dir()),
-        "open_logs_dir" => crate::log_err!(cmd::open_logs_dir()),
+        "open_app_dir" => crate::logging_error!(Type::Cmd, true, cmd::open_app_dir()),
+        "open_core_dir" => crate::logging_error!(Type::Cmd, true, cmd::open_core_dir()),
+        "open_logs_dir" => crate::logging_error!(Type::Cmd, true, cmd::open_logs_dir()),
         "restart_clash" => feat::restart_clash_core(),
         "restart_app" => feat::restart_app(),
+        "entry_lightweight_mode" => entry_lightweight_mode(),
         "quit" => {
-            println!("quit");
             feat::quit(Some(0));
         }
         id if id.starts_with("profiles_") => {

src-tauri/src/core/tray/speed_rate.rs

@@ -15,7 +15,6 @@ use tungstenite::client::IntoClientRequest;
 pub struct SpeedRate {
     rate: Arc<Mutex<(Rate, Rate)>>,
     last_update: Arc<Mutex<std::time::Instant>>,
-    // 移除 base_image，不再缓存原始图像
 }
 
 impl SpeedRate {
@@ -77,44 +76,71 @@ impl SpeedRate {
     }
 
     // 分离图标加载和速率渲染
-    pub fn add_speed_text(icon_bytes: Vec<u8>, rate: Option<Rate>) -> Result<Vec<u8>> {
-        let rate = rate.unwrap_or(Rate { up: 0, down: 0 });
+    pub fn add_speed_text(
+        is_custom_icon: bool,
+        icon_bytes: Option<Vec<u8>>,
+        rate: Option<&Rate>,
+    ) -> Result<Vec<u8>> {
+        let rate = rate.unwrap_or(&Rate { up: 0, down: 0 });
 
-        // 加载原始图标
-        let icon_image = image::load_from_memory(&icon_bytes)?;
-        let (icon_width, icon_height) = (icon_image.width(), icon_image.height());
+        let (mut icon_width, mut icon_height) = (0, 256);
+        let icon_image = if let Some(bytes) = icon_bytes.clone() {
+            let icon_image = image::load_from_memory(&bytes)?;
+            icon_width = icon_image.width();
+            icon_height = icon_image.height();
+            icon_image
+        } else {
+            // 返回一个空的 RGBA 图像
+            image::DynamicImage::new_rgba8(0, 0)
+        };
 
-        // 判断是否为彩色图标
-        let is_colorful =
-            !crate::utils::help::is_monochrome_image_from_bytes(&icon_bytes).unwrap_or(false);
+        let total_width = match (is_custom_icon, icon_bytes.is_some()) {
+            (true, true) => 510,
+            (true, false) => 740,
+            (false, false) => 740,
+            (false, true) => icon_width + 740,
+        };
 
-        // 增加文本宽度和间距
-        let text_width = 580; // 文本区域宽度
-        let total_width = icon_width + text_width;
+        // println!(
+        //     "icon_height: {}, icon_wight: {}, total_width: {}",
+        //     icon_height, icon_width, total_width
+        // );
 
         // 创建新的透明画布
         let mut combined_image = RgbaImage::new(total_width, icon_height);
 
         // 将原始图标绘制到新画布的左侧
-        for y in 0..icon_height {
-            for x in 0..icon_width {
-                let pixel = icon_image.get_pixel(x, y);
-                combined_image.put_pixel(x, y, pixel);
+        if icon_bytes.is_some() {
+            for y in 0..icon_height {
+                for x in 0..icon_width {
+                    let pixel = icon_image.get_pixel(x, y);
+                    combined_image.put_pixel(x, y, pixel);
+                }
             }
         }
 
+        let is_colorful = if let Some(bytes) = icon_bytes.clone() {
+            !crate::utils::help::is_monochrome_image_from_bytes(&bytes).unwrap_or(false)
+        } else {
+            false
+        };
+
         // 选择文本颜色
         let (text_color, shadow_color) = if is_colorful {
-            // 彩色图标使用黑色文本和轻微白色阴影
             (
-                Rgba([255u8, 255u8, 255u8, 255u8]),
-                Rgba([0u8, 0u8, 0u8, 160u8]),
+                Rgba([144u8, 144u8, 144u8, 255u8]),
+                // Rgba([255u8, 255u8, 255u8, 128u8]),
+                Rgba([0u8, 0u8, 0u8, 128u8]),
             )
+            // (
+            //     Rgba([160u8, 160u8, 160u8, 255u8]),
+            //     // Rgba([255u8, 255u8, 255u8, 128u8]),
+            //     Rgba([0u8, 0u8, 0u8, 255u8]),
+            // )
         } else {
-            // 单色图标使用白色文本和轻微黑色阴影
             (
                 Rgba([255u8, 255u8, 255u8, 255u8]),
-                Rgba([0u8, 0u8, 0u8, 120u8]),
+                Rgba([0u8, 0u8, 0u8, 128u8]),
             )
         };
         // 减小字体大小以适应文本区域
@@ -124,17 +150,30 @@ impl SpeedRate {
         let scale = ab_glyph::PxScale::from(font_size);
 
         // 使用更简洁的速率格式
-        let up_text = format_bytes_speed(rate.up);
-        let down_text = format_bytes_speed(rate.down);
+        let up_text = format!("↑ {}", format_bytes_speed(rate.up));
+        let down_text = format!("↓ {}", format_bytes_speed(rate.down));
+
+        // For test rate display
+        // let down_text = format!("↓ {}", format_bytes_speed(102 * 1020 * 1024));
 
         // 计算文本位置，确保垂直间距合适
         // 修改文本位置为居右显示
-        let up_text_width = imageproc::drawing::text_size(scale, &font, &up_text).0 as u32;
-        let down_text_width = imageproc::drawing::text_size(scale, &font, &down_text).0 as u32;
-
         // 计算右对齐的文本位置
-        let up_text_x = total_width - up_text_width;
-        let down_text_x = total_width - down_text_width;
+        // let up_text_width = imageproc::drawing::text_size(scale, &font, &up_text).0 as u32;
+        // let down_text_width = imageproc::drawing::text_size(scale, &font, &down_text).0 as u32;
+        // let up_text_x = total_width - up_text_width;
+        // let down_text_x = total_width - down_text_width;
+
+        // 计算左对齐的文本位置
+        let (up_text_x, down_text_x) = {
+            if is_custom_icon || icon_bytes.is_some() {
+                let text_left_offset = 30;
+                let left_begin = icon_width + text_left_offset;
+                (left_begin, left_begin)
+            } else {
+                (icon_width, icon_width)
+            }
+        };
 
         // 优化垂直位置，使速率显示的高度和上下间距正好等于图标大小
         let text_height = font_size as i32;

src-tauri/src/error/mod.rs

@@ -0,0 +1 @@
+pub mod service;

src-tauri/src/error/service.rs

@@ -0,0 +1 @@
+

src-tauri/src/feat/backup.rs

@@ -1,8 +1,8 @@
 use crate::{
     config::{Config, IVerge},
     core::backup,
-    log_err,
-    utils::dirs::app_home_dir,
+    logging_error,
+    utils::{dirs::app_home_dir, logging::Type},
 };
 use anyhow::Result;
 use reqwest_dav::list_cmd::ListFile;
@@ -69,8 +69,9 @@ pub async fn restore_webdav_backup(filename: String) -> Result<()> {
     // extract zip file
     let mut zip = zip::ZipArchive::new(fs::File::open(backup_storage_path.clone())?)?;
     zip.extract(app_home_dir()?)?;
-
-    log_err!(
+    logging_error!(
+        Type::Backup,
+        true,
         super::patch_verge(
             IVerge {
                 webdav_url,

src-tauri/src/feat/clash.rs

@@ -1,9 +1,9 @@
 use crate::{
     config::Config,
     core::{handle, tray, CoreManager},
-    log_err,
+    logging_error,
     module::mihomo::MihomoManager,
-    utils::resolve,
+    utils::{logging::Type, resolve},
 };
 use serde_yaml::{Mapping, Value};
 use tauri::Manager;
@@ -28,12 +28,31 @@ pub fn restart_clash_core() {
 pub fn restart_app() {
     tauri::async_runtime::spawn_blocking(|| {
         tauri::async_runtime::block_on(async {
-            log_err!(CoreManager::global().stop_core().await);
+            logging_error!(Type::Core, true, CoreManager::global().stop_core().await);
+            resolve::resolve_reset_async().await;
+            let app_handle = handle::Handle::global().app_handle().unwrap();
+            std::thread::sleep(std::time::Duration::from_secs(1));
+            tauri::process::restart(&app_handle.env());
         });
-        resolve::resolve_reset();
-        let app_handle = handle::Handle::global().app_handle().unwrap();
-        std::thread::sleep(std::time::Duration::from_secs(1));
-        tauri::process::restart(&app_handle.env());
+    });
+}
+
+fn after_change_clash_mode() {
+    tauri::async_runtime::spawn(async {
+        match MihomoManager::global().get_connections().await {
+            Ok(connections) => {
+                if let Some(connections_array) = connections["connections"].as_array() {
+                    for connection in connections_array {
+                        if let Some(id) = connection["id"].as_str() {
+                            let _ = MihomoManager::global().delete_connection(id).await;
+                        }
+                    }
+                }
+            }
+            Err(err) => {
+                log::error!(target: "app", "Failed to get connections: {}", err);
+            }
+        }
     });
 }
 
@@ -47,7 +66,6 @@ pub fn change_clash_mode(mode: String) {
     });
     tauri::async_runtime::spawn(async move {
         log::debug!(target: "app", "change clash mode to {mode}");
-
         match MihomoManager::global().patch_configs(json_value).await {
             Ok(_) => {
                 // 更新订阅
@@ -55,8 +73,16 @@ pub fn change_clash_mode(mode: String) {
 
                 if Config::clash().data().save_config().is_ok() {
                     handle::Handle::refresh_clash();
-                    log_err!(tray::Tray::global().update_menu());
-                    log_err!(tray::Tray::global().update_icon(None));
+                    logging_error!(Type::Tray, true, tray::Tray::global().update_menu());
+                    logging_error!(Type::Tray, true, tray::Tray::global().update_icon(None));
+                }
+
+                let is_auto_close_connection = Config::verge()
+                    .data()
+                    .auto_close_connection
+                    .unwrap_or(false);
+                if is_auto_close_connection {
+                    after_change_clash_mode();
                 }
             }
             Err(err) => println!("{err}"),

src-tauri/src/feat/config.rs

@@ -1,8 +1,9 @@
 use crate::{
     config::{Config, IVerge},
     core::{handle, hotkey, sysopt, tray, CoreManager},
-    log_err,
+    logging_error,
     module::lightweight,
+    utils::logging::Type,
 };
 use anyhow::Result;
 use serde_yaml::Mapping;
@@ -18,8 +19,8 @@ pub async fn patch_clash(patch: Mapping) -> Result<()> {
             CoreManager::global().restart_core().await?;
         } else {
             if patch.get("mode").is_some() {
-                log_err!(tray::Tray::global().update_menu());
-                log_err!(tray::Tray::global().update_icon(None));
+                logging_error!(Type::Tray, true, tray::Tray::global().update_menu());
+                logging_error!(Type::Tray, true, tray::Tray::global().update_icon(None));
             }
             Config::runtime().latest().patch_config(patch);
             CoreManager::global().update_config().await?;
@@ -89,6 +90,7 @@ pub async fn patch_verge(patch: IVerge, not_save_file: bool) -> Result<()> {
     let http_enabled = patch.verge_http_enabled;
     let http_port = patch.verge_port;
     let enable_tray_speed = patch.enable_tray_speed;
+    let enable_tray_icon = patch.enable_tray_icon;
     let enable_global_hotkey = patch.enable_global_hotkey;
     let tray_event = patch.tray_event;
     let home_cards = patch.home_cards.clone();
@@ -145,6 +147,7 @@ pub async fn patch_verge(patch: IVerge, not_save_file: bool) -> Result<()> {
             || tun_tray_icon.is_some()
             || tray_icon.is_some()
             || enable_tray_speed.is_some()
+            || enable_tray_icon.is_some()
         {
             update_flags |= UpdateFlags::SystrayIcon as i32;
         }
@@ -164,6 +167,7 @@ pub async fn patch_verge(patch: IVerge, not_save_file: bool) -> Result<()> {
 
         // Process updates based on flags
         if (update_flags & (UpdateFlags::RestartCore as i32)) != 0 {
+            Config::generate().await?;
             CoreManager::global().restart_core().await?;
         }
         if (update_flags & (UpdateFlags::ClashConfig as i32)) != 0 {

src-tauri/src/feat/profile.rs

@@ -82,3 +82,11 @@ pub async fn update_profile(uid: String, option: Option<PrfOption>) -> Result<()
 
     Ok(())
 }
+
+/// 增强配置
+pub async fn enhance_profiles() -> Result<()> {
+    crate::core::CoreManager::global()
+        .update_config()
+        .await
+        .map(|_| ())
+}

src-tauri/src/feat/proxy.rs

@@ -28,6 +28,19 @@ pub fn toggle_system_proxy() {
 
 /// Toggle TUN mode on/off
 pub fn toggle_tun_mode(not_save_file: Option<bool>) {
+    // tauri::async_runtime::spawn(async move {
+    //     logging!(
+    //         info,
+    //         Type::Service,
+    //         true,
+    //         "Toggle TUN mode need install service"
+    //     );
+    //     if is_service_available().await.is_err() {
+    //         logging_error!(Type::Service, true, install_service().await);
+    //     }
+    //     logging_error!(Type::Core, true, CoreManager::global().restart_core().await);
+    // });
+
     let enable = Config::verge().data().enable_tun_mode;
     let enable = enable.unwrap_or(false);
 

src-tauri/src/feat/window.rs

@@ -6,8 +6,6 @@ use crate::{
     module::mihomo::MihomoManager,
     utils::resolve,
 };
-use tauri::Manager;
-use tauri_plugin_window_state::{AppHandleExt, StateFlags};
 
 /// Open or close the dashboard window
 #[allow(dead_code)]
@@ -47,40 +45,10 @@ pub fn open_or_close_dashboard() {
     } else {
         println!("No existing window found, creating new window");
         log::info!(target: "app", "No existing window found, creating new window");
-        resolve::create_window();
+        resolve::create_window(true);
     }
 }
 
-/// Setup window state monitor to save window position and size in real-time
-pub fn setup_window_state_monitor(app_handle: &tauri::AppHandle) {
-    let window = app_handle.get_webview_window("main").unwrap();
-    let app_handle_clone = app_handle.clone();
-
-    // 监听窗口移动事件
-    let app_handle_move = app_handle_clone.clone();
-    window.on_window_event(move |event| {
-        match event {
-            // 窗口移动时保存状态
-            tauri::WindowEvent::Moved(_) => {
-                let _ = app_handle_move.save_window_state(StateFlags::all());
-            }
-            // 窗口调整大小时保存状态
-            tauri::WindowEvent::Resized(_) => {
-                let _ = app_handle_move.save_window_state(StateFlags::all());
-            }
-            // 其他可能改变窗口状态的事件
-            tauri::WindowEvent::ScaleFactorChanged { .. } => {
-                let _ = app_handle_move.save_window_state(StateFlags::all());
-            }
-            // 窗口关闭时保存
-            tauri::WindowEvent::CloseRequested { .. } => {
-                let _ = app_handle_move.save_window_state(StateFlags::all());
-            }
-            _ => {}
-        }
-    });
-}
-
 /// 优化的应用退出函数
 pub fn quit(code: Option<i32>) {
     log::debug!(target: "app", "启动退出流程");

src-tauri/src/lib.rs

@@ -2,6 +2,7 @@ mod cmd;
 mod config;
 mod core;
 mod enhance;
+mod error;
 mod feat;
 mod module;
 mod utils;
@@ -16,6 +17,7 @@ use tauri::AppHandle;
 use tauri::Manager;
 use tauri_plugin_autostart::MacosLauncher;
 use tauri_plugin_deep_link::DeepLinkExt;
+use utils::logging::Type;
 
 /// A global singleton handle to the application.
 pub struct AppHandleManager {
@@ -110,7 +112,6 @@ pub fn run() {
         .plugin(tauri_plugin_clipboard_manager::init())
         .plugin(tauri_plugin_process::init())
         .plugin(tauri_plugin_global_shortcut::Builder::new().build())
-        .plugin(tauri_plugin_notification::init())
         .plugin(tauri_plugin_fs::init())
         .plugin(tauri_plugin_dialog::init())
         .plugin(tauri_plugin_shell::init())
@@ -120,13 +121,13 @@ pub fn run() {
             #[cfg(any(target_os = "linux", all(debug_assertions, windows)))]
             {
                 use tauri_plugin_deep_link::DeepLinkExt;
-                log_err!(app.deep_link().register_all());
+                logging_error!(Type::System, true, app.deep_link().register_all());
             }
 
             app.deep_link().on_open_url(|event| {
                 tauri::async_runtime::spawn(async move {
                     if let Some(url) = event.urls().first() {
-                        log_err!(resolve_scheme(url.to_string()).await);
+                        logging_error!(Type::Setup, true, resolve_scheme(url.to_string()).await);
                     }
                 });
             });
@@ -151,9 +152,14 @@ pub fn run() {
             cmd::restart_app,
             // 添加新的命令
             cmd::get_running_mode,
-            cmd::install_service,
             cmd::get_app_uptime,
             cmd::get_auto_launch_status,
+            cmd::is_admin,
+            // service 管理
+            cmd::install_service,
+            cmd::uninstall_service,
+            cmd::reinstall_service,
+            cmd::repair_service,
             // clash
             cmd::get_clash_info,
             cmd::patch_clash_config,
@@ -276,13 +282,25 @@ pub fn run() {
                     tauri::WindowEvent::Focused(true) => {
                         #[cfg(target_os = "macos")]
                         {
-                            log_err!(hotkey::Hotkey::global().register("CMD+Q", "quit"));
-                            log_err!(hotkey::Hotkey::global().register("CMD+W", "hide"));
+                            logging_error!(
+                                Type::Hotkey,
+                                true,
+                                hotkey::Hotkey::global().register("CMD+Q", "quit")
+                            );
+                            logging_error!(
+                                Type::Hotkey,
+                                true,
+                                hotkey::Hotkey::global().register("CMD+W", "hide")
+                            );
                         }
 
                         #[cfg(not(target_os = "macos"))]
                         {
-                            log_err!(hotkey::Hotkey::global().register("Control+Q", "quit"));
+                            logging_error!(
+                                Type::Hotkey,
+                                true,
+                                hotkey::Hotkey::global().register("Control+Q", "quit")
+                            );
                         };
                         {
                             let is_enable_global_hotkey = Config::verge()
@@ -290,19 +308,31 @@ pub fn run() {
                                 .enable_global_hotkey
                                 .unwrap_or(true);
                             if !is_enable_global_hotkey {
-                                log_err!(hotkey::Hotkey::global().init())
+                                logging_error!(Type::Hotkey, true, hotkey::Hotkey::global().init())
                             }
                         }
                     }
                     tauri::WindowEvent::Focused(false) => {
                         #[cfg(target_os = "macos")]
                         {
-                            log_err!(hotkey::Hotkey::global().unregister("CMD+Q"));
-                            log_err!(hotkey::Hotkey::global().unregister("CMD+W"));
+                            logging_error!(
+                                Type::Hotkey,
+                                true,
+                                hotkey::Hotkey::global().unregister("CMD+Q")
+                            );
+                            logging_error!(
+                                Type::Hotkey,
+                                true,
+                                hotkey::Hotkey::global().unregister("CMD+W")
+                            );
                         }
                         #[cfg(not(target_os = "macos"))]
                         {
-                            log_err!(hotkey::Hotkey::global().unregister("Control+Q"));
+                            logging_error!(
+                                Type::Hotkey,
+                                true,
+                                hotkey::Hotkey::global().unregister("Control+Q")
+                            );
                         };
                         {
                             let is_enable_global_hotkey = Config::verge()
@@ -310,20 +340,32 @@ pub fn run() {
                                 .enable_global_hotkey
                                 .unwrap_or(true);
                             if !is_enable_global_hotkey {
-                                log_err!(hotkey::Hotkey::global().reset())
+                                logging_error!(Type::Hotkey, true, hotkey::Hotkey::global().reset())
                             }
                         }
                     }
                     tauri::WindowEvent::Destroyed => {
                         #[cfg(target_os = "macos")]
                         {
-                            log_err!(hotkey::Hotkey::global().unregister("CMD+Q"));
-                            log_err!(hotkey::Hotkey::global().unregister("CMD+W"));
+                            logging_error!(
+                                Type::Hotkey,
+                                true,
+                                hotkey::Hotkey::global().unregister("CMD+Q")
+                            );
+                            logging_error!(
+                                Type::Hotkey,
+                                true,
+                                hotkey::Hotkey::global().unregister("CMD+W")
+                            );
                         }
 
                         #[cfg(not(target_os = "macos"))]
                         {
-                            log_err!(hotkey::Hotkey::global().unregister("Control+Q"));
+                            logging_error!(
+                                Type::Hotkey,
+                                true,
+                                hotkey::Hotkey::global().unregister("Control+Q")
+                            );
                         };
                     }
                     _ => {}

src-tauri/src/module/lightweight.rs

@@ -5,46 +5,51 @@ use tauri::{Listener, Manager};
 use crate::{
     config::Config,
     core::{handle, timer::Timer},
-    log_err,
+    log_err, logging,
+    utils::logging::Type,
+    AppHandleManager,
 };
 
 const LIGHT_WEIGHT_TASK_UID: &str = "light_weight_task";
 
 pub fn enable_auto_light_weight_mode() {
-    println!("[lightweight_mode] 开启自动轻量模式");
-    log::info!(target: "app", "[lightweight_mode] 开启自动轻量模式");
+    Timer::global().init().unwrap();
+    logging!(info, Type::Lightweight, true, "开启自动轻量模式");
     setup_window_close_listener();
     setup_webview_focus_listener();
 }
 
 pub fn disable_auto_light_weight_mode() {
-    println!("[lightweight_mode] 关闭自动轻量模式");
-    log::info!(target: "app", "[lightweight_mode] 关闭自动轻量模式");
+    logging!(info, Type::Lightweight, true, "关闭自动轻量模式");
     let _ = cancel_light_weight_timer();
     cancel_window_close_listener();
 }
 
 pub fn entry_lightweight_mode() {
-    println!("尝试进入轻量模式。motherfucker");
     if let Some(window) = handle::Handle::global().get_window() {
-        log_err!(window.close());
-    }
-
-    if let Some(window) = handle::Handle::global().get_window() {
-        if let Some(webview) = window.get_webview_window("main") {
-            log_err!(webview.destroy());
-            println!("[lightweight_mode] 轻量模式已开启");
-            log::info!(target: "app", "[lightweight_mode] 轻量模式已开启");
+        if window.is_visible().unwrap_or(false) {
+            let _ = window.hide();
         }
+        if let Some(webview) = window.get_webview_window("main") {
+            let _ = webview.destroy();
+        }
+        #[cfg(target_os = "macos")]
+        AppHandleManager::global().set_activation_policy_accessory();
+        logging!(info, Type::Lightweight, true, "轻量模式已开启");
     }
+    let _ = cancel_light_weight_timer();
 }
 
 fn setup_window_close_listener() -> u32 {
     if let Some(window) = handle::Handle::global().get_window() {
         let handler = window.listen("tauri://close-requested", move |_event| {
             let _ = setup_light_weight_timer();
-            println!("[lightweight_mode] 监听到关闭请求，开始轻量模式计时");
-            log::info!(target: "app", "[lightweight_mode] 监听到关闭请求，开始轻量模式计时");
+            logging!(
+                info,
+                Type::Lightweight,
+                true,
+                "监听到关闭请求，开始轻量模式计时"
+            );
         });
         return handler;
     }
@@ -55,8 +60,12 @@ fn setup_webview_focus_listener() -> u32 {
     if let Some(window) = handle::Handle::global().get_window() {
         let handler = window.listen("tauri://focus", move |_event| {
             log_err!(cancel_light_weight_timer());
-            println!("[lightweight_mode] 监听到窗口获得焦点，取消轻量模式计时");
-            log::info!(target: "app", "[lightweight_mode] 监听到窗口获得焦点，取消轻量模式计时");
+            logging!(
+                info,
+                Type::Lightweight,
+                true,
+                "监听到窗口获得焦点，取消轻量模式计时"
+            );
         });
         return handler;
     }
@@ -66,8 +75,7 @@ fn setup_webview_focus_listener() -> u32 {
 fn cancel_window_close_listener() {
     if let Some(window) = handle::Handle::global().get_window() {
         window.unlisten(setup_window_close_listener());
-        println!("[lightweight_mode] 取消了窗口关闭监听");
-        log::info!(target: "app", "[lightweight_mode] 取消了窗口关闭监听");
+        logging!(info, Type::Lightweight, true, "取消了窗口关闭监听");
     }
 }
 
@@ -84,7 +92,6 @@ fn setup_light_weight_timer() -> Result<()> {
     let once_by_minutes = Config::verge()
         .latest()
         .auto_light_weight_minutes
-        .clone()
         .unwrap_or(10);
 
     let task = TaskBuilder::default()
@@ -92,17 +99,14 @@ fn setup_light_weight_timer() -> Result<()> {
         .set_maximum_parallel_runnable_num(1)
         .set_frequency_once_by_minutes(once_by_minutes)
         .spawn_async_routine(move || async move {
-            println!("[lightweight_mode] 计时器到期，开始进入轻量模式");
-            log::info!(target: "app",
-                "[lightweight_mode] 计时器到期，开始进入轻量模式"
-            );
+            logging!(info, Type::Timer, true, "计时器到期，开始进入轻量模式");
             entry_lightweight_mode();
         })
-        .context("failed to create light weight timer task")?;
+        .context("failed to create timer task")?;
 
     delay_timer
         .add_task(task)
-        .context("failed to add light weight timer task")?;
+        .context("failed to add timer task")?;
 
     let timer_task = crate::core::timer::TimerTask {
         task_id,
@@ -112,12 +116,11 @@ fn setup_light_weight_timer() -> Result<()> {
 
     timer_map.insert(LIGHT_WEIGHT_TASK_UID.to_string(), timer_task);
 
-    println!(
-        "[lightweight_mode] 轻量模式计时器已设置，{} 分钟后将自动进入轻量模式",
-        once_by_minutes
-    );
-    log::info!(target: "app",
-        "[lightweight_mode] 轻量模式计时器已设置，{} 分钟后将自动进入轻量模式",
+    logging!(
+        info,
+        Type::Timer,
+        true,
+        "计时器已设置，{} 分钟后将自动进入轻量模式",
         once_by_minutes
     );
 
@@ -131,11 +134,9 @@ fn cancel_light_weight_timer() -> Result<()> {
     if let Some(task) = timer_map.remove(LIGHT_WEIGHT_TASK_UID) {
         delay_timer
             .remove_task(task.task_id)
-            .context("failed to remove light weight timer task")?;
+            .context("failed to remove timer task")?;
+        logging!(info, Type::Timer, true, "计时器已取消");
     }
 
-    println!("[lightweight_mode] 轻量模式计时器已取消");
-    log::info!(target: "app", "[lightweight_mode] 轻量模式计时器已取消");
-
     Ok(())
 }

src-tauri/src/module/mod.rs

@@ -1,3 +1,3 @@
+pub mod lightweight;
 pub mod mihomo;
 pub mod sysinfo;
-pub mod lightweight;

src-tauri/src/module/sysinfo.rs

@@ -1,4 +1,7 @@
-use crate::core::{handle, CoreManager};
+use crate::{
+    cmd::system,
+    core::{handle, CoreManager},
+};
 use std::fmt::{self, Debug, Formatter};
 use sysinfo::System;
 
@@ -9,14 +12,15 @@ pub struct PlatformSpecification {
     system_arch: String,
     verge_version: String,
     running_mode: String,
+    is_admin: bool,
 }
 
 impl Debug for PlatformSpecification {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(
             f,
-            "System Name: {}\nSystem Version: {}\nSystem kernel Version: {}\nSystem Arch: {}\nVerge Version: {}\nRunning Mode: {}",
-            self.system_name, self.system_version, self.system_kernel_version, self.system_arch, self.verge_version, self.running_mode
+            "System Name: {}\nSystem Version: {}\nSystem kernel Version: {}\nSystem Arch: {}\nVerge Version: {}\nRunning Mode: {}\nIs Admin: {}",
+            self.system_name, self.system_version, self.system_kernel_version, self.system_arch, self.verge_version, self.running_mode, self.is_admin
         )
     }
 }
@@ -32,16 +36,10 @@ impl PlatformSpecification {
         let config = handler.config();
         let verge_version = config.version.clone().unwrap_or("Null".into());
 
-        // Get running mode asynchronously
-        let running_mode = tokio::task::block_in_place(|| {
-            tokio::runtime::Handle::current().block_on(async {
-                match CoreManager::global().get_running_mode().await {
-                    crate::core::RunningMode::Service => "Service".to_string(),
-                    crate::core::RunningMode::Sidecar => "Sidecar".to_string(),
-                    crate::core::RunningMode::NotRunning => "Not Running".to_string(),
-                }
-            })
-        });
+        // 使用默认值避免在同步上下文中执行异步操作
+        let running_mode = "NotRunning".to_string();
+
+        let is_admin = system::is_admin().unwrap_or_default();
 
         Self {
             system_name,
@@ -50,6 +48,17 @@ impl PlatformSpecification {
             system_arch,
             verge_version,
             running_mode,
+            is_admin,
         }
     }
+
+    // 异步方法来获取完整的系统信息
+    pub async fn new_async() -> Self {
+        let mut info = Self::new();
+
+        let running_mode = CoreManager::global().get_running_mode().await;
+        info.running_mode = running_mode.to_string();
+
+        info
+    }
 }

src-tauri/src/utils/dirs.rs

@@ -77,6 +77,36 @@ pub fn app_profiles_dir() -> Result<PathBuf> {
     Ok(app_home_dir()?.join("profiles"))
 }
 
+/// icons dir
+pub fn app_icons_dir() -> Result<PathBuf> {
+    Ok(app_home_dir()?.join("icons"))
+}
+
+pub fn find_target_icons(target: &str) -> Result<Option<String>> {
+    let icons_dir = app_icons_dir()?;
+    let mut matching_files = Vec::new();
+
+    for entry in fs::read_dir(icons_dir)? {
+        let entry = entry?;
+        let path = entry.path();
+
+        if let Some(file_name) = path.file_name().and_then(|n| n.to_str()) {
+            if file_name.starts_with(target)
+                && (file_name.ends_with(".ico") || file_name.ends_with(".png"))
+            {
+                matching_files.push(path);
+            }
+        }
+    }
+
+    if matching_files.is_empty() {
+        Ok(None)
+    } else {
+        let first = path_to_str(matching_files.first().unwrap())?;
+        Ok(Some(first.to_string()))
+    }
+}
+
 /// logs dir
 pub fn app_logs_dir() -> Result<PathBuf> {
     Ok(app_home_dir()?.join("logs"))

src-tauri/src/utils/help.rs

@@ -1,8 +1,8 @@
-use crate::enhance::seq::SeqMap;
+use crate::{enhance::seq::SeqMap, logging, utils::logging::Type};
 use anyhow::{anyhow, bail, Context, Result};
 use nanoid::nanoid;
 use serde::{de::DeserializeOwned, Serialize};
-use serde_yaml::{Mapping, Value};
+use serde_yaml::Mapping;
 use std::{fs, path::PathBuf, str::FromStr};
 
 /// read data from yaml as struct T
@@ -22,19 +22,41 @@ pub fn read_yaml<T: DeserializeOwned>(path: &PathBuf) -> Result<T> {
     })
 }
 
-/// read mapping from yaml fix #165
+/// read mapping from yaml
 pub fn read_mapping(path: &PathBuf) -> Result<Mapping> {
-    let mut val: Value = read_yaml(path)?;
-    val.apply_merge()
-        .with_context(|| format!("failed to apply merge \"{}\"", path.display()))?;
+    if !path.exists() {
+        bail!("file not found \"{}\"", path.display());
+    }
 
-    Ok(val
-        .as_mapping()
-        .ok_or(anyhow!(
-            "failed to transform to yaml mapping \"{}\"",
-            path.display()
-        ))?
-        .to_owned())
+    let yaml_str = fs::read_to_string(path)
+        .with_context(|| format!("failed to read the file \"{}\"", path.display()))?;
+
+    // YAML语法检查
+    match serde_yaml::from_str::<serde_yaml::Value>(&yaml_str) {
+        Ok(mut val) => {
+            val.apply_merge()
+                .with_context(|| format!("failed to apply merge \"{}\"", path.display()))?;
+
+            Ok(val
+                .as_mapping()
+                .ok_or(anyhow!(
+                    "failed to transform to yaml mapping \"{}\"",
+                    path.display()
+                ))?
+                .to_owned())
+        }
+        Err(err) => {
+            let error_msg = format!("YAML syntax error in {}: {}", path.display(), err);
+            logging!(error, Type::Config, true, "{}", error_msg);
+
+            crate::core::handle::Handle::notice_message(
+                "config_validate::yaml_syntax_error",
+                &error_msg,
+            );
+
+            bail!("YAML syntax error: {}", err)
+        }
+    }
 }
 
 /// read mapping from yaml fix #165
@@ -136,52 +158,6 @@ pub fn linux_elevator() -> String {
     }
 }
 
-#[macro_export]
-macro_rules! error {
-    ($result: expr) => {
-        log::error!(target: "app", "{}", $result);
-    };
-}
-
-#[macro_export]
-macro_rules! log_err {
-    ($result: expr) => {
-        if let Err(err) = $result {
-            log::error!(target: "app", "{err}");
-        }
-    };
-
-    ($result: expr, $err_str: expr) => {
-        if let Err(_) = $result {
-            log::error!(target: "app", "{}", $err_str);
-        }
-    };
-}
-
-#[macro_export]
-macro_rules! trace_err {
-    ($result: expr, $err_str: expr) => {
-        if let Err(err) = $result {
-            log::trace!(target: "app", "{}, err {}", $err_str, err);
-        }
-    }
-}
-
-/// wrap the anyhow error
-/// transform the error to String
-#[macro_export]
-macro_rules! wrap_err {
-    ($stat: expr) => {
-        match $stat {
-            Ok(a) => Ok(a),
-            Err(err) => {
-                log::error!(target: "app", "{}", err.to_string());
-                Err(format!("{}", err.to_string()))
-            }
-        }
-    };
-}
-
 /// return the string literal error
 #[macro_export]
 macro_rules! ret_err {
@@ -213,15 +189,16 @@ macro_rules! t {
 /// ```
 #[cfg(target_os = "macos")]
 pub fn format_bytes_speed(speed: u64) -> String {
-    if speed < 1024 {
-        format!("{}B/s", speed)
-    } else if speed < 1024 * 1024 {
-        format!("{:.1}KB/s", speed as f64 / 1024.0)
-    } else if speed < 1024 * 1024 * 1024 {
-        format!("{:.1}MB/s", speed as f64 / 1024.0 / 1024.0)
-    } else {
-        format!("{:.1}GB/s", speed as f64 / 1024.0 / 1024.0 / 1024.0)
+    const UNITS: [&str; 4] = ["B", "KB", "MB", "GB"];
+    let mut size = speed as f64;
+    let mut unit_index = 0;
+
+    while size >= 1000.0 && unit_index < UNITS.len() - 1 {
+        size /= 1024.0;
+        unit_index += 1;
     }
+
+    format!("{:.1}{}/s", size, UNITS[unit_index])
 }
 
 #[cfg(target_os = "macos")]

src-tauri/src/utils/init.rs

@@ -177,6 +177,7 @@ fn init_dns_config() -> Result<()> {
         (
             "default-nameserver".into(),
             Value::Sequence(vec![
+                Value::String("system".into()),
                 Value::String("223.6.6.6".into()),
                 Value::String("8.8.8.8".into()),
             ]),
@@ -189,14 +190,7 @@ fn init_dns_config() -> Result<()> {
                 Value::String("https://dns.alidns.com/dns-query".into()),
             ]),
         ),
-        (
-            "fallback".into(),
-            Value::Sequence(vec![
-                Value::String("https://dns.alidns.com/dns-query".into()),
-                Value::String("https://dns.google/dns-query".into()),
-                Value::String("https://cloudflare-dns.com/dns-query".into()),
-            ]),
-        ),
+        ("fallback".into(), Value::Sequence(vec![])),
         (
             "nameserver-policy".into(),
             Value::Mapping(serde_yaml::Mapping::new()),
@@ -206,6 +200,7 @@ fn init_dns_config() -> Result<()> {
             Value::Sequence(vec![
                 Value::String("https://doh.pub/dns-query".into()),
                 Value::String("https://dns.alidns.com/dns-query".into()),
+                Value::String("tls://223.5.5.5".into()),
             ]),
         ),
         ("direct-nameserver".into(), Value::Sequence(vec![])),
@@ -300,15 +295,11 @@ pub fn init_config() -> Result<()> {
 /// after tauri setup
 pub fn init_resources() -> Result<()> {
     let app_dir = dirs::app_home_dir()?;
-    let test_dir = app_dir.join("test");
     let res_dir = dirs::app_resources_dir()?;
 
     if !app_dir.exists() {
         let _ = fs::create_dir_all(&app_dir);
     }
-    if !test_dir.exists() {
-        let _ = fs::create_dir_all(&test_dir);
-    }
     if !res_dir.exists() {
         let _ = fs::create_dir_all(&res_dir);
     }
@@ -320,7 +311,6 @@ pub fn init_resources() -> Result<()> {
     for file in file_list.iter() {
         let src_path = res_dir.join(file);
         let dest_path = app_dir.join(file);
-        let test_dest_path = test_dir.join(file);
         log::debug!(target: "app", "src_path: {src_path:?}, dest_path: {dest_path:?}");
 
         let handle_copy = |dest: &PathBuf| {
@@ -332,9 +322,6 @@ pub fn init_resources() -> Result<()> {
             };
         };
 
-        if src_path.exists() && !test_dest_path.exists() {
-            handle_copy(&test_dest_path);
-        }
         if src_path.exists() && !dest_path.exists() {
             handle_copy(&dest_path);
             continue;

src-tauri/src/utils/logging.rs

@@ -0,0 +1,139 @@
+use std::fmt;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Type {
+    Cmd,
+    Core,
+    Config,
+    Setup,
+    System,
+    Service,
+    Hotkey,
+    Window,
+    Tray,
+    Timer,
+    Frontend,
+    Backup,
+    Lightweight,
+}
+
+impl fmt::Display for Type {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Type::Cmd => write!(f, "[Cmd]"),
+            Type::Core => write!(f, "[Core]"),
+            Type::Config => write!(f, "[Config]"),
+            Type::Setup => write!(f, "[Setup]"),
+            Type::System => write!(f, "[System]"),
+            Type::Service => write!(f, "[Service]"),
+            Type::Hotkey => write!(f, "[Hotkey]"),
+            Type::Window => write!(f, "[Window]"),
+            Type::Tray => write!(f, "[Tray]"),
+            Type::Timer => write!(f, "[Timer]"),
+            Type::Frontend => write!(f, "[Frontend]"),
+            Type::Backup => write!(f, "[Backup]"),
+            Type::Lightweight => write!(f, "[Lightweight]"),
+        }
+    }
+}
+
+#[macro_export]
+macro_rules! error {
+    ($result: expr) => {
+        log::error!(target: "app", "{}", $result);
+    };
+}
+
+#[macro_export]
+macro_rules! log_err {
+    ($result: expr) => {
+        if let Err(err) = $result {
+            log::error!(target: "app", "{err}");
+        }
+    };
+
+    ($result: expr, $err_str: expr) => {
+        if let Err(_) = $result {
+            log::error!(target: "app", "{}", $err_str);
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! trace_err {
+    ($result: expr, $err_str: expr) => {
+        if let Err(err) = $result {
+            log::trace!(target: "app", "{}, err {}", $err_str, err);
+        }
+    }
+}
+
+/// wrap the anyhow error
+/// transform the error to String
+#[macro_export]
+macro_rules! wrap_err {
+    ($stat: expr) => {
+        match $stat {
+            Ok(a) => Ok(a),
+            Err(err) => {
+                log::error!(target: "app", "{}", err.to_string());
+                Err(format!("{}", err.to_string()))
+            }
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! logging {
+    // 带 println 的版本（支持格式化参数）
+    ($level:ident, $type:expr, true, $($arg:tt)*) => {
+        println!("{} {}", $type, format_args!($($arg)*));
+        log::$level!(target: "app", "{} {}", $type, format_args!($($arg)*));
+    };
+
+    // 带 println 的版本（使用 false 明确不打印）
+    ($level:ident, $type:expr, false, $($arg:tt)*) => {
+        log::$level!(target: "app", "{} {}", $type, format_args!($($arg)*));
+    };
+
+    // 不带 print 参数的版本（默认不打印）
+    ($level:ident, $type:expr, $($arg:tt)*) => {
+        log::$level!(target: "app", "{} {}", $type, format_args!($($arg)*));
+    };
+}
+
+#[macro_export]
+macro_rules! logging_error {
+    // 1. 处理 Result<T, E>，带打印控制
+    ($type:expr, $print:expr, $expr:expr) => {
+        match $expr {
+            Ok(_) => {},
+            Err(err) => {
+                if $print {
+                    println!("[{}] Error: {}", $type, err);
+                }
+                log::error!(target: "app", "[{}] {}", $type, err);
+            }
+        }
+    };
+
+    // 2. 处理 Result<T, E>，默认不打印
+    ($type:expr, $expr:expr) => {
+        if let Err(err) = $expr {
+            log::error!(target: "app", "[{}] {}", $type, err);
+        }
+    };
+
+    // 3. 处理格式化字符串，带打印控制
+    ($type:expr, $print:expr, $fmt:literal $(, $arg:expr)*) => {
+        if $print {
+            println!("[{}] {}", $type, format_args!($fmt $(, $arg)*));
+        }
+        log::error!(target: "app", "[{}] {}", $type, format_args!($fmt $(, $arg)*));
+    };
+
+    // 4. 处理格式化字符串，不带 bool 时，默认 `false`
+    ($type:expr, $fmt:literal $(, $arg:expr)*) => {
+        logging_error!($type, false, $fmt $(, $arg)*);
+    };
+}

src-tauri/src/utils/mod.rs

@@ -3,6 +3,7 @@ pub mod error;
 pub mod help;
 pub mod i18n;
 pub mod init;
+pub mod logging;
 pub mod resolve;
 pub mod server;
 pub mod tmpl;

src-tauri/src/utils/resolve.rs

@@ -1,7 +1,12 @@
 #[cfg(target_os = "macos")]
 use crate::AppHandleManager;
 use crate::{
-    config::{Config, IVerge, PrfItem}, core::*, log_err, module::lightweight, utils::{error, init, server}, wrap_err
+    config::{Config, IVerge, PrfItem},
+    core::*,
+    logging, logging_error,
+    module::lightweight,
+    utils::{error, init, logging::Type, server},
+    wrap_err,
 };
 use anyhow::{bail, Result};
 use once_cell::sync::OnceCell;
@@ -10,10 +15,9 @@ use serde_yaml::Mapping;
 use std::net::TcpListener;
 use tauri::{App, Manager};
 
-use url::Url;
+use tauri::Url;
 //#[cfg(not(target_os = "linux"))]
 // use window_shadows::set_shadow;
-use tauri_plugin_notification::NotificationExt;
 
 pub static VERSION: OnceCell<String> = OnceCell::new();
 
@@ -47,106 +51,98 @@ pub async fn resolve_setup(app: &mut App) {
     handle::Handle::global().init(app.app_handle());
     VERSION.get_or_init(|| version.clone());
 
-    log_err!(init::init_config());
-    log_err!(init::init_resources());
-    log_err!(init::init_scheme());
-    log_err!(init::startup_script().await);
+    logging_error!(Type::Config, true, init::init_config());
+    logging_error!(Type::Setup, true, init::init_resources());
+    logging_error!(Type::Setup, true, init::init_scheme());
+    logging_error!(Type::Setup, true, init::startup_script().await);
     // 处理随机端口
-    log_err!(resolve_random_port_config());
+    logging_error!(Type::System, true, resolve_random_port_config());
     // 启动核心
-    log::trace!(target:"app", "init config");
-    log_err!(Config::init_config().await);
+    logging!(trace, Type::Config, true, "Initial config");
+    logging_error!(Type::Config, true, Config::init_config().await);
 
-    if service::check_service().await.is_err() {
-        match service::reinstall_service().await {
-            Ok(_) => {
-                log::info!(target:"app", "install service susccess.");
-                #[cfg(not(target_os = "macos"))]
-                std::thread::sleep(std::time::Duration::from_millis(1000));
-                #[cfg(target_os = "macos")]
-                {
-                    let mut service_runing = false;
-                    for _ in 0..40 {
-                        if service::check_service().await.is_ok() {
-                            service_runing = true;
-                            break;
-                        } else {
-                            log::warn!(target: "app", "service not runing, sleep 500ms and check again.");
-                            std::thread::sleep(std::time::Duration::from_millis(500));
-                        }
-                    }
-                    if !service_runing {
-                        log::warn!(target: "app", "service not running, will fallback to user mode");
-                    }
-                }
-            }
-            Err(e) => {
-                log::warn!(target: "app", "failed to install service: {e:?}, will fallback to user mode");
-            }
-        }
-    }
-
-    log::trace!(target: "app", "launch core");
-    log_err!(CoreManager::global().init().await);
+    logging!(trace, Type::Core, "Starting CoreManager");
+    logging_error!(Type::Core, true, CoreManager::global().init().await);
 
     // setup a simple http server for singleton
     log::trace!(target: "app", "launch embed server");
     server::embed_server();
 
-    log::trace!(target: "app", "init system tray");
-    log_err!(tray::Tray::global().init());
-    log_err!(tray::Tray::global().create_systray(app));
+    log::trace!(target: "app", "Initial system tray");
+    logging_error!(Type::Tray, true, tray::Tray::global().init());
+    logging_error!(Type::Tray, true, tray::Tray::global().create_systray(app));
 
-    log_err!(sysopt::Sysopt::global().update_sysproxy().await);
-    log_err!(sysopt::Sysopt::global().init_guard_sysproxy());
+    logging_error!(
+        Type::System,
+        true,
+        sysopt::Sysopt::global().update_sysproxy().await
+    );
+    logging_error!(
+        Type::System,
+        true,
+        sysopt::Sysopt::global().init_guard_sysproxy()
+    );
 
-    // 初始化热键
-    log::trace!(target: "app", "init hotkeys");
-    log_err!(hotkey::Hotkey::global().init());
+    let is_silent_start = { Config::verge().data().enable_silent_start }.unwrap_or(false);
+    create_window(!is_silent_start);
 
-    let silent_start = { Config::verge().data().enable_silent_start };
-    if !silent_start.unwrap_or(false) {
-        create_window();
-    }
-
-    log_err!(tray::Tray::global().update_part());
-    log_err!(timer::Timer::global().init());
+    logging_error!(Type::System, true, timer::Timer::global().init());
 
     let enable_auto_light_weight_mode = { Config::verge().data().enable_auto_light_weight_mode };
     if enable_auto_light_weight_mode.unwrap_or(false) {
         lightweight::enable_auto_light_weight_mode();
     }
+
+    logging_error!(Type::Tray, true, tray::Tray::global().update_part());
+
+    // 初始化热键
+    logging!(trace, Type::System, true, "Initial hotkeys");
+    logging_error!(Type::System, true, hotkey::Hotkey::global().init());
 }
 
-/// reset system proxy
-pub fn resolve_reset() {
-    tauri::async_runtime::block_on(async move {
-        #[cfg(target_os = "macos")]
-        tray::Tray::global().unsubscribe_traffic();
+/// reset system proxy (异步版)
+pub async fn resolve_reset_async() {
+    #[cfg(target_os = "macos")]
+    logging!(info, Type::Tray, true, "Unsubscribing from traffic updates");
+    #[cfg(target_os = "macos")]
+    tray::Tray::global().unsubscribe_traffic();
 
-        log_err!(sysopt::Sysopt::global().reset_sysproxy().await);
-        log_err!(CoreManager::global().stop_core().await);
-        #[cfg(target_os = "macos")]
+    logging_error!(
+        Type::System,
+        true,
+        sysopt::Sysopt::global().reset_sysproxy().await
+    );
+    logging_error!(Type::Core, true, CoreManager::global().stop_core().await);
+    #[cfg(target_os = "macos")]
+    {
+        logging!(info, Type::System, true, "Restoring system DNS settings");
         restore_public_dns().await;
-    });
+    }
 }
 
 /// create main window
-pub fn create_window() {
-    println!("Starting to create window");
-    log::info!(target: "app", "Starting to create window");
+pub fn create_window(is_showup: bool) {
+    logging!(info, Type::Window, true, "Creating window");
 
     let app_handle = handle::Handle::global().app_handle().unwrap();
     #[cfg(target_os = "macos")]
     AppHandleManager::global().set_activation_policy_regular();
 
     if let Some(window) = handle::Handle::global().get_window() {
-        println!("Found existing window, trying to show it");
-        log::info!(target: "app", "Found existing window, trying to show it");
+        logging!(
+            info,
+            Type::Window,
+            true,
+            "Found existing window, attempting to restore visibility"
+        );
 
         if window.is_minimized().unwrap_or(false) {
-            println!("Window is minimized, unminimizing");
-            log::info!(target: "app", "Window is minimized, unminimizing");
+            logging!(
+                info,
+                Type::Window,
+                true,
+                "Window is minimized, restoring window state"
+            );
             let _ = window.unminimize();
         }
         let _ = window.show();
@@ -154,8 +150,7 @@ pub fn create_window() {
         return;
     }
 
-    println!("Creating new window");
-    log::info!(target: "app", "Creating new window");
+    logging!(info, Type::Window, true, "Creating new application window");
 
     #[cfg(target_os = "windows")]
     let window = tauri::WebviewWindowBuilder::new(
@@ -201,17 +196,46 @@ pub fn create_window() {
 
     match window {
         Ok(window) => {
-            println!("Window created successfully, attempting to show");
-            log::info!(target: "app", "Window created successfully, attempting to show");
-            let _ = window.show();
-            let _ = window.set_focus();
+            logging!(info, Type::Window, true, "Window created successfully");
+            if is_showup {
+                println!("is showup");
+                let _ = window.show();
+                let _ = window.set_focus();
+            } else {
+                let _ = window.hide();
+                #[cfg(target_os = "macos")]
+                AppHandleManager::global().set_activation_policy_accessory();
+            }
 
             // 设置窗口状态监控，实时保存窗口位置和大小
-            crate::feat::setup_window_state_monitor(&app_handle);
+            // crate::feat::setup_window_state_monitor(&app_handle);
+
+            // 标记前端UI已准备就绪，向前端发送启动完成事件
+            let app_handle_clone = app_handle.clone();
+            tauri::async_runtime::spawn(async move {
+                use tauri::Emitter;
+
+                logging!(
+                    info,
+                    Type::Window,
+                    true,
+                    "标记前端UI已准备就绪，开始处理启动错误队列"
+                );
+                handle::Handle::global().mark_startup_completed();
+
+                if let Some(window) = app_handle_clone.get_webview_window("main") {
+                    let _ = window.emit("verge://startup-completed", ());
+                }
+            });
         }
         Err(e) => {
-            println!("Failed to create window: {:?}", e);
-            log::error!(target: "app", "Failed to create window: {:?}", e);
+            logging!(
+                error,
+                Type::Window,
+                true,
+                "Failed to create window: {:?}",
+                e
+            );
         }
     }
 }
@@ -219,8 +243,6 @@ pub fn create_window() {
 pub async fn resolve_scheme(param: String) -> Result<()> {
     log::info!(target:"app", "received deep link: {}", param);
 
-    let app_handle = handle::Handle::global().app_handle().unwrap();
-
     let param_str = if param.starts_with("[") && param.len() > 4 {
         param
             .get(2..param.len() - 2)
@@ -243,41 +265,32 @@ pub async fn resolve_scheme(param: String) -> Result<()> {
             .find(|(key, _)| key == "name")
             .map(|(_, value)| value.into_owned());
 
-        let encode_url = link_parsed
-            .query_pairs()
-            .find(|(key, _)| key == "url")
-            .map(|(_, value)| value.into_owned());
+        // 通过直接获取查询部分并解析特定参数来避免 URL 转义问题
+        let url_param = if let Some(query) = link_parsed.query() {
+            let prefix = "url=";
+            if let Some(pos) = query.find(prefix) {
+                let raw_url = &query[pos + prefix.len()..];
+                Some(percent_decode_str(raw_url).decode_utf8_lossy().to_string())
+            } else {
+                None
+            }
+        } else {
+            None
+        };
 
-        match encode_url {
+        match url_param {
             Some(url) => {
-                let url = percent_decode_str(url.as_ref())
-                    .decode_utf8_lossy()
-                    .to_string();
+                log::info!(target:"app", "decoded subscription url: {}", url);
 
-                create_window();
+                create_window(false);
                 match PrfItem::from_url(url.as_ref(), name, None, None).await {
                     Ok(item) => {
                         let uid = item.uid.clone().unwrap();
                         let _ = wrap_err!(Config::profiles().data().append_item(item));
                         handle::Handle::notice_message("import_sub_url::ok", uid);
-
-                        app_handle
-                            .notification()
-                            .builder()
-                            .title("Clash Verge")
-                            .body("Import profile success")
-                            .show()
-                            .unwrap();
                     }
                     Err(e) => {
                         handle::Handle::notice_message("import_sub_url::error", e.to_string());
-                        app_handle
-                            .notification()
-                            .builder()
-                            .title("Clash Verge")
-                            .body(format!("Import profile failed: {e}"))
-                            .show()
-                            .unwrap();
                     }
                 }
             }

src-tauri/src/utils/server.rs

@@ -3,7 +3,8 @@ extern crate warp;
 use super::resolve;
 use crate::{
     config::{Config, IVerge, DEFAULT_PAC},
-    log_err,
+    logging_error,
+    utils::logging::Type,
 };
 use anyhow::{bail, Result};
 use port_scanner::local_port_available;
@@ -48,7 +49,7 @@ pub fn embed_server() {
 
     tauri::async_runtime::spawn(async move {
         let visible = warp::path!("commands" / "visible").map(move || {
-            resolve::create_window();
+            resolve::create_window(false);
             "ok"
         });
 
@@ -69,7 +70,11 @@ pub fn embed_server() {
                 .unwrap_or_default()
         });
         async fn scheme_handler(query: QueryParam) -> Result<impl warp::Reply, Infallible> {
-            log_err!(resolve::resolve_scheme(query.param).await);
+            logging_error!(
+                Type::Setup,
+                true,
+                resolve::resolve_scheme(query.param).await
+            );
             Ok("ok")
         }
 

src-tauri/src_crates/crate_mihomo_api/Cargo.toml

@@ -6,9 +6,9 @@ edition = "2024"
 debug = []
 
 [dependencies]
-reqwest = { version = "0.12.12", features = ["json"] }
-serde = { version = "1.0.218", features = ["derive"] }
+reqwest = { version = "0.12.15", features = ["json"] }
+serde = { version = "1.0.219", features = ["derive"] }
 serde_json = "1.0.140"
 
 [dev-dependencies]
-tokio = { version = "1.43.0", features = ["rt", "macros"] }
+tokio = { version = "1.44.1", features = ["rt", "macros"] }

src-tauri/src_crates/crate_mihomo_api/src/lib.rs

@@ -98,6 +98,12 @@ impl MihomoManager {
 }
 
 impl MihomoManager {
+    pub async fn is_mihomo_running(&self) -> Result<(), String> {
+        let url = format!("{}/version", self.mihomo_server);
+        let _response = self.send_request(Method::GET, url, None).await?;
+        Ok(())
+    }
+
     pub async fn put_configs_force(&self, clash_config_path: &str) -> Result<(), String> {
         let url = format!("{}/configs?force=true", self.mihomo_server);
         let payload = serde_json::json!({
@@ -134,4 +140,23 @@ impl MihomoManager {
         let response = self.send_request(Method::GET, url, None).await?;
         Ok(response)
     }
+
+    pub async fn get_connections(&self) -> Result<serde_json::Value, String> {
+        let url = format!("{}/connections", self.mihomo_server);
+        let response = self.send_request(Method::GET, url, None).await?;
+        Ok(response)
+    }
+
+    pub async fn delete_connection(&self, id: &str) -> Result<(), String> {
+        let url = format!("{}/connections/{}", self.mihomo_server, id);
+        let response = self.send_request(Method::DELETE, url, None).await?;
+        if response["code"] == 204 {
+            Ok(())
+        } else {
+            Err(response["message"]
+                .as_str()
+                .unwrap_or("unknown error")
+                .to_string())
+        }
+    }
 }

src-tauri/tauri.conf.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.2.1-alpha",
+  "version": "2.2.3",
   "$schema": "../node_modules/@tauri-apps/cli/config.schema.json",
   "bundle": {
     "active": true,
@@ -11,9 +11,15 @@
       "icons/icon.icns",
       "icons/icon.ico"
     ],
-    "resources": ["resources", "resources/locales/*"],
+    "resources": [
+      "resources",
+      "resources/locales/*"
+    ],
     "publisher": "Clash Verge Rev",
-    "externalBin": ["sidecar/verge-mihomo", "sidecar/verge-mihomo-alpha"],
+    "externalBin": [
+      "sidecar/verge-mihomo",
+      "sidecar/verge-mihomo-alpha"
+    ],
     "copyright": "GNU General Public License v3.0",
     "category": "DeveloperTool",
     "shortDescription": "Clash Verge Rev",
@@ -32,8 +38,10 @@
       "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IEQyOEMyRjBCQkVGOUJEREYKUldUZnZmbStDeStNMHU5Mmo1N24xQXZwSVRYbXA2NUpzZE5oVzlqeS9Bc0t6RVV4MmtwVjBZaHgK",
       "endpoints": [
         "https://download.clashverge.dev/https://github.com/clash-verge-rev/clash-verge-rev/releases/download/updater/update-proxy.json",
+        "https://gh-proxy.com/https://github.com/clash-verge-rev/clash-verge-rev/releases/download/updater/update-proxy.json",
         "https://github.com/clash-verge-rev/clash-verge-rev/releases/download/updater/update.json",
         "https://download.clashverge.dev/https://github.com/clash-verge-rev/clash-verge-rev/releases/download/updater-alpha/update-alpha-proxy.json",
+        "https://gh-proxy.com/https://github.com/clash-verge-rev/clash-verge-rev/releases/download/updater-alpha/update-alpha-proxy.json",
         "https://github.com/clash-verge-rev/clash-verge-rev/releases/download/updater-alpha/update-alpha.json"
       ],
       "windows": {
@@ -42,15 +50,25 @@
     },
     "deep-link": {
       "desktop": {
-        "schemes": ["clash", "clash-verge"]
+        "schemes": [
+          "clash",
+          "clash-verge"
+        ]
       }
     }
   },
   "app": {
     "security": {
-      "capabilities": ["desktop-capability", "migrated"],
+      "capabilities": [
+        "desktop-capability",
+        "migrated"
+      ],
       "assetProtocol": {
-        "scope": ["$APPDATA/**", "$RESOURCE/../**", "**"],
+        "scope": [
+          "$APPDATA/**",
+          "$RESOURCE/../**",
+          "**"
+        ],
         "enable": true
       },
       "csp": null

src/App.tsx

@@ -0,0 +1,13 @@
+import { AppDataProvider } from "./providers/app-data-provider";
+import React from "react";
+import Layout from "./pages/_layout";
+
+function App() {
+  return (
+    <AppDataProvider>
+      <Layout />
+    </AppDataProvider>
+  );
+}
+
+export default App; 

src/components/connection/connection-detail.tsx

@@ -1,7 +1,7 @@
 import dayjs from "dayjs";
 import { forwardRef, useImperativeHandle, useState } from "react";
 import { useLockFn } from "ahooks";
-import { Box, Button, Snackbar } from "@mui/material";
+import { Box, Button, Snackbar, useTheme } from "@mui/material";
 import { deleteConnection } from "@/services/api";
 import parseTraffic from "@/utils/parse-traffic";
 import { t } from "i18next";
@@ -14,6 +14,7 @@ export const ConnectionDetail = forwardRef<ConnectionDetailRef>(
   (props, ref) => {
     const [open, setOpen] = useState(false);
     const [detail, setDetail] = useState<IConnectionsItem>(null!);
+    const theme = useTheme();
 
     useImperativeHandle(ref, () => ({
       open: (detail: IConnectionsItem) => {
@@ -35,6 +36,8 @@ export const ConnectionDetail = forwardRef<ConnectionDetailRef>(
             maxWidth: "520px",
             maxHeight: "480px",
             overflowY: "auto",
+            backgroundColor: theme.palette.background.paper,
+            color: theme.palette.text.primary,
           },
         }}
         message={
@@ -54,6 +57,7 @@ interface InnerProps {
 
 const InnerConnectionDetail = ({ data, onClose }: InnerProps) => {
   const { metadata, rulePayload } = data;
+  const theme = useTheme();
   const chains = [...data.chains].reverse().join(" / ");
   const rule = rulePayload ? `${data.rule}(${rulePayload})` : data.rule;
   const host = metadata.host
@@ -99,11 +103,11 @@ const InnerConnectionDetail = ({ data, onClose }: InnerProps) => {
   const onDelete = useLockFn(async () => deleteConnection(data.id));
 
   return (
-    <Box sx={{ userSelect: "text" }}>
+    <Box sx={{ userSelect: "text", color: theme.palette.text.secondary }}>
       {information.map((each) => (
         <div key={each.label}>
           <b>{each.label}</b>
-          <span style={{ wordBreak: "break-all" }}>: {each.value}</span>
+          <span style={{ wordBreak: "break-all", color: theme.palette.text.primary }}>: {each.value}</span>
         </div>
       ))}
 

src/components/home/clash-info-card.tsx

@@ -1,13 +1,10 @@
 import { useTranslation } from "react-i18next";
 import { Typography, Stack, Divider } from "@mui/material";
 import { DeveloperBoardOutlined } from "@mui/icons-material";
-import { useClashInfo } from "@/hooks/use-clash";
 import { useClash } from "@/hooks/use-clash";
 import { EnhancedCard } from "./enhanced-card";
-import useSWR from "swr";
-import { getRules } from "@/services/api";
-import { getAppUptime } from "@/services/cmds";
 import { useMemo } from "react";
+import { useAppData } from "@/providers/app-data-provider";
 
 // 将毫秒转换为时:分:秒格式的函数
 const formatUptime = (uptimeMs: number) => {
@@ -19,32 +16,15 @@ const formatUptime = (uptimeMs: number) => {
 
 export const ClashInfoCard = () => {
   const { t } = useTranslation();
-  const { clashInfo } = useClashInfo();
   const { version: clashVersion } = useClash();
-
-  // 使用SWR获取应用运行时间，降低更新频率
-  const { data: uptimeMs = 0 } = useSWR(
-    "appUptime",
-    getAppUptime,
-    {
-      refreshInterval: 1000,
-      revalidateOnFocus: false,
-      dedupingInterval: 1000,
-    },
-  );
+  const { clashConfig, sysproxy, rules, uptime } = useAppData();
 
   // 使用useMemo缓存格式化后的uptime，避免频繁计算
-  const uptime = useMemo(() => formatUptime(uptimeMs), [uptimeMs]);
-
-  // 获取规则数据，只在组件加载时获取一次
-  const { data: rules = [] } = useSWR("getRules", getRules, {
-    revalidateOnFocus: false,
-    errorRetryCount: 2,
-  });
+  const formattedUptime = useMemo(() => formatUptime(uptime), [uptime]);
 
   // 使用备忘录组件内容，减少重新渲染
   const cardContent = useMemo(() => {
-    if (!clashInfo) return null;
+    if (!clashConfig) return null;
     
     return (
       <Stack spacing={1.5}>
@@ -62,7 +42,7 @@ export const ClashInfoCard = () => {
             {t("System Proxy Address")}
           </Typography>
           <Typography variant="body2" fontWeight="medium">
-            {clashInfo.server || "-"}
+            {sysproxy?.server || "-"}
           </Typography>
         </Stack>
         <Divider />
@@ -71,7 +51,7 @@ export const ClashInfoCard = () => {
             {t("Mixed Port")}
           </Typography>
           <Typography variant="body2" fontWeight="medium">
-            {clashInfo.mixed_port || "-"}
+            {clashConfig["mixed-port"] || "-"}
           </Typography>
         </Stack>
         <Divider />
@@ -80,7 +60,7 @@ export const ClashInfoCard = () => {
             {t("Uptime")}
           </Typography>
           <Typography variant="body2" fontWeight="medium">
-            {uptime}
+            {formattedUptime}
           </Typography>
         </Stack>
         <Divider />
@@ -94,7 +74,7 @@ export const ClashInfoCard = () => {
         </Stack>
       </Stack>
     );
-  }, [clashInfo, clashVersion, t, uptime, rules.length]);
+  }, [clashConfig, clashVersion, t, formattedUptime, rules.length, sysproxy]);
 
   return (
     <EnhancedCard

src/components/home/clash-mode-card.tsx

@@ -1,8 +1,7 @@
 import { useTranslation } from "react-i18next";
 import { Box, Typography, Paper, Stack, Fade } from "@mui/material";
 import { useLockFn } from "ahooks";
-import useSWR from "swr";
-import { closeAllConnections, getClashConfig } from "@/services/api";
+import { closeAllConnections } from "@/services/api";
 import { patchClashMode } from "@/services/cmds";
 import { useVerge } from "@/hooks/use-verge";
 import {
@@ -10,31 +9,19 @@ import {
   MultipleStopRounded,
   DirectionsRounded,
 } from "@mui/icons-material";
-import { useState, useEffect, useMemo } from "react";
+import { useMemo } from "react";
+import { useAppData } from "@/providers/app-data-provider";
 
 export const ClashModeCard = () => {
   const { t } = useTranslation();
   const { verge } = useVerge();
-
-  // 获取当前Clash配置
-  const { data: clashConfig, mutate: mutateClash } = useSWR(
-    "getClashConfig",
-    getClashConfig,
-    { revalidateOnFocus: false }
-  );
+  const { clashConfig, refreshProxy } = useAppData();
 
   // 支持的模式列表
   const modeList = useMemo(() => ["rule", "global", "direct"] as const, []);
 
-  // 本地状态记录当前模式
-  const [localMode, setLocalMode] = useState<string>("rule");
-
-  // 当从API获取到当前模式时更新本地状态
-  useEffect(() => {
-    if (clashConfig?.mode) {
-      setLocalMode(clashConfig.mode.toLowerCase());
-    }
-  }, [clashConfig]);
+  // 直接使用API返回的模式，不维护本地状态
+  const currentMode = clashConfig?.mode?.toLowerCase();
 
   // 模式图标映射
   const modeIcons = useMemo(() => ({
@@ -45,22 +32,17 @@ export const ClashModeCard = () => {
 
   // 切换模式的处理函数
   const onChangeMode = useLockFn(async (mode: string) => {
-    if (mode === localMode) return;
-    
-    setLocalMode(mode);
-    
+    if (mode === currentMode) return;
     if (verge?.auto_close_connection) {
       closeAllConnections();
     }
 
     try {
       await patchClashMode(mode);
-      mutateClash();
+      // 使用共享的刷新方法
+      refreshProxy();
     } catch (error) {
       console.error("Failed to change mode:", error);
-      if (clashConfig?.mode) {
-        setLocalMode(clashConfig.mode.toLowerCase());
-      }
     }
   });
 
@@ -73,8 +55,8 @@ export const ClashModeCard = () => {
     alignItems: "center",
     justifyContent: "center",
     gap: 1,
-    bgcolor: mode === localMode ? "primary.main" : "background.paper",
-    color: mode === localMode ? "primary.contrastText" : "text.primary",
+    bgcolor: mode === currentMode ? "primary.main" : "background.paper",
+    color: mode === currentMode ? "primary.contrastText" : "text.primary",
     borderRadius: 1.5,
     transition: "all 0.2s ease-in-out",
     position: "relative",
@@ -86,7 +68,7 @@ export const ClashModeCard = () => {
     "&:active": {
       transform: "translateY(1px)",
     },
-    "&::after": mode === localMode
+    "&::after": mode === currentMode
       ? {
           content: '""',
           position: "absolute",
@@ -132,7 +114,7 @@ export const ClashModeCard = () => {
         {modeList.map((mode) => (
           <Paper
             key={mode}
-            elevation={mode === localMode ? 2 : 0}
+            elevation={mode === currentMode ? 2 : 0}
             onClick={() => onChangeMode(mode)}
             sx={buttonStyles(mode)}
           >
@@ -141,7 +123,7 @@ export const ClashModeCard = () => {
               variant="body2"
               sx={{
                 textTransform: "capitalize",
-                fontWeight: mode === localMode ? 600 : 400,
+                fontWeight: mode === currentMode ? 600 : 400,
               }}
             >
               {t(mode)}
@@ -161,15 +143,13 @@ export const ClashModeCard = () => {
           overflow: "visible",
         }}
       >
-        <Fade in={true} timeout={200}>
-          <Typography
-            variant="caption"
-            component="div"
-            sx={descriptionStyles}
-          >
-            {t(`${localMode} Mode Description`)}
-          </Typography>
-        </Fade>
+        <Typography
+          variant="caption"
+          component="div"
+          sx={descriptionStyles}
+        >
+          {t(`${currentMode} Mode Description`)}
+        </Typography>
       </Box>
     </Box>
   );

src/components/home/current-proxy-card.tsx

@@ -13,7 +13,7 @@ import {
   SelectChangeEvent,
   Tooltip,
 } from "@mui/material";
-import { useEffect, useState, useMemo, useCallback, useRef } from "react";
+import { useEffect, useState, useMemo, useCallback } from "react";
 import {
   SignalWifi4Bar as SignalStrong,
   SignalWifi3Bar as SignalGood,
@@ -24,16 +24,11 @@ import {
   ChevronRight,
 } from "@mui/icons-material";
 import { useNavigate } from "react-router-dom";
-import { useCurrentProxy } from "@/hooks/use-current-proxy";
 import { EnhancedCard } from "@/components/home/enhanced-card";
-import {
-  getProxies,
-  updateProxy,
-  getConnections,
-  deleteConnection,
-} from "@/services/api";
+import { updateProxy, deleteConnection } from "@/services/api";
 import delayManager from "@/services/delay";
 import { useVerge } from "@/hooks/use-verge";
+import { useAppData } from "@/providers/app-data-provider";
 
 // 本地存储的键名
 const STORAGE_KEY_GROUP = "clash-verge-selected-proxy-group";
@@ -53,11 +48,16 @@ function convertDelayColor(delayValue: number) {
   const mainColor = colorStr.split(".")[0];
 
   switch (mainColor) {
-    case "success": return "success";
-    case "warning": return "warning";
-    case "error": return "error";
-    case "primary": return "primary";
-    default: return "default";
+    case "success":
+      return "success";
+    case "warning":
+      return "warning";
+    case "error":
+      return "error";
+    case "primary":
+      return "primary";
+    default:
+      return "default";
   }
 }
 
@@ -79,7 +79,7 @@ function getSignalIcon(delay: number) {
 // 简单的防抖函数
 function debounce(fn: Function, ms = 100) {
   let timeoutId: ReturnType<typeof setTimeout>;
-  return function(this: any, ...args: any[]) {
+  return function (this: any, ...args: any[]) {
     clearTimeout(timeoutId);
     timeoutId = setTimeout(() => fn.apply(this, args), ms);
   };
@@ -87,20 +87,16 @@ function debounce(fn: Function, ms = 100) {
 
 export const CurrentProxyCard = () => {
   const { t } = useTranslation();
-  const { currentProxy, primaryGroupName, mode, refreshProxy } = useCurrentProxy();
   const navigate = useNavigate();
   const theme = useTheme();
   const { verge } = useVerge();
+  const { proxies, connections, clashConfig, refreshProxy } = useAppData();
 
   // 判断模式
+  const mode = clashConfig?.mode?.toLowerCase() || "rule";
   const isGlobalMode = mode === "global";
   const isDirectMode = mode === "direct";
   
-  // 使用 useRef 存储最后一次刷新时间和是否正在刷新
-  const lastRefreshRef = useRef<number>(0);
-  const isRefreshingRef = useRef<boolean>(false);
-  const pendingRefreshRef = useRef<boolean>(false);
-
   // 定义状态类型
   type ProxyState = {
     proxyData: {
@@ -133,149 +129,275 @@ export const CurrentProxyCard = () => {
 
   // 初始化选择的组
   useEffect(() => {
+    if (!proxies) return;
+    
+    // 提取primaryGroupName
+    const getPrimaryGroupName = () => {
+      if (!proxies?.groups?.length) return "";
+      
+      // 查找主要的代理组（优先级：包含关键词 > 第一个非GLOBAL组）
+      const primaryKeywords = [
+        "auto",
+        "select",
+        "proxy",
+        "节点选择",
+        "自动选择",
+      ];
+      const primaryGroup =
+        proxies.groups.find((group: { name: string }) =>
+          primaryKeywords.some((keyword) =>
+            group.name.toLowerCase().includes(keyword.toLowerCase()),
+          ),
+        ) || proxies.groups.filter((g: { name: string }) => g.name !== "GLOBAL")[0];
+
+      return primaryGroup?.name || "";
+    };
+    
+    const primaryGroupName = getPrimaryGroupName();
+    
     // 根据模式确定初始组
     if (isGlobalMode) {
-      setState(prev => ({
+      setState((prev) => ({
         ...prev,
         selection: {
           ...prev.selection,
-          group: "GLOBAL"
-        }
+          group: "GLOBAL",
+        },
       }));
     } else if (isDirectMode) {
-      setState(prev => ({
+      setState((prev) => ({
         ...prev,
         selection: {
           ...prev.selection,
-          group: "DIRECT"
-        }
+          group: "DIRECT",
+        },
       }));
     } else {
       const savedGroup = localStorage.getItem(STORAGE_KEY_GROUP);
-      setState(prev => ({
+      setState((prev) => ({
         ...prev,
         selection: {
           ...prev.selection,
-          group: savedGroup || primaryGroupName || ""
-        }
+          group: savedGroup || primaryGroupName || "",
+        },
       }));
     }
-  }, [isGlobalMode, isDirectMode, primaryGroupName]);
+  }, [isGlobalMode, isDirectMode, proxies]);
 
-  // 带锁的代理数据获取函数，防止并发请求
-  const fetchProxyData = useCallback(async (force = false) => {
-    // 防止重复请求
-    if (isRefreshingRef.current) {
-      pendingRefreshRef.current = true;
-      return;
-    }
-
-    // 检查刷新间隔
-    const now = Date.now();
-    if (!force && now - lastRefreshRef.current < 1000) {
-      return;
-    }
-
-    isRefreshingRef.current = true;
-    lastRefreshRef.current = now;
-    
-    try {
-      const data = await getProxies();
+  // 监听代理数据变化，更新状态
+  useEffect(() => {
+    if (!proxies) return;
     
+    // 使用函数式更新确保状态更新的原子性
+    setState((prev) => {
       // 过滤和格式化组
-      const filteredGroups = data.groups
-        .filter(g => g.name !== "DIRECT" && g.name !== "REJECT")
-        .map(g => ({
+      const filteredGroups = proxies.groups
+        .filter((g: { name: string }) => g.name !== "DIRECT" && g.name !== "REJECT")
+        .map((g: { name: string; now: string; all: Array<{ name: string }> }) => ({
           name: g.name,
           now: g.now || "",
-          all: g.all.map(p => p.name),
+          all: g.all.map((p: { name: string }) => p.name),
         }));
       
-      // 使用函数式更新确保状态更新的原子性
-      setState(prev => {
-        let newProxy = "";
-        let newDisplayProxy = null;
-        let newGroup = prev.selection.group;
+      let newProxy = "";
+      let newDisplayProxy = null;
+      let newGroup = prev.selection.group;
 
-        // 根据模式确定新代理
-        if (isDirectMode) {
-          newGroup = "DIRECT";
-          newProxy = "DIRECT";
-          newDisplayProxy = data.records?.DIRECT || null;
-        } else if (isGlobalMode && data.global) {
-          newGroup = "GLOBAL";
-          newProxy = data.global.now || "";
-          newDisplayProxy = data.records?.[newProxy] || null;
-        } else {
-          // 普通模式 - 检查当前选择的组是否存在
-          const currentGroup = filteredGroups.find(g => g.name === prev.selection.group);
+      // 根据模式确定新代理
+      if (isDirectMode) {
+        newGroup = "DIRECT";
+        newProxy = "DIRECT";
+        newDisplayProxy = proxies.records?.DIRECT || null;
+      } else if (isGlobalMode && proxies.global) {
+        newGroup = "GLOBAL";
+        newProxy = proxies.global.now || "";
+        newDisplayProxy = proxies.records?.[newProxy] || null;
+      } else {
+        // 普通模式 - 检查当前选择的组是否存在
+        const currentGroup = filteredGroups.find(
+          (g: { name: string }) => g.name === prev.selection.group,
+        );
 
-          // 如果当前组不存在或为空，自动选择第一个组
-          if (!currentGroup && filteredGroups.length > 0) {
-            newGroup = filteredGroups[0].name;
-            const firstGroup = filteredGroups[0];
-            newProxy = firstGroup.now;
-            newDisplayProxy = data.records?.[newProxy] || null;
+        // 如果当前组不存在或为空，自动选择第一个组
+        if (!currentGroup && filteredGroups.length > 0) {
+          newGroup = filteredGroups[0].name;
+          const firstGroup = filteredGroups[0];
+          newProxy = firstGroup.now;
+          newDisplayProxy = proxies.records?.[newProxy] || null;
 
-            // 保存到本地存储
-            if (!isGlobalMode && !isDirectMode) {
-              localStorage.setItem(STORAGE_KEY_GROUP, newGroup);
-              if (newProxy) {
-                localStorage.setItem(STORAGE_KEY_PROXY, newProxy);
-              }
+          // 保存到本地存储
+          if (!isGlobalMode && !isDirectMode) {
+            localStorage.setItem(STORAGE_KEY_GROUP, newGroup);
+            if (newProxy) {
+              localStorage.setItem(STORAGE_KEY_PROXY, newProxy);
             }
-          } else if (currentGroup) {
-            // 使用当前组的代理
-            newProxy = currentGroup.now;
-            newDisplayProxy = data.records?.[newProxy] || null;
           }
+        } else if (currentGroup) {
+          // 使用当前组的代理
+          newProxy = currentGroup.now;
+          newDisplayProxy = proxies.records?.[newProxy] || null;
         }
+      }
 
-        // 返回新状态
+      // 返回新状态
+      return {
+        proxyData: {
+          groups: filteredGroups,
+          records: proxies.records || {},
+          globalProxy: proxies.global?.now || "",
+          directProxy: proxies.records?.DIRECT || null,
+        },
+        selection: {
+          group: newGroup,
+          proxy: newProxy,
+        },
+        displayProxy: newDisplayProxy,
+      };
+    });
+  }, [proxies, isGlobalMode, isDirectMode]);
+
+  // 使用防抖包装状态更新，避免快速连续更新，增加防抖时间
+  const debouncedSetState = useCallback(
+    debounce((updateFn: (prev: ProxyState) => ProxyState) => {
+      setState(updateFn);
+    }, 300),
+    [],
+  );
+
+  // 处理代理组变更
+  const handleGroupChange = useCallback(
+    (event: SelectChangeEvent) => {
+      if (isGlobalMode || isDirectMode) return;
+
+      const newGroup = event.target.value;
+
+      // 保存到本地存储
+      localStorage.setItem(STORAGE_KEY_GROUP, newGroup);
+
+      // 获取该组当前选中的代理
+      setState((prev) => {
+        const group = prev.proxyData.groups.find((g: { name: string }) => g.name === newGroup);
+        if (group) {
+          return {
+            ...prev,
+            selection: {
+              group: newGroup,
+              proxy: group.now,
+            },
+            displayProxy: prev.proxyData.records[group.now] || null,
+          };
+        }
         return {
-          proxyData: {
-            groups: filteredGroups,
-            records: data.records || {},
-            globalProxy: data.global?.now || "",
-            directProxy: data.records?.DIRECT || null,
-          },
+          ...prev,
           selection: {
+            ...prev.selection,
             group: newGroup,
-            proxy: newProxy
           },
-          displayProxy: newDisplayProxy
         };
       });
-    } catch (error) {
-      console.error("获取代理信息失败", error);
-    } finally {
-      isRefreshingRef.current = false;
+    },
+    [isGlobalMode, isDirectMode],
+  );
 
-      // 处理待处理的刷新请求
-      if (pendingRefreshRef.current) {
-        pendingRefreshRef.current = false;
-        setTimeout(() => fetchProxyData(), 100);
+  // 处理代理节点变更
+  const handleProxyChange = useCallback(
+    async (event: SelectChangeEvent) => {
+      if (isDirectMode) return;
+
+      const newProxy = event.target.value;
+      const currentGroup = state.selection.group;
+      const previousProxy = state.selection.proxy;
+
+      // 立即更新UI，优化体验
+      debouncedSetState((prev: ProxyState) => ({
+        ...prev,
+        selection: {
+          ...prev.selection,
+          proxy: newProxy,
+        },
+        displayProxy: prev.proxyData.records[newProxy] || null,
+      }));
+
+      // 非特殊模式下保存到本地存储
+      if (!isGlobalMode && !isDirectMode) {
+        localStorage.setItem(STORAGE_KEY_PROXY, newProxy);
       }
-    }
-  }, [isGlobalMode, isDirectMode]);
 
-  // 响应 currentProxy 变化
-  useEffect(() => {
-    if (currentProxy && (!state.displayProxy || currentProxy.name !== state.displayProxy.name)) {
-      fetchProxyData(true);
-    }
-  }, [currentProxy, fetchProxyData, state.displayProxy]);
+      try {
+        // 更新代理设置
+        await updateProxy(currentGroup, newProxy);
 
-  // 平滑的定期刷新，使用固定间隔
-  useEffect(() => {
-    fetchProxyData();
+        // 自动关闭连接设置
+        if (verge?.auto_close_connection && previousProxy) {
+          connections.data.forEach((conn: any) => {
+            if (conn.chains.includes(previousProxy)) {
+              deleteConnection(conn.id);
+            }
+          });
+        }
 
-    const intervalId = setInterval(() => {
-      fetchProxyData();
-    }, 3000); // 使用固定的3秒间隔，平衡响应速度和性能
+        // 延长刷新延迟时间
+        setTimeout(() => {
+          refreshProxy();
+        }, 500);
+      } catch (error) {
+        console.error("更新代理失败", error);
+      }
+    },
+    [
+      isDirectMode,
+      isGlobalMode,
+      state.proxyData.records,
+      state.selection,
+      verge?.auto_close_connection,
+      refreshProxy,
+      debouncedSetState,
+      connections.data,
+    ],
+  );
 
-    return () => clearInterval(intervalId);
-  }, [fetchProxyData]);
+  // 导航到代理页面
+  const goToProxies = useCallback(() => {
+    navigate("/");
+  }, [navigate]);
+
+  // 获取要显示的代理节点
+  const currentProxy = useMemo(() => {
+    // 从state中获取当前代理信息
+    return state.displayProxy;
+  }, [state.displayProxy]);
+
+  // 获取当前节点的延迟
+  const currentDelay = currentProxy
+    ? delayManager.getDelayFix(currentProxy, state.selection.group)
+    : -1;
+
+  // 获取信号图标
+  const signalInfo = getSignalIcon(currentDelay);
+
+  // 自定义渲染选择框中的值
+  const renderProxyValue = useCallback(
+    (selected: string) => {
+      if (!selected || !state.proxyData.records[selected]) return selected;
+
+      const delayValue = delayManager.getDelayFix(
+        state.proxyData.records[selected],
+        state.selection.group,
+      );
+
+      return (
+        <Box sx={{ display: "flex", justifyContent: "space-between" }}>
+          <Typography noWrap>{selected}</Typography>
+          <Chip
+            size="small"
+            label={delayManager.formatDelay(delayValue)}
+            color={convertDelayColor(delayValue)}
+          />
+        </Box>
+      );
+    },
+    [state.proxyData.records, state.selection.group],
+  );
 
   // 计算要显示的代理选项 - 使用 useMemo 优化
   const proxyOptions = useMemo(() => {
@@ -285,160 +407,37 @@ export const CurrentProxyCard = () => {
     if (isGlobalMode && state.proxyData.records) {
       // 全局模式下的选项
       return Object.keys(state.proxyData.records)
-        .filter(name => name !== "DIRECT" && name !== "REJECT")
-        .map(name => ({ name }));
+        .filter((name) => name !== "DIRECT" && name !== "REJECT")
+        .map((name) => ({ name }));
     }
 
     // 普通模式
-    const group = state.proxyData.groups.find(g => g.name === state.selection.group);
+    const group = state.proxyData.groups.find(
+      (g: { name: string }) => g.name === state.selection.group,
+    );
     if (group) {
-      return group.all.map(name => ({ name }));
+      return group.all.map((name) => ({ name }));
     }
     return [];
   }, [isDirectMode, isGlobalMode, state.proxyData, state.selection.group]);
 
-  // 使用防抖包装状态更新，避免快速连续更新
-  const debouncedSetState = useCallback(
-    debounce((updateFn: (prev: ProxyState) => ProxyState) => {
-      setState(updateFn);
-    }, 50),
-    []
-  );
-
-  // 处理代理组变更
-  const handleGroupChange = useCallback((event: SelectChangeEvent) => {
-    if (isGlobalMode || isDirectMode) return;
-    
-    const newGroup = event.target.value;
-    
-    // 保存到本地存储
-    localStorage.setItem(STORAGE_KEY_GROUP, newGroup);
-    
-    // 获取该组当前选中的代理
-    setState(prev => {
-      const group = prev.proxyData.groups.find(g => g.name === newGroup);
-      if (group) {
-        return {
-          ...prev,
-          selection: {
-            group: newGroup,
-            proxy: group.now
-          },
-          displayProxy: prev.proxyData.records[group.now] || null
-        };
-      }
-      return {
-        ...prev,
-        selection: {
-          ...prev.selection,
-          group: newGroup
-        }
-      };
-    });
-  }, [isGlobalMode, isDirectMode]);
-
-  // 处理代理节点变更
-  const handleProxyChange = useCallback(async (event: SelectChangeEvent) => {
-    if (isDirectMode) return;
-    
-    const newProxy = event.target.value;
-    const currentGroup = state.selection.group;
-    const previousProxy = state.selection.proxy;
-    
-    // 立即更新UI，优化体验
-    debouncedSetState((prev: ProxyState) => ({
-      ...prev,
-      selection: {
-        ...prev.selection,
-        proxy: newProxy
-      },
-      displayProxy: prev.proxyData.records[newProxy] || null
-    }));
-    
-    // 非特殊模式下保存到本地存储
-    if (!isGlobalMode && !isDirectMode) {
-      localStorage.setItem(STORAGE_KEY_PROXY, newProxy);
-    }
-    
-    try {
-      // 更新代理设置
-      await updateProxy(currentGroup, newProxy);
-      
-      // 自动关闭连接设置
-      if (verge?.auto_close_connection && previousProxy) {
-        getConnections().then(({ connections }) => {
-          connections.forEach(conn => {
-            if (conn.chains.includes(previousProxy)) {
-              deleteConnection(conn.id);
-            }
-          });
-        });
-      }
-      
-      // 刷新代理信息，使用较短的延迟
-      setTimeout(() => {
-        refreshProxy();
-        fetchProxyData(true);
-      }, 200);
-    } catch (error) {
-      console.error("更新代理失败", error);
-    }
-  }, [isDirectMode, isGlobalMode, state.proxyData.records, state.selection, verge?.auto_close_connection, refreshProxy, fetchProxyData, debouncedSetState]);
-
-  // 导航到代理页面
-  const goToProxies = useCallback(() => {
-    navigate("/");
-  }, [navigate]);
-
-  // 获取要显示的代理节点
-  const proxyToDisplay = state.displayProxy || currentProxy;
-  
-  // 获取当前节点的延迟
-  const currentDelay = proxyToDisplay
-    ? delayManager.getDelayFix(proxyToDisplay, state.selection.group)
-    : -1;
-  
-  // 获取信号图标
-  const signalInfo = getSignalIcon(currentDelay);
-
-  // 自定义渲染选择框中的值
-  const renderProxyValue = useCallback((selected: string) => {
-    if (!selected || !state.proxyData.records[selected]) return selected;
-
-    const delayValue = delayManager.getDelayFix(
-      state.proxyData.records[selected],
-      state.selection.group
-    );
-
-    return (
-      <Box sx={{ display: "flex", justifyContent: "space-between" }}>
-        <Typography noWrap>{selected}</Typography>
-        <Chip
-          size="small"
-          label={delayManager.formatDelay(delayValue)}
-          color={convertDelayColor(delayValue)}
-        />
-      </Box>
-    );
-  }, [state.proxyData.records, state.selection.group]);
-
   return (
     <EnhancedCard
       title={t("Current Node")}
       icon={
         <Tooltip
           title={
-            proxyToDisplay
+            currentProxy
               ? `${signalInfo.text}: ${delayManager.formatDelay(currentDelay)}`
               : "无代理节点"
           }
         >
           <Box sx={{ color: signalInfo.color }}>
-            {proxyToDisplay ? signalInfo.icon : <SignalNone color="disabled" />}
+            {currentProxy ? signalInfo.icon : <SignalNone color="disabled" />}
           </Box>
         </Tooltip>
       }
-      iconColor={proxyToDisplay ? "primary" : undefined}
+      iconColor={currentProxy ? "primary" : undefined}
       action={
         <Button
           variant="outlined"
@@ -451,7 +450,7 @@ export const CurrentProxyCard = () => {
         </Button>
       }
     >
-      {proxyToDisplay ? (
+      {currentProxy ? (
         <Box>
           {/* 代理节点信息显示 */}
           <Box
@@ -468,30 +467,56 @@ export const CurrentProxyCard = () => {
           >
             <Box>
               <Typography variant="body1" fontWeight="medium">
-                {proxyToDisplay.name}
+                {currentProxy.name}
               </Typography>
 
-              <Box sx={{ display: "flex", alignItems: "center", flexWrap: "wrap" }}>
-                <Typography variant="caption" color="text.secondary" sx={{ mr: 1 }}>
-                  {proxyToDisplay.type}
+              <Box
+                sx={{ display: "flex", alignItems: "center", flexWrap: "wrap" }}
+              >
+                <Typography
+                  variant="caption"
+                  color="text.secondary"
+                  sx={{ mr: 1 }}
+                >
+                  {currentProxy.type}
                 </Typography>
                 {isGlobalMode && (
-                  <Chip size="small" label={t("Global Mode")} color="primary" sx={{ mr: 0.5 }} />
+                  <Chip
+                    size="small"
+                    label={t("Global Mode")}
+                    color="primary"
+                    sx={{ mr: 0.5 }}
+                  />
                 )}
                 {isDirectMode && (
-                  <Chip size="small" label={t("Direct Mode")} color="success" sx={{ mr: 0.5 }} />
+                  <Chip
+                    size="small"
+                    label={t("Direct Mode")}
+                    color="success"
+                    sx={{ mr: 0.5 }}
+                  />
                 )}
                 {/* 节点特性 */}
-                {proxyToDisplay.udp && <Chip size="small" label="UDP" variant="outlined" />}
-                {proxyToDisplay.tfo && <Chip size="small" label="TFO" variant="outlined" />}
-                {proxyToDisplay.xudp && <Chip size="small" label="XUDP" variant="outlined" />}
-                {proxyToDisplay.mptcp && <Chip size="small" label="MPTCP" variant="outlined" />}
-                {proxyToDisplay.smux && <Chip size="small" label="SMUX" variant="outlined" />}
+                {currentProxy.udp && (
+                  <Chip size="small" label="UDP" variant="outlined" />
+                )}
+                {currentProxy.tfo && (
+                  <Chip size="small" label="TFO" variant="outlined" />
+                )}
+                {currentProxy.xudp && (
+                  <Chip size="small" label="XUDP" variant="outlined" />
+                )}
+                {currentProxy.mptcp && (
+                  <Chip size="small" label="MPTCP" variant="outlined" />
+                )}
+                {currentProxy.smux && (
+                  <Chip size="small" label="SMUX" variant="outlined" />
+                )}
               </Box>
             </Box>
 
             {/* 显示延迟 */}
-            {proxyToDisplay && !isDirectMode && (
+            {currentProxy && !isDirectMode && (
               <Chip
                 size="small"
                 label={delayManager.formatDelay(currentDelay)}
@@ -500,7 +525,12 @@ export const CurrentProxyCard = () => {
             )}
           </Box>
           {/* 代理组选择器 */}
-          <FormControl fullWidth variant="outlined" size="small" sx={{ mb: 1.5 }}>
+          <FormControl
+            fullWidth
+            variant="outlined"
+            size="small"
+            sx={{ mb: 1.5 }}
+          >
             <InputLabel id="proxy-group-select-label">{t("Group")}</InputLabel>
             <Select
               labelId="proxy-group-select-label"
@@ -535,39 +565,41 @@ export const CurrentProxyCard = () => {
                 },
               }}
             >
-              {proxyOptions.map((proxy) => {
-                const delayValue = delayManager.getDelayFix(
-                  state.proxyData.records[proxy.name],
-                  state.selection.group
-                );
-                return (
-                  <MenuItem
-                    key={proxy.name}
-                    value={proxy.name}
-                    sx={{
-                      display: "flex",
-                      justifyContent: "space-between",
-                      alignItems: "center",
-                      width: "100%",
-                      pr: 1,
-                    }}
-                  >
-                    <Typography noWrap sx={{ flex: 1, mr: 1 }}>
-                      {proxy.name}
-                    </Typography>
-                    <Chip
-                      size="small"
-                      label={delayManager.formatDelay(delayValue)}
-                      color={convertDelayColor(delayValue)}
-                      sx={{
-                        minWidth: "60px",
-                        height: "22px",
-                        flexShrink: 0,
-                      }}
-                    />
-                  </MenuItem>
-                );
-              })}
+              {isDirectMode
+                ? null
+                : proxyOptions.map((proxy, index) => {
+                    const delayValue = delayManager.getDelayFix(
+                      state.proxyData.records[proxy.name],
+                      state.selection.group,
+                    );
+                    return (
+                      <MenuItem
+                        key={`${proxy.name}-${index}`}
+                        value={proxy.name}
+                        sx={{
+                          display: "flex",
+                          justifyContent: "space-between",
+                          alignItems: "center",
+                          width: "100%",
+                          pr: 1,
+                        }}
+                      >
+                        <Typography noWrap sx={{ flex: 1, mr: 1 }}>
+                          {proxy.name}
+                        </Typography>
+                        <Chip
+                          size="small"
+                          label={delayManager.formatDelay(delayValue)}
+                          color={convertDelayColor(delayValue)}
+                          sx={{
+                            minWidth: "60px",
+                            height: "22px",
+                            flexShrink: 0,
+                          }}
+                        />
+                      </MenuItem>
+                    );
+                  })}
             </Select>
           </FormControl>
         </Box>

src/components/home/enhanced-card.tsx

@@ -31,6 +31,16 @@ export const EnhancedCard = ({
   const theme = useTheme();
   const isDark = theme.palette.mode === "dark";
 
+  // 统一的标题截断样式
+  const titleTruncateStyle = {
+    minWidth: 0,
+    maxWidth: "100%",
+    overflow: "hidden",
+    textOverflow: "ellipsis",
+    whiteSpace: "nowrap",
+    display: "block"
+  };
+
   return (
     <Box
       sx={{
@@ -52,7 +62,13 @@ export const EnhancedCard = ({
           borderColor: "divider",
         }}
       >
-        <Box sx={{ display: "flex", alignItems: "center" }}>
+        <Box sx={{ 
+          display: "flex", 
+          alignItems: "center", 
+          minWidth: 0, 
+          flex: 1,
+          overflow: "hidden"
+        }}>
           <Box
             sx={{
               display: "flex",
@@ -62,21 +78,32 @@ export const EnhancedCard = ({
               width: 38,
               height: 38,
               mr: 1.5,
+              flexShrink: 0,
               backgroundColor: alpha(theme.palette[iconColor].main, 0.12),
               color: theme.palette[iconColor].main,
             }}
           >
             {icon}
           </Box>
-          {typeof title === "string" ? (
-            <Typography variant="h6" fontWeight="medium" fontSize={18}>
-              {title}
-            </Typography>
-          ) : (
-            title
-          )}
+          <Box sx={{ minWidth: 0, flex: 1 }}>
+            {typeof title === "string" ? (
+              <Typography 
+                variant="h6" 
+                fontWeight="medium" 
+                fontSize={18}
+                sx={titleTruncateStyle}
+                title={title}
+              >
+                {title}
+              </Typography>
+            ) : (
+              <Box sx={titleTruncateStyle}>
+                {title}
+              </Box>
+            )}
+          </Box>
         </Box>
-        {action}
+        {action && <Box sx={{ ml: 2, flexShrink: 0 }}>{action}</Box>}
       </Box>
       <Box
         sx={{

src/components/home/enhanced-traffic-graph.tsx

@@ -39,69 +39,35 @@ export interface EnhancedTrafficGraphRef {
 // 时间范围类型
 type TimeRange = 1 | 5 | 10; // 分钟
 
-// 创建一个明确的类型
+// 数据点类型
 type DataPoint = ITrafficItem & { name: string; timestamp: number };
 
-// 控制帧率的工具函数
-const FPS_LIMIT = 1; // 限制为1fps，因为数据每秒才更新一次
-const FRAME_MIN_TIME = 1000 / FPS_LIMIT; // 每帧最小时间间隔，即1000ms
-
-// 全局存储流量数据历史记录
-declare global {
-  interface Window {
-    trafficHistoryData?: DataPoint[];
-    trafficHistoryStyle?: "line" | "area";
-    trafficHistoryTimeRange?: TimeRange;
-  }
-}
-
-// 初始化全局存储
-if (typeof window !== "undefined" && !window.trafficHistoryData) {
-  window.trafficHistoryData = [];
-  window.trafficHistoryStyle = "area";
-  window.trafficHistoryTimeRange = 10;
-}
-
 /**
  * 增强型流量图表组件
- * 基于 Recharts 实现，支持线图和面积图两种模式
  */
 export const EnhancedTrafficGraph = memo(forwardRef<EnhancedTrafficGraphRef>(
   (props, ref) => {
     const theme = useTheme();
     const { t } = useTranslation();
 
-    // 从全局变量恢复状态
-    const [timeRange, setTimeRange] = useState<TimeRange>(
-      window.trafficHistoryTimeRange || 10
-    );
-    const [chartStyle, setChartStyle] = useState<"line" | "area">(
-      window.trafficHistoryStyle || "area"
-    );
-    
-    // 使用useRef存储数据，避免不必要的重渲染
-    const dataBufferRef = useRef<DataPoint[]>([]);
-    // 只为渲染目的的状态
+    // 基础状态
+    const [timeRange, setTimeRange] = useState<TimeRange>(10);
+    const [chartStyle, setChartStyle] = useState<"line" | "area">("area");
     const [displayData, setDisplayData] = useState<DataPoint[]>([]);
     
-    // 帧率控制
-    const lastUpdateTimeRef = useRef<number>(0);
-    const pendingUpdateRef = useRef<boolean>(false);
-    const rafIdRef = useRef<number | null>(null);
+    // 数据缓冲区
+    const dataBufferRef = useRef<DataPoint[]>([]);
 
     // 根据时间范围计算保留的数据点数量
     const getMaxPointsByTimeRange = useCallback(
-      (minutes: TimeRange): number => {
-        // 使用更低的采样率来减少点的数量，每2秒一个点而不是每秒一个点
-        return minutes * 30; // 每分钟30个点(每2秒1个点)
-      },
-      [],
+      (minutes: TimeRange): number => minutes * 60,
+      []
     );
 
-    // 最大数据点数量 - 基于选择的时间范围
+    // 最大数据点数量
     const MAX_BUFFER_SIZE = useMemo(
       () => getMaxPointsByTimeRange(10),
-      [getMaxPointsByTimeRange],
+      [getMaxPointsByTimeRange]
     );
 
     // 颜色配置
@@ -113,149 +79,50 @@ export const EnhancedTrafficGraph = memo(forwardRef<EnhancedTrafficGraphRef>(
         tooltip: theme.palette.background.paper,
         text: theme.palette.text.primary,
       }),
-      [theme],
+      [theme]
     );
 
     // 切换时间范围
     const handleTimeRangeClick = useCallback(() => {
       setTimeRange((prevRange) => {
         // 在1、5、10分钟之间循环切换
-        const newRange = prevRange === 1 ? 5 : prevRange === 5 ? 10 : 1;
-        window.trafficHistoryTimeRange = newRange; // 保存到全局
-        return newRange;
+        return prevRange === 1 ? 5 : prevRange === 5 ? 10 : 1;
       });
     }, []);
 
     // 初始化数据缓冲区
     useEffect(() => {
-      let initialBuffer: DataPoint[] = [];
+      // 创建初始空数据
+      const now = Date.now();
+      const tenMinutesAgo = now - 10 * 60 * 1000;
 
-      // 如果全局有保存的数据，优先使用
-      if (window.trafficHistoryData && window.trafficHistoryData.length > 0) {
-        initialBuffer = [...window.trafficHistoryData];
+      const initialBuffer = Array.from(
+        { length: MAX_BUFFER_SIZE },
+        (_, index) => {
+          const pointTime =
+            tenMinutesAgo + index * ((10 * 60 * 1000) / MAX_BUFFER_SIZE);
+          const date = new Date(pointTime);
 
-        // 确保数据长度符合要求
-        if (initialBuffer.length > MAX_BUFFER_SIZE) {
-          initialBuffer = initialBuffer.slice(-MAX_BUFFER_SIZE);
-        } else if (initialBuffer.length < MAX_BUFFER_SIZE) {
-          // 如果历史数据不足，则在前面补充空数据
-          const now = Date.now();
-          const oldestTimestamp = initialBuffer.length > 0 
-            ? initialBuffer[0].timestamp 
-            : now - 10 * 60 * 1000;
-          
-          const additionalPoints = MAX_BUFFER_SIZE - initialBuffer.length;
-          const timeInterval = initialBuffer.length > 0
-            ? (initialBuffer[0].timestamp - (now - 10 * 60 * 1000)) / additionalPoints
-            : (10 * 60 * 1000) / MAX_BUFFER_SIZE;
-          
-          const emptyPrefix: DataPoint[] = Array.from(
-            { length: additionalPoints },
-            (_, index) => {
-              const pointTime = oldestTimestamp - (additionalPoints - index) * timeInterval;
-              const date = new Date(pointTime);
-              
-              return {
-                up: 0,
-                down: 0,
-                timestamp: pointTime,
-                name: date.toLocaleTimeString("en-US", {
-                  hour12: false,
-                  hour: "2-digit",
-                  minute: "2-digit",
-                  second: "2-digit",
-                }),
-              };
-            }
-          );
-          
-          initialBuffer = [...emptyPrefix, ...initialBuffer];
+          return {
+            up: 0,
+            down: 0,
+            timestamp: pointTime,
+            name: date.toLocaleTimeString("en-US", {
+              hour12: false,
+              hour: "2-digit",
+              minute: "2-digit",
+              second: "2-digit",
+            }),
+          };
         }
-      } else {
-        // 没有历史数据时，创建空的初始缓冲区
-        const now = Date.now();
-        const tenMinutesAgo = now - 10 * 60 * 1000;
-
-        initialBuffer = Array.from(
-          { length: MAX_BUFFER_SIZE },
-          (_, index) => {
-            const pointTime =
-              tenMinutesAgo + index * ((10 * 60 * 1000) / MAX_BUFFER_SIZE);
-            const date = new Date(pointTime);
-
-            return {
-              up: 0,
-              down: 0,
-              timestamp: pointTime,
-              name: date.toLocaleTimeString("en-US", {
-                hour12: false,
-                hour: "2-digit",
-                minute: "2-digit",
-                second: "2-digit",
-              }),
-            };
-          }
-        );
-      }
+      );
 
       dataBufferRef.current = initialBuffer;
-      window.trafficHistoryData = initialBuffer; // 保存到全局
       
       // 更新显示数据
       const pointsToShow = getMaxPointsByTimeRange(timeRange);
       setDisplayData(initialBuffer.slice(-pointsToShow));
-      
-      // 清理函数，取消任何未完成的动画帧
-      return () => {
-        if (rafIdRef.current !== null) {
-          cancelAnimationFrame(rafIdRef.current);
-          rafIdRef.current = null;
-        }
-      };
-    }, [MAX_BUFFER_SIZE, getMaxPointsByTimeRange, timeRange]);
-
-    // 处理数据更新并控制帧率的函数
-    const updateDisplayData = useCallback(() => {
-      if (pendingUpdateRef.current) {
-        pendingUpdateRef.current = false;
-        
-        // 根据当前时间范围计算需要显示的点数
-        const pointsToShow = getMaxPointsByTimeRange(timeRange);
-        // 从缓冲区中获取最新的数据点
-        const newDisplayData = dataBufferRef.current.slice(-pointsToShow);
-        setDisplayData(newDisplayData);
-      }
-      
-      rafIdRef.current = null;
-    }, [timeRange, getMaxPointsByTimeRange]);
-    
-    // 节流更新函数
-    const throttledUpdateData = useCallback(() => {
-      pendingUpdateRef.current = true;
-      
-      const now = performance.now();
-      const timeSinceLastUpdate = now - lastUpdateTimeRef.current;
-      
-      if (rafIdRef.current === null) {
-        if (timeSinceLastUpdate >= FRAME_MIN_TIME) {
-          // 如果距离上次更新已经超过最小帧时间，立即更新
-          lastUpdateTimeRef.current = now;
-          rafIdRef.current = requestAnimationFrame(updateDisplayData);
-        } else {
-          // 否则，在适当的时间进行更新
-          const timeToWait = FRAME_MIN_TIME - timeSinceLastUpdate;
-          setTimeout(() => {
-            lastUpdateTimeRef.current = performance.now();
-            rafIdRef.current = requestAnimationFrame(updateDisplayData);
-          }, timeToWait);
-        }
-      }
-    }, [updateDisplayData]);
-
-    // 监听时间范围变化，更新显示数据
-    useEffect(() => {
-      throttledUpdateData();
-    }, [timeRange, throttledUpdateData]);
+    }, [MAX_BUFFER_SIZE, getMaxPointsByTimeRange]);
 
     // 添加数据点方法
     const appendData = useCallback((data: ITrafficItem) => {
@@ -281,24 +148,24 @@ export const EnhancedTrafficGraph = memo(forwardRef<EnhancedTrafficGraphRef>(
         timestamp: timestamp,
       };
 
-      // 更新ref，但保持原数组大小
+      // 更新缓冲区，保持原数组大小
       const newBuffer = [...dataBufferRef.current.slice(1), newPoint];
       dataBufferRef.current = newBuffer;
       
-      // 保存到全局变量
-      window.trafficHistoryData = newBuffer;
+      // 更新显示数据
+      const pointsToShow = getMaxPointsByTimeRange(timeRange);
+      setDisplayData(newBuffer.slice(-pointsToShow));
+    }, [timeRange, getMaxPointsByTimeRange]);
 
-      // 使用节流更新显示数据
-      throttledUpdateData();
-    }, [throttledUpdateData]);
+    // 监听时间范围变化，更新显示数据
+    useEffect(() => {
+      const pointsToShow = getMaxPointsByTimeRange(timeRange);
+      setDisplayData(dataBufferRef.current.slice(-pointsToShow));
+    }, [timeRange, getMaxPointsByTimeRange]);
 
     // 切换图表样式
     const toggleStyle = useCallback(() => {
-      setChartStyle((prev) => {
-        const newStyle = prev === "line" ? "area" : "line";
-        window.trafficHistoryStyle = newStyle; // 保存到全局
-        return newStyle;
-      });
+      setChartStyle((prev) => prev === "line" ? "area" : "line");
     }, []);
 
     // 暴露方法给父组件
@@ -308,13 +175,12 @@ export const EnhancedTrafficGraph = memo(forwardRef<EnhancedTrafficGraphRef>(
         appendData,
         toggleStyle,
       }),
-      [appendData, toggleStyle],
+      [appendData, toggleStyle]
     );
 
     // 格式化工具提示内容
     const formatTooltip = useCallback((value: number, name: string, props: any) => {
       const [num, unit] = parseTraffic(value);
-      // 使用props.dataKey判断是上传还是下载
       return [`${num} ${unit}/s`, props?.dataKey === "up" ? t("Upload") : t("Download")];
     }, [t]);
 
@@ -327,7 +193,6 @@ export const EnhancedTrafficGraph = memo(forwardRef<EnhancedTrafficGraphRef>(
     // 格式化X轴标签
     const formatXLabel = useCallback((value: string) => {
       if (!value) return "";
-      // 只显示小时和分钟
       const parts = value.split(":");
       return `${parts[0]}:${parts[1]}`;
     }, []);
@@ -340,7 +205,7 @@ export const EnhancedTrafficGraph = memo(forwardRef<EnhancedTrafficGraphRef>(
     // 共享图表配置
     const chartConfig = useMemo(() => ({
       data: displayData,
-      margin: { top: 10, right: 20, left: 0, bottom: 0 },
+      margin: { top: 20, right: 10, left: 0, bottom: -10 },
     }), [displayData]);
 
     // 共享的线条/区域配置
@@ -352,7 +217,7 @@ export const EnhancedTrafficGraph = memo(forwardRef<EnhancedTrafficGraphRef>(
       isAnimationActive: false, // 禁用动画以减少CPU使用
     }), []);
 
-    // 曲线类型 - 使用线性曲线避免错位
+    // 曲线类型
     const curveType = "monotone";
 
     return (
@@ -363,186 +228,138 @@ export const EnhancedTrafficGraph = memo(forwardRef<EnhancedTrafficGraphRef>(
           position: "relative",
           bgcolor: "action.hover",
           borderRadius: 1,
-          padding: 1,
           cursor: "pointer",
         }}
         onClick={toggleStyle}
       >
         <ResponsiveContainer width="100%" height="100%">
-          {chartStyle === "line" ? (
-            <LineChart {...chartConfig}>
-              <CartesianGrid strokeDasharray="3 3" vertical={false} stroke={colors.grid} opacity={0.3} />
-              <XAxis
-                dataKey="name"
-                tick={{ fontSize: 10, fill: colors.text }}
-                tickLine={{ stroke: colors.grid }}
-                axisLine={{ stroke: colors.grid }}
-                interval="preserveStart"
-                tickFormatter={formatXLabel}
-                minTickGap={30}
-              />
-              <YAxis
-                tickFormatter={formatYAxis}
-                tick={{ fontSize: 10, fill: colors.text }}
-                tickLine={{ stroke: colors.grid }}
-                axisLine={{ stroke: colors.grid }}
-                width={40}
-                domain={[0, "auto"]}
-              />
-              <Tooltip
-                formatter={formatTooltip}
-                labelFormatter={(label) => `${t("Time")}: ${label}`}
-                contentStyle={{
-                  backgroundColor: colors.tooltip,
-                  borderColor: colors.grid,
-                  borderRadius: 4,
-                }}
-                itemStyle={{ color: colors.text }}
-                isAnimationActive={false}
-              />
-              <Line
-                type={curveType}
-                {...commonLineProps}
-                dataKey="up"
-                name={t("Upload")}
-                stroke={colors.up}
-              />
-              <Line
-                type={curveType}
-                {...commonLineProps}
-                dataKey="down"
-                name={t("Download")}
-                stroke={colors.down}
-              />
+          {/* 根据chartStyle动态选择图表类型 */}
+          {(() => {
+            // 创建共享的图表组件
+            const commonChartComponents = (
+              <>
+                <CartesianGrid strokeDasharray="3 3" vertical={false} stroke={colors.grid} opacity={0.3} />
+                <XAxis
+                  dataKey="name"
+                  tick={{ fontSize: 10, fill: colors.text }}
+                  tickLine={{ stroke: colors.grid }}
+                  axisLine={{ stroke: colors.grid }}
+                  interval="preserveStart"
+                  tickFormatter={formatXLabel}
+                  minTickGap={30}
+                />
+                <YAxis
+                  tickFormatter={formatYAxis}
+                  tick={{ fontSize: 10, fill: colors.text }}
+                  tickLine={{ stroke: colors.grid }}
+                  axisLine={{ stroke: colors.grid }}
+                  width={44}
+                  domain={[0, "auto"]}
+                  padding={{ top: 8, bottom: 0 }}
+                />
+                <Tooltip
+                  formatter={formatTooltip}
+                  labelFormatter={(label) => `${t("Time")}: ${label}`}
+                  contentStyle={{
+                    backgroundColor: colors.tooltip,
+                    borderColor: colors.grid,
+                    borderRadius: 4,
+                  }}
+                  itemStyle={{ color: colors.text }}
+                  isAnimationActive={false}
+                />
                 
-              {/* 可点击的时间范围标签 */}
-              <text
-                x="1%"
-                y="6%"
-                textAnchor="start"
-                fill={theme.palette.text.secondary}
-                fontSize={11}
-                fontWeight="bold"
-                onClick={handleTimeRangeClick}
-                style={{ cursor: "pointer" }}
-              >
-                {getTimeRangeText()}
-              </text>
+                {/* 可点击的时间范围标签 */}
+                <text
+                  x="1%"
+                  y="11%"
+                  textAnchor="start"
+                  fill={theme.palette.text.secondary}
+                  fontSize={11}
+                  fontWeight="bold"
+                  onClick={handleTimeRangeClick}
+                  style={{ cursor: "pointer" }}
+                >
+                  {getTimeRangeText()}
+                </text>
                 
-              {/* 上传标签 - 右上角 */}
-              <text
-                x="98%"
-                y="7%"
-                textAnchor="end"
-                fill={colors.up}
-                fontSize={12}
-                fontWeight="bold"
-              >
-                {t("Upload")}
-              </text>
+                {/* 上传标签 - 右上角 */}
+                <text
+                  x="99%"
+                  y="11%"
+                  textAnchor="end"
+                  fill={colors.up}
+                  fontSize={12}
+                  fontWeight="bold"
+                  onClick={toggleStyle}
+                  style={{ cursor: "pointer" }}
+                >
+                  {t("Upload")}
+                </text>
 
-              {/* 下载标签 - 右上角下方 */}
-              <text
-                x="98%"
-                y="16%"
-                textAnchor="end"
-                fill={colors.down}
-                fontSize={12}
-                fontWeight="bold"
-              >
-                {t("Download")}
-              </text>
-            </LineChart>
-          ) : (
-            <AreaChart {...chartConfig}>
-              <CartesianGrid strokeDasharray="3 3" vertical={false} stroke={colors.grid} opacity={0.3} />
-              <XAxis
-                dataKey="name"
-                tick={{ fontSize: 10, fill: colors.text }}
-                tickLine={{ stroke: colors.grid }}
-                axisLine={{ stroke: colors.grid }}
-                interval="preserveStart"
-                tickFormatter={formatXLabel}
-                minTickGap={30}
-              />
-              <YAxis
-                tickFormatter={formatYAxis}
-                tick={{ fontSize: 10, fill: colors.text }}
-                tickLine={{ stroke: colors.grid }}
-                axisLine={{ stroke: colors.grid }}
-                width={40}
-                domain={[0, "auto"]}
-                padding={{ top: 10, bottom: 0 }}
-              />
-              <Tooltip
-                formatter={formatTooltip}
-                labelFormatter={(label) => `${t("Time")}: ${label}`}
-                contentStyle={{
-                  backgroundColor: colors.tooltip,
-                  borderColor: colors.grid,
-                  borderRadius: 4,
-                }}
-                itemStyle={{ color: colors.text }}
-                isAnimationActive={false}
-              />
-              <Area
-                type={curveType}
-                {...commonLineProps}
-                dataKey="up"
-                name={t("Upload")}
-                stroke={colors.up}
-                fill={colors.up}
-                fillOpacity={0.2}
-              />
-              <Area
-                type={curveType}
-                {...commonLineProps}
-                dataKey="down"
-                name={t("Download")}
-                stroke={colors.down}
-                fill={colors.down}
-                fillOpacity={0.3}
-              />
+                {/* 下载标签 - 右上角下方 */}
+                <text
+                  x="99%"
+                  y="19%"
+                  textAnchor="end"
+                  fill={colors.down}
+                  fontSize={12}
+                  fontWeight="bold"
+                  onClick={toggleStyle}
+                  style={{ cursor: "pointer" }}
+                >
+                  {t("Download")}
+                </text>
+              </>
+            );
 
-              {/* 可点击的时间范围标签 */}
-              <text
-                x="1%"
-                y="6%"
-                textAnchor="start"
-                fill={theme.palette.text.secondary}
-                fontSize={11}
-                fontWeight="bold"
-                onClick={handleTimeRangeClick}
-                style={{ cursor: "pointer" }}
-              >
-                {getTimeRangeText()}
-              </text>
-              
-              {/* 上传标签 - 右上角 */}
-              <text
-                x="98%"
-                y="7%"
-                textAnchor="end"
-                fill={colors.up}
-                fontSize={12}
-                fontWeight="bold"
-              >
-                {t("Upload")}
-              </text>
-
-              {/* 下载标签 - 右上角下方 */}
-              <text
-                x="98%"
-                y="16%"
-                textAnchor="end"
-                fill={colors.down}
-                fontSize={12}
-                fontWeight="bold"
-              >
-                {t("Download")}
-              </text>
-            </AreaChart>
-          )}
+            // 根据chartStyle返回相应的图表类型
+            if (chartStyle === "line") {
+              return (
+                <LineChart {...chartConfig}>
+                  {commonChartComponents}
+                  <Line
+                    type={curveType}
+                    {...commonLineProps}
+                    dataKey="up"
+                    name={t("Upload")}
+                    stroke={colors.up}
+                  />
+                  <Line
+                    type={curveType}
+                    {...commonLineProps}
+                    dataKey="down"
+                    name={t("Download")}
+                    stroke={colors.down}
+                  />
+                </LineChart>
+              );
+            } else {
+              return (
+                <AreaChart {...chartConfig}>
+                  {commonChartComponents}
+                  <Area
+                    type={curveType}
+                    {...commonLineProps}
+                    dataKey="up"
+                    name={t("Upload")}
+                    stroke={colors.up}
+                    fill={colors.up}
+                    fillOpacity={0.2}
+                  />
+                  <Area
+                    type={curveType}
+                    {...commonLineProps}
+                    dataKey="down"
+                    name={t("Download")}
+                    stroke={colors.down}
+                    fill={colors.down}
+                    fillOpacity={0.3}
+                  />
+                </AreaChart>
+              );
+            }
+          })()}
         </ResponsiveContainer>
       </Box>
     );

src/components/home/enhanced-traffic-stats.tsx

@@ -28,6 +28,7 @@ import { createAuthSockette } from "@/utils/websocket";
 import parseTraffic from "@/utils/parse-traffic";
 import { getConnections, isDebugEnabled, gc } from "@/services/api";
 import { ReactNode } from "react";
+import { useAppData } from "@/providers/app-data-provider";
 
 interface MemoryUsage {
   inuse: number;
@@ -157,11 +158,13 @@ export const EnhancedTrafficStats = () => {
   const pageVisible = useVisibility();
   const [isDebug, setIsDebug] = useState(false);
   
+  // 使用AppDataProvider
+  const { connections, uptime } = useAppData();
+  
   // 使用单一状态对象减少状态更新次数
   const [stats, setStats] = useState({
     traffic: { up: 0, down: 0 },
     memory: { inuse: 0, oslimit: undefined as number | undefined },
-    connections: { uploadTotal: 0, downloadTotal: 0, activeConnections: 0 },
   });
 
   // 创建一个标记来追踪最后更新时间，用于节流
@@ -176,36 +179,6 @@ export const EnhancedTrafficStats = () => {
     memory: null as ReturnType<typeof createAuthSockette> | null,
   });
 
-  // 获取连接数据
-  const fetchConnections = useCallback(async () => {
-    if (!pageVisible) return;
-    
-    try {
-      const connections = await getConnections();
-      if (connections) {
-        setStats(prev => ({
-          ...prev,
-          connections: {
-            uploadTotal: connections.uploadTotal || 0,
-            downloadTotal: connections.downloadTotal || 0,
-            activeConnections: connections.connections ? connections.connections.length : 0,
-          }
-        }));
-      }
-    } catch (err) {
-      console.error("Failed to fetch connections:", err);
-    }
-  }, [pageVisible]);
-
-  // 定期更新连接数据
-  useEffect(() => {
-    if (!pageVisible) return;
-    
-    fetchConnections();
-    const intervalId = setInterval(fetchConnections, CONNECTIONS_UPDATE_INTERVAL);
-    return () => clearInterval(intervalId);
-  }, [pageVisible, fetchConnections]);
-
   // 检查是否支持调试
   useEffect(() => {
     isDebugEnabled().then((flag) => setIsDebug(flag));
@@ -328,14 +301,14 @@ export const EnhancedTrafficStats = () => {
     const [up, upUnit] = parseTraffic(stats.traffic.up);
     const [down, downUnit] = parseTraffic(stats.traffic.down);
     const [inuse, inuseUnit] = parseTraffic(stats.memory.inuse);
-    const [uploadTotal, uploadTotalUnit] = parseTraffic(stats.connections.uploadTotal);
-    const [downloadTotal, downloadTotalUnit] = parseTraffic(stats.connections.downloadTotal);
+    const [uploadTotal, uploadTotalUnit] = parseTraffic(connections.uploadTotal);
+    const [downloadTotal, downloadTotalUnit] = parseTraffic(connections.downloadTotal);
     
     return {
       up, upUnit, down, downUnit, inuse, inuseUnit,
       uploadTotal, uploadTotalUnit, downloadTotal, downloadTotalUnit
     };
-  }, [stats]);
+  }, [stats, connections.uploadTotal, connections.downloadTotal]);
 
   // 渲染流量图表 - 使用useMemo缓存渲染结果
   const trafficGraphComponent = useMemo(() => {
@@ -398,7 +371,7 @@ export const EnhancedTrafficStats = () => {
     {
       icon: <LinkRounded fontSize="small" />,
       title: t("Active Connections"),
-      value: stats.connections.activeConnections,
+      value: connections.count,
       unit: "",
       color: "success" as const,
     },
@@ -424,14 +397,16 @@ export const EnhancedTrafficStats = () => {
       color: "error" as const,
       onClick: isDebug ? handleGarbageCollection : undefined,
     },
-  ], [t, parsedData, stats.connections.activeConnections, isDebug, handleGarbageCollection]);
+  ], [t, parsedData, connections.count, isDebug, handleGarbageCollection]);
 
   return (
     <Grid container spacing={1} columns={{ xs: 8, sm: 8, md: 12 }}>
-      <Grid size={12}>
-        {/* 流量图表区域 */}
-        {trafficGraphComponent}
-      </Grid>
+      {trafficGraph && (
+        <Grid size={12}>
+          {/* 流量图表区域 */}
+          {trafficGraphComponent}
+        </Grid>
+      )}
       {/* 统计卡片区域 */}
       {statCards.map((card, index) => (
         <Grid key={index} size={4}>

src/components/home/home-profile-card.tsx

@@ -27,6 +27,7 @@ import { openWebUrl, updateProfile } from "@/services/cmds";
 import { useLockFn } from "ahooks";
 import { Notice } from "@/components/base";
 import { EnhancedCard } from "./enhanced-card";
+import { useAppData } from "@/providers/app-data-provider";
 
 // 定义旋转动画
 const round = keyframes`
@@ -35,19 +36,10 @@ const round = keyframes`
 `;
 
 // 辅助函数解析URL和过期时间
-const parseUrl = (url?: string, maxLength: number = 25) => {
+const parseUrl = (url?: string) => {
   if (!url) return "-";
-  let parsedUrl = "";
-  if (url.startsWith("http")) {
-    parsedUrl = new URL(url).host;
-  } else {
-    parsedUrl = "local";
-  }
-  
-  if (parsedUrl.length > maxLength) {
-    return parsedUrl.substring(0, maxLength - 3) + "...";
-  }
-  return parsedUrl;
+  if (url.startsWith("http")) return new URL(url).host;
+  return "local";
 };
 
 const parseExpire = (expire?: number) => {
@@ -81,6 +73,14 @@ export interface HomeProfileCardProps {
   onProfileUpdated?: () => void;
 }
 
+// 添加一个通用的截断样式
+const truncateStyle = {
+  maxWidth: "calc(100% - 28px)",
+  overflow: "hidden",
+  textOverflow: "ellipsis",
+  whiteSpace: "nowrap"
+};
+
 // 提取独立组件减少主组件复杂度
 const ProfileDetails = ({ current, onUpdateProfile, updating }: { 
   current: ProfileItem; 
@@ -109,8 +109,8 @@ const ProfileDetails = ({ current, onUpdateProfile, updating }: {
         {current.url && (
           <Stack direction="row" alignItems="center" spacing={1}>
             <DnsOutlined fontSize="small" color="action" />
-            <Typography variant="body2" color="text.secondary">
-              {t("From")}:{" "}
+            <Typography variant="body2" color="text.secondary" noWrap sx={{ display: "flex", alignItems: "center" }}>
+              <span style={{ flexShrink: 0 }}>{t("From")}: </span>
               {current.home ? (
                 <Link
                   component="button"
@@ -118,22 +118,46 @@ const ProfileDetails = ({ current, onUpdateProfile, updating }: {
                   onClick={() => current.home && openWebUrl(current.home)}
                   sx={{ 
                     display: "inline-flex",
-                    alignItems: "center"
+                    alignItems: "center",
+                    minWidth: 0,
+                    maxWidth: "calc(100% - 40px)",
+                    ml: 0.5
                   }}
+                  title={parseUrl(current.url)}
                 >
-                  {parseUrl(current.url)}
+                  <Typography
+                    component="span"
+                    sx={{
+                      overflow: "hidden",
+                      textOverflow: "ellipsis",
+                      whiteSpace: "nowrap",
+                      minWidth: 0,
+                      flex: 1
+                    }}
+                  >
+                    {parseUrl(current.url)}
+                  </Typography>
                   <LaunchOutlined
                     fontSize="inherit"
                     sx={{ ml: 0.5, fontSize: "0.8rem", opacity: 0.7, flexShrink: 0 }}
                   />
                 </Link>
               ) : (
-                <Box 
+                <Typography
                   component="span"
                   fontWeight="medium"
+                  sx={{
+                    overflow: "hidden",
+                    textOverflow: "ellipsis",
+                    whiteSpace: "nowrap",
+                    minWidth: 0,
+                    flex: 1,
+                    ml: 0.5
+                  }}
+                  title={parseUrl(current.url)}
                 >
                   {parseUrl(current.url)}
-                </Box>
+                </Typography>
               )}
             </Typography>
           </Stack>
@@ -247,6 +271,7 @@ const EmptyProfile = ({ onClick }: { onClick: () => void }) => {
 export const HomeProfileCard = ({ current, onProfileUpdated }: HomeProfileCardProps) => {
   const { t } = useTranslation();
   const navigate = useNavigate();
+  const { refreshAll } = useAppData();
   
   // 更新当前订阅
   const [updating, setUpdating] = useState(false);
@@ -259,6 +284,9 @@ export const HomeProfileCard = ({ current, onProfileUpdated }: HomeProfileCardPr
       await updateProfile(current.uid);
       Notice.success(t("Update subscription successfully"));
       onProfileUpdated?.();
+      
+      // 刷新首页数据
+      refreshAll();
     } catch (err: any) {
       Notice.error(err?.message || err.toString());
     } finally {
@@ -285,16 +313,30 @@ export const HomeProfileCard = ({ current, onProfileUpdated }: HomeProfileCardPr
         fontSize={18}
         onClick={() => current.home && openWebUrl(current.home)}
         sx={{
-          display: "inline-flex",
-          alignItems: "center",
           color: "inherit",
           textDecoration: "none",
+          display: "flex",
+          alignItems: "center",
+          minWidth: 0,
+          maxWidth: "100%",
+          "& > span": {
+            overflow: "hidden",
+            textOverflow: "ellipsis",
+            whiteSpace: "nowrap",
+            flex: 1
+          }
         }}
+        title={current.name}
       >
-        {current.name}
+        <span>{current.name}</span>
         <LaunchOutlined
           fontSize="inherit"
-          sx={{ ml: 0.5, fontSize: "0.8rem", opacity: 0.7 }}
+          sx={{ 
+            ml: 0.5, 
+            fontSize: "0.8rem", 
+            opacity: 0.7,
+            flexShrink: 0 
+          }}
         />
       </Link>
     );

src/components/home/ip-info-card.tsx

@@ -129,7 +129,7 @@ export const IpInfoCard = () => {
         }
       >
         <Box sx={{ display: "flex", flexDirection: "column", gap: 1 }}>
-          <Skeleton variant="text" width="60%" height={32} />
+          <Skeleton variant="text" width="60%" height={30} />
           <Skeleton variant="text" width="80%" height={24} />
           <Skeleton variant="text" width="70%" height={24} />
           <Skeleton variant="text" width="50%" height={24} />

src/components/home/proxy-tun-card.tsx

@@ -18,12 +18,8 @@ import {
   HelpOutlineRounded,
   SvgIconComponent,
 } from "@mui/icons-material";
-import useSWR from "swr";
-import {
-  getSystemProxy,
-  getAutotemProxy,
-  getRunningMode,
-} from "@/services/cmds";
+import { useVerge } from "@/hooks/use-verge";
+import { useSystemState } from "@/hooks/use-system-state";
 
 const LOCAL_STORAGE_TAB_KEY = "clash-verge-proxy-active-tab";
 
@@ -36,71 +32,64 @@ interface TabButtonProps {
 }
 
 // 抽取Tab组件以减少重复代码
-const TabButton: FC<TabButtonProps> = memo(({
-  isActive,
-  onClick,
-  icon: Icon,
-  label,
-  hasIndicator = false
-}) => (
-  <Paper
-    elevation={isActive ? 2 : 0}
-    onClick={onClick}
-    sx={{
-      cursor: "pointer",
-      px: 2,
-      py: 1,
-      display: "flex",
-      alignItems: "center",
-      justifyContent: "center",
-      gap: 1,
-      bgcolor: isActive ? "primary.main" : "background.paper",
-      color: isActive ? "primary.contrastText" : "text.primary",
-      borderRadius: 1.5,
-      flex: 1,
-      maxWidth: 160,
-      transition: "all 0.2s ease-in-out",
-      position: "relative",
-      "&:hover": {
-        transform: "translateY(-1px)",
-        boxShadow: 1,
-      },
-      "&:after": isActive
-        ? {
-          content: '""',
-          position: "absolute",
-          bottom: -9,
-          left: "50%",
-          width: 2,
-          height: 9,
-          bgcolor: "primary.main",
-          transform: "translateX(-50%)",
-        }
-        : {},
-    }}
-  >
-    <Icon fontSize="small" />
-    <Typography
-      variant="body2"
-      sx={{ fontWeight: isActive ? 600 : 400 }}
+const TabButton: FC<TabButtonProps> = memo(
+  ({ isActive, onClick, icon: Icon, label, hasIndicator = false }) => (
+    <Paper
+      elevation={isActive ? 2 : 0}
+      onClick={onClick}
+      sx={{
+        cursor: "pointer",
+        px: 2,
+        py: 1,
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        gap: 1,
+        bgcolor: isActive ? "primary.main" : "background.paper",
+        color: isActive ? "primary.contrastText" : "text.primary",
+        borderRadius: 1.5,
+        flex: 1,
+        maxWidth: 160,
+        transition: "all 0.2s ease-in-out",
+        position: "relative",
+        "&:hover": {
+          transform: "translateY(-1px)",
+          boxShadow: 1,
+        },
+        "&:after": isActive
+          ? {
+              content: '""',
+              position: "absolute",
+              bottom: -9,
+              left: "50%",
+              width: 2,
+              height: 9,
+              bgcolor: "primary.main",
+              transform: "translateX(-50%)",
+            }
+          : {},
+      }}
     >
-      {label}
-    </Typography>
-    {hasIndicator && (
-      <Box
-        sx={{
-          width: 8,
-          height: 8,
-          borderRadius: "50%",
-          bgcolor: isActive ? "#fff" : "success.main",
-          position: "absolute",
-          top: 8,
-          right: 8,
-        }}
-      />
-    )}
-  </Paper>
-));
+      <Icon fontSize="small" />
+      <Typography variant="body2" sx={{ fontWeight: isActive ? 600 : 400 }}>
+        {label}
+      </Typography>
+      {hasIndicator && (
+        <Box
+          sx={{
+            width: 8,
+            height: 8,
+            borderRadius: "50%",
+            bgcolor: isActive ? "#fff" : "success.main",
+            position: "absolute",
+            top: 8,
+            right: 8,
+          }}
+        />
+      )}
+    </Paper>
+  ),
+);
 
 interface TabDescriptionProps {
   description: string;
@@ -108,52 +97,57 @@ interface TabDescriptionProps {
 }
 
 // 抽取描述文本组件
-const TabDescription: FC<TabDescriptionProps> = memo(({ description, tooltipTitle }) => (
-  <Fade in={true} timeout={200}>
-    <Typography
-      variant="caption"
-      component="div"
-      sx={{
-        width: "95%",
-        textAlign: "center",
-        color: "text.secondary",
-        p: 0.8,
-        borderRadius: 1,
-        borderColor: "primary.main",
-        borderWidth: 1,
-        borderStyle: "solid",
-        backgroundColor: "background.paper",
-        display: "flex",
-        alignItems: "center",
-        justifyContent: "center",
-        gap: 0.5,
-        wordBreak: "break-word",
-        hyphens: "auto",
-      }}
-    >
-      {description}
-      <Tooltip title={tooltipTitle}>
-        <HelpOutlineRounded
-          sx={{ fontSize: 14, opacity: 0.7, flexShrink: 0 }}
-        />
-      </Tooltip>
-    </Typography>
-  </Fade>
-));
+const TabDescription: FC<TabDescriptionProps> = memo(
+  ({ description, tooltipTitle }) => (
+    <Fade in={true} timeout={200}>
+      <Typography
+        variant="caption"
+        component="div"
+        sx={{
+          width: "95%",
+          textAlign: "center",
+          color: "text.secondary",
+          p: 0.8,
+          borderRadius: 1,
+          borderColor: "primary.main",
+          borderWidth: 1,
+          borderStyle: "solid",
+          backgroundColor: "background.paper",
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          gap: 0.5,
+          wordBreak: "break-word",
+          hyphens: "auto",
+        }}
+      >
+        {description}
+        <Tooltip title={tooltipTitle}>
+          <HelpOutlineRounded
+            sx={{ fontSize: 14, opacity: 0.7, flexShrink: 0 }}
+          />
+        </Tooltip>
+      </Typography>
+    </Fade>
+  ),
+);
 
 export const ProxyTunCard: FC = () => {
   const { t } = useTranslation();
   const theme = useTheme();
-  const [activeTab, setActiveTab] = useState<string>(() =>
-    localStorage.getItem(LOCAL_STORAGE_TAB_KEY) || "system"
+  const [activeTab, setActiveTab] = useState<string>(
+    () => localStorage.getItem(LOCAL_STORAGE_TAB_KEY) || "system",
   );
 
   // 获取代理状态信息
-  const { data: sysproxy } = useSWR("getSystemProxy", getSystemProxy);
-  const { data: runningMode } = useSWR("getRunningMode", getRunningMode);
+  const { verge } = useVerge();
+  const { isSidecarMode, isAdminMode } = useSystemState();
 
-  // 是否以sidecar模式运行
-  const isSidecarMode = runningMode === "sidecar";
+  // 从verge配置中获取开关状态
+  const { enable_system_proxy, enable_tun_mode } = verge ?? {};
+  
+  // 判断Tun模式是否可用 - 当处于服务模式或管理员模式时可用
+  const isTunAvailable = !isSidecarMode || isAdminMode;
 
   // 处理错误
   const handleError = (err: Error) => {
@@ -170,20 +164,22 @@ export const ProxyTunCard: FC = () => {
   const tabDescription = useMemo(() => {
     if (activeTab === "system") {
       return {
-        text: sysproxy?.enable
+        text: enable_system_proxy
           ? t("System Proxy Enabled")
           : t("System Proxy Disabled"),
-        tooltip: t("System Proxy Info")
+        tooltip: t("System Proxy Info"),
       };
     } else {
       return {
-        text: isSidecarMode
+        text: !isTunAvailable
           ? t("TUN Mode Service Required")
-          : t("TUN Mode Intercept Info"),
-        tooltip: t("Tun Mode Info")
+          : enable_tun_mode
+            ? t("TUN Mode Enabled")
+            : t("TUN Mode Disabled"),
+        tooltip: t("TUN Mode Intercept Info"),
       };
     }
-  }, [activeTab, sysproxy?.enable, isSidecarMode, t]);
+  }, [activeTab, enable_system_proxy, enable_tun_mode, isTunAvailable, t]);
 
   return (
     <Box sx={{ display: "flex", flexDirection: "column", width: "100%" }}>
@@ -203,13 +199,14 @@ export const ProxyTunCard: FC = () => {
           onClick={() => handleTabChange("system")}
           icon={ComputerRounded}
           label={t("System Proxy")}
-          hasIndicator={sysproxy?.enable}
+          hasIndicator={enable_system_proxy}
         />
         <TabButton
           isActive={activeTab === "tun"}
           onClick={() => handleTabChange("tun")}
           icon={TroubleshootRounded}
           label={t("Tun Mode")}
+          hasIndicator={enable_tun_mode && isTunAvailable}
         />
       </Stack>
 

src/components/home/system-info-card.tsx

@@ -1,21 +1,30 @@
 import { useTranslation } from "react-i18next";
-import { Typography, Stack, Divider, Chip, IconButton } from "@mui/material";
-import { InfoOutlined, SettingsOutlined } from "@mui/icons-material";
+import { Typography, Stack, Divider, Chip, IconButton, Tooltip } from "@mui/material";
+import { 
+  InfoOutlined, 
+  SettingsOutlined, 
+  WarningOutlined, 
+  AdminPanelSettingsOutlined,
+  DnsOutlined,
+  ExtensionOutlined
+} from "@mui/icons-material";
 import { useVerge } from "@/hooks/use-verge";
 import { EnhancedCard } from "./enhanced-card";
 import useSWR from "swr";
-import { getRunningMode, getSystemInfo, installService } from "@/services/cmds";
+import { getSystemInfo, installService } from "@/services/cmds";
 import { useNavigate } from "react-router-dom";
 import { version as appVersion } from "@root/package.json";
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { check as checkUpdate } from "@tauri-apps/plugin-updater";
 import { useLockFn } from "ahooks";
 import { Notice } from "@/components/base";
+import { useSystemState } from "@/hooks/use-system-state";
 
 export const SystemInfoCard = () => {
   const { t } = useTranslation();
   const { verge, patchVerge } = useVerge();
   const navigate = useNavigate();
+  const { isAdminMode, isSidecarMode, mutateRunningMode } = useSystemState();
 
   // 系统信息状态
   const [systemState, setSystemState] = useState({
@@ -23,16 +32,6 @@ export const SystemInfoCard = () => {
     lastCheckUpdate: "-",
   });
 
-  // 获取运行模式
-  const { data: runningMode = "sidecar", mutate: mutateRunningMode } = useSWR(
-    "getRunningMode",
-    getRunningMode,
-    { suspense: false, revalidateOnFocus: false }
-  );
-
-  // 是否以sidecar模式运行
-  const isSidecarMode = runningMode === "sidecar";
-
   // 初始化系统信息
   useEffect(() => {
     // 获取系统信息
@@ -42,7 +41,10 @@ export const SystemInfoCard = () => {
         if (lines.length > 0) {
           const sysName = lines[0].split(": ")[1] || "";
           const sysVersion = lines[1].split(": ")[1] || "";
-          setSystemState(prev => ({ ...prev, osInfo: `${sysName} ${sysVersion}` }));
+          setSystemState((prev) => ({
+            ...prev,
+            osInfo: `${sysName} ${sysVersion}`,
+          }));
         }
       })
       .catch(console.error);
@@ -53,9 +55,9 @@ export const SystemInfoCard = () => {
       try {
         const timestamp = parseInt(lastCheck, 10);
         if (!isNaN(timestamp)) {
-          setSystemState(prev => ({ 
+          setSystemState((prev) => ({
             ...prev,
-            lastCheckUpdate: new Date(timestamp).toLocaleString() 
+            lastCheckUpdate: new Date(timestamp).toLocaleString(),
           }));
         }
       } catch (e) {
@@ -65,9 +67,9 @@ export const SystemInfoCard = () => {
       // 如果启用了自动检查更新但没有记录，设置当前时间并延迟检查
       const now = Date.now();
       localStorage.setItem("last_check_update", now.toString());
-      setSystemState(prev => ({ 
+      setSystemState((prev) => ({
         ...prev,
-        lastCheckUpdate: new Date(now).toLocaleString() 
+        lastCheckUpdate: new Date(now).toLocaleString(),
       }));
 
       setTimeout(() => {
@@ -84,9 +86,9 @@ export const SystemInfoCard = () => {
     async () => {
       const now = Date.now();
       localStorage.setItem("last_check_update", now.toString());
-      setSystemState(prev => ({ 
+      setSystemState((prev) => ({
         ...prev,
-        lastCheckUpdate: new Date(now).toLocaleString() 
+        lastCheckUpdate: new Date(now).toLocaleString(),
       }));
       return await checkUpdate();
     },
@@ -94,7 +96,7 @@ export const SystemInfoCard = () => {
       revalidateOnFocus: false,
       refreshInterval: 24 * 60 * 60 * 1000, // 每天检查一次
       dedupingInterval: 60 * 60 * 1000, // 1小时内不重复检查
-    }
+    },
   );
 
   // 导航到设置页面
@@ -104,13 +106,13 @@ export const SystemInfoCard = () => {
 
   // 切换自启动状态
   const toggleAutoLaunch = useCallback(async () => {
-    if (!verge) return;
+    if (!verge || isAdminMode) return;
     try {
       await patchVerge({ enable_auto_launch: !verge.enable_auto_launch });
     } catch (err) {
       console.error("切换开机自启动状态失败:", err);
     }
-  }, [verge, patchVerge]);
+  }, [verge, patchVerge, isAdminMode]);
 
   // 安装系统服务
   const onInstallService = useLockFn(async () => {
@@ -118,18 +120,20 @@ export const SystemInfoCard = () => {
       Notice.info(t("Installing Service..."), 1000);
       await installService();
       Notice.success(t("Service Installed Successfully"), 2000);
-      await mutateRunningMode();
+
+        await mutateRunningMode();
+
     } catch (err: any) {
       Notice.error(err.message || err.toString(), 3000);
     }
   });
 
-  // 点击运行模式处理
+  // 点击运行模式处理,Sidecar或纯管理员模式允许安装服务
   const handleRunningModeClick = useCallback(() => {
-    if (isSidecarMode) {
+    if (isSidecarMode || (isAdminMode && isSidecarMode)) {
       onInstallService();
     }
-  }, [isSidecarMode, onInstallService]);
+  }, [isSidecarMode, isAdminMode, onInstallService]);
 
   // 检查更新
   const onCheckUpdate = useLockFn(async () => {
@@ -147,16 +151,82 @@ export const SystemInfoCard = () => {
   });
 
   // 是否启用自启动
-  const autoLaunchEnabled = useMemo(() => verge?.enable_auto_launch || false, [verge]);
+  const autoLaunchEnabled = useMemo(
+    () => verge?.enable_auto_launch || false,
+    [verge],
+  );
 
   // 运行模式样式
-  const runningModeStyle = useMemo(() => ({
-    cursor: isSidecarMode ? "pointer" : "default",
-    textDecoration: isSidecarMode ? "underline" : "none",
-    "&:hover": {
-      opacity: isSidecarMode ? 0.7 : 1,
-    },
-  }), [isSidecarMode]);
+  const runningModeStyle = useMemo(
+    () => ({
+      // Sidecar或纯管理员模式允许安装服务
+      cursor: (isSidecarMode || (isAdminMode && isSidecarMode)) ? "pointer" : "default",
+      textDecoration: (isSidecarMode || (isAdminMode && isSidecarMode)) ? "underline" : "none",
+      display: "flex",
+      alignItems: "center",
+      gap: 0.5,
+      "&:hover": {
+        opacity: (isSidecarMode || (isAdminMode && isSidecarMode)) ? 0.7 : 1,
+      },
+    }),
+    [isSidecarMode, isAdminMode],
+  );
+
+  // 获取模式图标和文本
+  const getModeIcon = () => {
+    if (isAdminMode) {
+      // 判断是否为组合模式（管理员+服务）
+      if (!isSidecarMode) {
+        return (
+          <>
+            <AdminPanelSettingsOutlined 
+              sx={{ color: "primary.main", fontSize: 16 }} 
+              titleAccess={t("Administrator Mode")}
+            />
+            <DnsOutlined 
+              sx={{ color: "success.main", fontSize: 16, ml: 0.5 }} 
+              titleAccess={t("Service Mode")}
+            />
+          </>
+        );
+      }
+      return (
+        <AdminPanelSettingsOutlined 
+          sx={{ color: "primary.main", fontSize: 16 }} 
+          titleAccess={t("Administrator Mode")}
+        />
+      );
+    } else if (isSidecarMode) {
+      return (
+        <ExtensionOutlined 
+          sx={{ color: "info.main", fontSize: 16 }} 
+          titleAccess={t("Sidecar Mode")}
+        />
+      );
+    } else {
+      return (
+        <DnsOutlined 
+          sx={{ color: "success.main", fontSize: 16 }} 
+          titleAccess={t("Service Mode")}
+        />
+      );
+    }
+  };
+
+  // 获取模式文本
+  const getModeText = () => {
+    if (isAdminMode) {
+      // 判断是否同时处于服务模式
+      if (!isSidecarMode) {
+        return t("Administrator + Service Mode");
+      }
+      return t("Administrator Mode");
+    } else if (isSidecarMode) {
+      return t("Sidecar Mode");
+    } else {
+      return t("Service Mode");
+    }
+  };
 
   // 只有当verge存在时才渲染内容
   if (!verge) return null;
@@ -182,21 +252,29 @@ export const SystemInfoCard = () => {
           </Typography>
         </Stack>
         <Divider />
-        <Stack direction="row" justifyContent="space-between">
+        <Stack direction="row" justifyContent="space-between" alignItems="center">
           <Typography variant="body2" color="text.secondary">
             {t("Auto Launch")}
           </Typography>
-          <Chip
-            size="small"
-            label={autoLaunchEnabled ? t("Enabled") : t("Disabled")}
-            color={autoLaunchEnabled ? "success" : "default"}
-            variant={autoLaunchEnabled ? "filled" : "outlined"}
-            onClick={toggleAutoLaunch}
-            sx={{ cursor: "pointer" }}
-          />
+          <Stack direction="row" spacing={1} alignItems="center">
+            {isAdminMode && (
+              <Tooltip title={t("Administrator mode does not support auto launch")}>
+                <WarningOutlined sx={{ color: "warning.main", fontSize: 20 }} />
+              </Tooltip>
+            )}
+            <Chip
+              size="small"
+              label={autoLaunchEnabled ? t("Enabled") : t("Disabled")}
+              color={autoLaunchEnabled ? "success" : "default"}
+              variant={autoLaunchEnabled ? "filled" : "outlined"}
+              onClick={toggleAutoLaunch}
+              disabled={isAdminMode}
+              sx={{ cursor: isAdminMode ? "not-allowed" : "pointer" }}
+            />
+          </Stack>
         </Stack>
         <Divider />
-        <Stack direction="row" justifyContent="space-between">
+        <Stack direction="row" justifyContent="space-between" alignItems="center">
           <Typography variant="body2" color="text.secondary">
             {t("Running Mode")}
           </Typography>
@@ -206,7 +284,8 @@ export const SystemInfoCard = () => {
             onClick={handleRunningModeClick}
             sx={runningModeStyle}
           >
-            {isSidecarMode ? t("Sidecar Mode") : t("Service Mode")}
+            {getModeIcon()}
+            {getModeText()}
           </Typography>
         </Stack>
         <Divider />

src/components/profile/profile-item.tsx

@@ -179,17 +179,21 @@ export const ProfileItem = (props: Props) => {
   /// 0 不使用任何代理
   /// 1 使用订阅好的代理
   /// 2 至少使用一个代理，根据订阅，如果没订阅，默认使用系统代理
-  const onUpdate = useLockFn(async (type: 0 | 1 | 2) => {
+  const onUpdate = useLockFn(async (type: 0 | 1 | 2): Promise<void> => {
     setAnchorEl(null);
     setLoadingCache((cache) => ({ ...cache, [itemData.uid]: true }));
 
-    const option: Partial<IProfileOption> = {};
+    // 存储原始设置以便回退后恢复
+    const originalOptions = { 
+      with_proxy: itemData.option?.with_proxy,
+      self_proxy: itemData.option?.self_proxy
+    };
 
+    // 根据类型设置初始更新选项
+    const option: Partial<IProfileOption> = {};
     if (type === 0) {
       option.with_proxy = false;
       option.self_proxy = false;
-    } else if (type === 1) {
-      // nothing
     } else if (type === 2) {
       if (itemData.option?.self_proxy) {
         option.with_proxy = false;
@@ -201,14 +205,31 @@ export const ProfileItem = (props: Props) => {
     }
 
     try {
+      // 尝试正常更新
       await updateProfile(itemData.uid, option);
       Notice.success(t("Update subscription successfully"));
       mutate("getProfiles");
     } catch (err: any) {
+      // 更新失败，尝试使用自身代理
       const errmsg = err?.message || err.toString();
-      Notice.error(
-        errmsg.replace(/error sending request for url (\S+?): /, ""),
-      );
+      Notice.info(t("Update failed, retrying with Clash proxy..."));
+      
+      try {
+        await updateProfile(itemData.uid, {
+          with_proxy: false,
+          self_proxy: true
+        });
+        
+        Notice.success(t("Update with Clash proxy successfully"));
+        
+        await updateProfile(itemData.uid, originalOptions);
+        mutate("getProfiles");
+      } catch (retryErr: any) {
+        const retryErrmsg = retryErr?.message || retryErr.toString();
+        Notice.error(
+          `${t("Update failed even with Clash proxy")}: ${retryErrmsg.replace(/error sending request for url (\S+?): /, "")}`,
+        );
+      }
     } finally {
       setLoadingCache((cache) => ({ ...cache, [itemData.uid]: false }));
     }

src/components/profile/profile-viewer.tsx

@@ -88,11 +88,13 @@ export const ProfileViewer = forwardRef<ProfileViewerRef, Props>(
       formIns.handleSubmit(async (form) => {
         setLoading(true);
         try {
+          // 基本验证
           if (!form.type) throw new Error("`Type` should not be null");
           if (form.type === "remote" && !form.url) {
             throw new Error("The URL should not be null");
           }
 
+          // 处理表单数据
           if (form.option?.update_interval) {
             form.option.update_interval = +form.option.update_interval;
           } else {
@@ -101,25 +103,72 @@ export const ProfileViewer = forwardRef<ProfileViewerRef, Props>(
           if (form.option?.user_agent === "") {
             delete form.option.user_agent;
           }
+          
           const name = form.name || `${form.type} file`;
           const item = { ...form, name };
+          const isRemote = form.type === "remote";
           
-          // 创建
-          if (openType === "new") {
-            await createProfile(item, fileDataRef.current);
-          }
-          // 编辑
-          else {
-            if (!form.uid) throw new Error("UID not found");
-            await patchProfile(form.uid, item);
+          // 保存原始代理设置以便回退成功后恢复
+          const originalOptions = { 
+            with_proxy: form.option?.with_proxy,
+            self_proxy: form.option?.self_proxy
+          };
+          
+          // 执行创建或更新操作，本地配置不需要回退机制
+          if (!isRemote) {
+            if (openType === "new") {
+              await createProfile(item, fileDataRef.current);
+            } else {
+              if (!form.uid) throw new Error("UID not found");
+              await patchProfile(form.uid, item);
+            }
+          } else {
+            // 远程配置使用回退机制
+            try {
+              // 尝试正常操作
+              if (openType === "new") {
+                await createProfile(item, fileDataRef.current);
+              } else {
+                if (!form.uid) throw new Error("UID not found");
+                await patchProfile(form.uid, item);
+              }
+            } catch (err) {
+              // 首次创建/更新失败，尝试使用自身代理
+              Notice.info(t("Profile creation failed, retrying with Clash proxy..."));
+              
+              // 使用自身代理的配置
+              const retryItem = {
+                ...item,
+                option: {
+                  ...item.option,
+                  with_proxy: false,
+                  self_proxy: true
+                }
+              };
+              
+              // 使用自身代理再次尝试
+              if (openType === "new") {
+                await createProfile(retryItem, fileDataRef.current);
+              } else {
+                if (!form.uid) throw new Error("UID not found");
+                await patchProfile(form.uid, retryItem);
+                
+                // 编辑模式下恢复原始代理设置
+                await patchProfile(form.uid, { option: originalOptions });
+              }
+              
+              Notice.success(t("Profile creation succeeded with Clash proxy"));
+            }
           }
+          
+          // 成功后的操作
           setOpen(false);
-          setLoading(false);
           setTimeout(() => formIns.reset(), 500);
           fileDataRef.current = null;
           props.onChange();
         } catch (err: any) {
           Notice.error(err.message || err.toString());
+        } finally {
           setLoading(false);
         }
       })

src/components/proxy/provider-button.tsx

@@ -1,195 +1,46 @@
-import dayjs from "dayjs";
-import useSWR, { mutate } from "swr";
 import { useState } from "react";
 import { 
   Button,
+  Box,
+  Dialog,
+  DialogTitle,
+  DialogContent,
+  DialogActions,
   IconButton,
   List,
   ListItem,
   ListItemText,
-  styled,
-  Box,
-  alpha,
   Typography,
   Divider,
   LinearProgress,
-  keyframes,
+  alpha,
+  styled,
+  useTheme
 } from "@mui/material";
-import { RefreshRounded } from "@mui/icons-material";
 import { useTranslation } from "react-i18next";
-import { getProxyProviders, proxyProviderUpdate } from "@/services/api";
-import { BaseDialog } from "../base";
+import { useLockFn } from "ahooks";
+import { proxyProviderUpdate } from "@/services/api";
+import { useAppData } from "@/providers/app-data-provider";
+import { Notice } from "@/components/base";
+import { StorageOutlined, RefreshRounded } from "@mui/icons-material";
+import dayjs from "dayjs";
 import parseTraffic from "@/utils/parse-traffic";
 
-const round = keyframes`
-  from { transform: rotate(0deg); }
-  to { transform: rotate(360deg); }
-`;
-
-export const ProviderButton = () => {
-  const { t } = useTranslation();
-  const { data } = useSWR("getProxyProviders", getProxyProviders);
-
-  const [open, setOpen] = useState(false);
-
-  const hasProvider = Object.keys(data || {}).length > 0;
-  const [updating, setUpdating] = useState(
-    Object.keys(data || {}).map(() => false),
-  );
-
-  const setUpdatingAt = (status: boolean, index: number) => {
-    setUpdating((prev) => {
-      const next = [...prev];
-      next[index] = status;
-      return next;
-    });
-  };
-  const handleUpdate = async (key: string, index: number) => {
-    setUpdatingAt(true, index);
-    proxyProviderUpdate(key)
-      .then(async () => {
-        setUpdatingAt(false, index);
-        await mutate("getProxies");
-        await mutate("getProxyProviders");
-      })
-      .catch(async () => {
-        setUpdatingAt(false, index);
-        await mutate("getProxies");
-        await mutate("getProxyProviders");
-      });
+// 定义代理提供者类型
+interface ProxyProviderItem {
+  name?: string;
+  proxies: any[];
+  updatedAt: number;
+  vehicleType: string;
+  subscriptionInfo?: {
+    Upload: number;
+    Download: number;
+    Total: number;
+    Expire: number;
   };
+}
 
-  if (!hasProvider) return null;
-
-  return (
-    <>
-      <Button
-        size="small"
-        variant="outlined"
-        sx={{ textTransform: "capitalize" }}
-        onClick={() => setOpen(true)}
-      >
-        {t("Proxy Provider")}
-      </Button>
-
-      <BaseDialog
-        open={open}
-        title={
-          <Box display="flex" justifyContent="space-between" gap={1}>
-            <Typography variant="h6">{t("Proxy Provider")}</Typography>
-            <Button
-              variant="contained"
-              size="small"
-              onClick={async () => {
-                Object.entries(data || {}).forEach(async ([key], index) => {
-                  await handleUpdate(key, index);
-                });
-              }}
-            >
-              {t("Update All")}
-            </Button>
-          </Box>
-        }
-        contentSx={{ width: 400 }}
-        disableOk
-        cancelBtn={t("Close")}
-        onClose={() => setOpen(false)}
-        onCancel={() => setOpen(false)}
-      >
-        <List sx={{ py: 0, minHeight: 250 }}>
-          {Object.entries(data || {}).map(([key, item], index) => {
-            const time = dayjs(item.updatedAt);
-            const sub = item.subscriptionInfo;
-            const hasSubInfo = !!sub;
-            const upload = sub?.Upload || 0;
-            const download = sub?.Download || 0;
-            const total = sub?.Total || 0;
-            const expire = sub?.Expire || 0;
-            const progress = Math.min(
-              Math.round(((download + upload) * 100) / (total + 0.01)) + 1,
-              100,
-            );
-            return (
-              <>
-                <ListItem
-                  sx={{
-                    p: 0,
-                    borderRadius: "10px",
-                    border: "solid 2px var(--divider-color)",
-                    mb: 1,
-                  }}
-                  key={key}
-                >
-                  <ListItemText
-                    sx={{ px: 1 }}
-                    primary={
-                      <>
-                        <Typography
-                          variant="h6"
-                          component="span"
-                          noWrap
-                          title={key}
-                        >
-                          {key}
-                        </Typography>
-                        <TypeBox component="span" sx={{ marginLeft: "8px" }}>
-                          {item.proxies.length}
-                        </TypeBox>
-                      </>
-                    }
-                    secondary={
-                      <>
-                        <StyledTypeBox component="span">
-                          {item.vehicleType}
-                        </StyledTypeBox>
-                        <StyledTypeBox component="span">
-                          {t("Update At")} {time.fromNow()}
-                        </StyledTypeBox>
-                        {hasSubInfo && (
-                          <>
-                            <Box sx={{ ...boxStyle, fontSize: 14 }}>
-                              <span title="Used / Total">
-                                {parseTraffic(upload + download)} /{" "}
-                                {parseTraffic(total)}
-                              </span>
-                              <span title="Expire Time">
-                                {parseExpire(expire)}
-                              </span>
-                            </Box>
-
-                            <LinearProgress
-                              variant="determinate"
-                              value={progress}
-                              style={{ opacity: total > 0 ? 1 : 0 }}
-                            />
-                          </>
-                        )}
-                      </>
-                    }
-                  />
-                  <Divider orientation="vertical" flexItem />
-                  <IconButton
-                    size="small"
-                    color="inherit"
-                    title={`${t("Update")}${t("Proxy Provider")}`}
-                    onClick={() => handleUpdate(key, index)}
-                    sx={{
-                      animation: updating[index]
-                        ? `1s linear infinite ${round}`
-                        : "none",
-                    }}
-                  >
-                    <RefreshRounded />
-                  </IconButton>
-                </ListItem>
-              </>
-            );
-          })}
-        </List>
-      </BaseDialog>
-    </>
-  );
-};
+// 样式化组件 - 类型框
 const TypeBox = styled(Box)<{ component?: React.ElementType }>(({ theme }) => ({
   display: "inline-block",
   border: "1px solid #ccc",
@@ -202,28 +53,271 @@ const TypeBox = styled(Box)<{ component?: React.ElementType }>(({ theme }) => ({
   lineHeight: 1.25,
 }));
 
-const StyledTypeBox = styled(Box)<{ component?: React.ElementType }>(
-  ({ theme }) => ({
-    display: "inline-block",
-    border: "1px solid #ccc",
-    borderColor: alpha(theme.palette.primary.main, 0.5),
-    color: alpha(theme.palette.primary.main, 0.8),
-    borderRadius: 4,
-    fontSize: 10,
-    marginRight: "4px",
-    padding: "0 2px",
-    lineHeight: 1.25,
-  }),
-);
-
-const boxStyle = {
-  height: 26,
-  display: "flex",
-  alignItems: "center",
-  justifyContent: "space-between",
-};
-
-function parseExpire(expire?: number) {
+// 解析过期时间
+const parseExpire = (expire?: number) => {
   if (!expire) return "-";
   return dayjs(expire * 1000).format("YYYY-MM-DD");
-}
+};
+
+export const ProviderButton = () => {
+  const { t } = useTranslation();
+  const theme = useTheme();
+  const [open, setOpen] = useState(false);
+  const { proxyProviders, refreshProxy, refreshProxyProviders } = useAppData();
+  const [updating, setUpdating] = useState<Record<string, boolean>>({});
+  
+  // 检查是否有提供者
+  const hasProviders = Object.keys(proxyProviders || {}).length > 0;
+  
+  // 更新单个代理提供者
+  const updateProvider = useLockFn(async (name: string) => {
+    try {
+      // 设置更新状态
+      setUpdating(prev => ({ ...prev, [name]: true }));
+      
+      await proxyProviderUpdate(name);
+      
+      // 刷新数据
+      await refreshProxy();
+      await refreshProxyProviders();
+      
+      Notice.success(`${name} 更新成功`);
+    } catch (err: any) {
+      Notice.error(`${name} 更新失败: ${err?.message || err.toString()}`);
+    } finally {
+      // 清除更新状态
+      setUpdating(prev => ({ ...prev, [name]: false }));
+    }
+  });
+  
+  // 更新所有代理提供者
+  const updateAllProviders = useLockFn(async () => {
+    try {
+      // 获取所有provider的名称
+      const allProviders = Object.keys(proxyProviders || {});
+      if (allProviders.length === 0) {
+        Notice.info("没有可更新的代理提供者");
+        return;
+      }
+      
+      // 设置所有provider为更新中状态
+      const newUpdating = allProviders.reduce((acc, key) => {
+        acc[key] = true;
+        return acc;
+      }, {} as Record<string, boolean>);
+      setUpdating(newUpdating);
+      
+      // 改为串行逐个更新所有provider
+      for (const name of allProviders) {
+        try {
+          await proxyProviderUpdate(name);
+          // 每个更新完成后更新状态
+          setUpdating(prev => ({ ...prev, [name]: false }));
+        } catch (err) {
+          console.error(`更新 ${name} 失败`, err);
+          // 继续执行下一个，不中断整体流程
+        }
+      }
+      
+      // 刷新数据
+      await refreshProxy();
+      await refreshProxyProviders();
+      
+      Notice.success("全部代理提供者更新成功");
+    } catch (err: any) {
+      Notice.error(`更新失败: ${err?.message || err.toString()}`);
+    } finally {
+      // 清除所有更新状态
+      setUpdating({});
+    }
+  });
+  
+  const handleClose = () => {
+    setOpen(false);
+  };
+  
+  if (!hasProviders) return null;
+
+  return (
+    <>
+      <Button
+        variant="outlined"
+        size="small"
+        startIcon={<StorageOutlined />}
+        onClick={() => setOpen(true)}
+        sx={{ mr: 1 }}
+      >
+        {t("Proxy Provider")}
+      </Button>
+      
+      <Dialog
+        open={open}
+        onClose={handleClose}
+        maxWidth="sm"
+        fullWidth
+      >
+        <DialogTitle>
+          <Box display="flex" justifyContent="space-between" alignItems="center">
+            <Typography variant="h6">{t("Proxy Provider")}</Typography>
+            <Box>
+              <Button
+                variant="contained"
+                size="small"
+                onClick={updateAllProviders}
+              >
+                {t("Update All")}
+              </Button>
+            </Box>
+          </Box>
+        </DialogTitle>
+        
+        <DialogContent>
+          <List sx={{ py: 0, minHeight: 250 }}>
+            {Object.entries(proxyProviders || {}).map(([key, item]) => {
+              const provider = item as ProxyProviderItem;
+              const time = dayjs(provider.updatedAt);
+              const isUpdating = updating[key];
+              
+              // 订阅信息
+              const sub = provider.subscriptionInfo;
+              const hasSubInfo = !!sub;
+              const upload = sub?.Upload || 0;
+              const download = sub?.Download || 0;
+              const total = sub?.Total || 0;
+              const expire = sub?.Expire || 0;
+              
+              // 流量使用进度
+              const progress = total > 0
+                ? Math.min(Math.round(((download + upload) * 100) / total) + 1, 100)
+                : 0;
+              
+              return (
+                <ListItem
+                  key={key}
+                  sx={[
+                    { 
+                      p: 0,
+                      mb: "8px",
+                      borderRadius: 2,
+                      overflow: "hidden",
+                      transition: "all 0.2s"
+                    },
+                    ({ palette: { mode, primary } }) => {
+                      const bgcolor = mode === "light" ? "#ffffff" : "#24252f";
+                      const hoverColor = mode === "light" 
+                        ? alpha(primary.main, 0.1)
+                        : alpha(primary.main, 0.2);
+                      
+                      return {
+                        backgroundColor: bgcolor,
+                        "&:hover": {
+                          backgroundColor: hoverColor,
+                        }
+                      };
+                    }
+                  ]}
+                >
+                  <ListItemText
+                    sx={{ px: 2, py: 1 }}
+                    primary={
+                      <Box sx={{ 
+                        display: "flex", 
+                        justifyContent: "space-between",
+                        alignItems: "center", 
+                      }}>
+                        <Typography
+                          variant="subtitle1"
+                          component="div"
+                          noWrap
+                          title={key}
+                          sx={{ display: "flex", alignItems: "center" }}
+                        >
+                          <span style={{ marginRight: "8px" }}>{key}</span> 
+                          <TypeBox component="span">
+                            {provider.proxies.length}
+                          </TypeBox>
+                          <TypeBox component="span">
+                            {provider.vehicleType}
+                          </TypeBox>
+                        </Typography>
+                        
+                        <Typography variant="body2" color="text.secondary" noWrap>
+                          <small>{t("Update At")}: </small>{time.fromNow()}
+                        </Typography>
+                      </Box>
+                    }
+                    secondary={
+                      <>
+                        {/* 订阅信息 */}
+                        {hasSubInfo && (
+                          <>
+                            <Box sx={{ 
+                              mb: 1,
+                              display: "flex",
+                              alignItems: "center",
+                              justifyContent: "space-between",
+                            }}>
+                              <span title={t("Used / Total") as string}>
+                                {parseTraffic(upload + download)} / {parseTraffic(total)}
+                              </span>
+                              <span title={t("Expire Time") as string}>
+                                {parseExpire(expire)}
+                              </span>
+                            </Box>
+                            
+                            {/* 进度条 */}
+                            <LinearProgress
+                              variant="determinate"
+                              value={progress}
+                              sx={{ 
+                                height: 6, 
+                                borderRadius: 3,
+                                opacity: total > 0 ? 1 : 0,
+                              }}
+                            />
+                          </>
+                        )}
+                      </>
+                    }
+                  />
+                  <Divider orientation="vertical" flexItem />
+                  <Box sx={{ 
+                    width: 40, 
+                    display: "flex", 
+                    justifyContent: "center",
+                    alignItems: "center"
+                  }}>
+                    <IconButton
+                      size="small"
+                      color="primary"
+                      onClick={(e) => {
+                        updateProvider(key);
+                      }}
+                      disabled={isUpdating}
+                      sx={{
+                        animation: isUpdating ? "spin 1s linear infinite" : "none",
+                        "@keyframes spin": {
+                          "0%": { transform: "rotate(0deg)" },
+                          "100%": { transform: "rotate(360deg)" }
+                        }
+                      }}
+                      title={t("Update Provider") as string}
+                    >
+                      <RefreshRounded />
+                    </IconButton>
+                  </Box>
+                </ListItem>
+              );
+            })}
+          </List>
+        </DialogContent>
+        
+        <DialogActions>
+          <Button onClick={handleClose} variant="outlined">
+            {t("Close")}
+          </Button>
+        </DialogActions>
+      </Dialog>
+    </>
+  );
+};

src/components/proxy/proxy-render.tsx

@@ -5,6 +5,8 @@ import {
   ListItemButton,
   Typography,
   styled,
+  Chip,
+  Tooltip,
 } from "@mui/material";
 import {
   ExpandLessRounded,
@@ -21,17 +23,19 @@ import { useThemeMode } from "@/services/states";
 import { useEffect, useMemo, useState } from "react";
 import { convertFileSrc } from "@tauri-apps/api/core";
 import { downloadIconCache } from "@/services/cmds";
+import { useTranslation } from "react-i18next";
 
 interface RenderProps {
   item: IRenderItem;
   indent: boolean;
-  onLocation: (group: IProxyGroupItem) => void;
+  onLocation: (group: IRenderItem["group"]) => void;
   onCheckAll: (groupName: string) => void;
   onHeadState: (groupName: string, patch: Partial<HeadState>) => void;
-  onChangeProxy: (group: IProxyGroupItem, proxy: IProxyItem) => void;
+  onChangeProxy: (group: IRenderItem["group"], proxy: IRenderItem["proxy"] & { name: string }) => void;
 }
 
 export const ProxyRender = (props: RenderProps) => {
+  const { t } = useTranslation();
   const { indent, item, onLocation, onCheckAll, onHeadState, onChangeProxy } =
     props;
   const { type, group, headState, proxy, proxyCol } = item;
@@ -123,7 +127,20 @@ export const ProxyRender = (props: RenderProps) => {
             },
           }}
         />
-        {headState?.open ? <ExpandLessRounded /> : <ExpandMoreRounded />}
+        <Box sx={{ display: "flex", alignItems: "center" }}>
+          <Tooltip title={t("Proxy Count")} arrow>
+            <Chip 
+              size="small" 
+              label={`${group.all.length}`} 
+              sx={{ 
+                mr: 1, 
+                backgroundColor: (theme) => alpha(theme.palette.primary.main, 0.1),
+                color: (theme) => theme.palette.primary.main,
+              }} 
+            />
+          </Tooltip>
+          {headState?.open ? <ExpandLessRounded /> : <ExpandMoreRounded />}
+        </Box>
       </ListItemButton>
     );
   }

src/components/proxy/use-render-list.ts

@@ -1,6 +1,4 @@
-import useSWR from "swr";
 import { useEffect, useMemo, useCallback } from "react";
-import { getProxies } from "@/services/api";
 import { useVerge } from "@/hooks/use-verge";
 import { filterSort } from "./use-filter-sort";
 import { useWindowWidth } from "./use-window-width";
@@ -9,12 +7,52 @@ import {
   DEFAULT_STATE,
   type HeadState,
 } from "./use-head-state";
+import { useAppData } from "@/providers/app-data-provider";
+
+// 定义代理项接口
+interface IProxyItem {
+  name: string;
+  type: string;
+  udp: boolean;
+  xudp: boolean;
+  tfo: boolean;
+  mptcp: boolean;
+  smux: boolean;
+  history: {
+    time: string;
+    delay: number;
+  }[];
+  provider?: string;
+  testUrl?: string;
+  [key: string]: any; // 添加索引签名以适应其他可能的属性
+}
+
+// 代理组类型
+type ProxyGroup = {
+  name: string;
+  type: string;
+  udp: boolean;
+  xudp: boolean;
+  tfo: boolean;
+  mptcp: boolean;
+  smux: boolean;
+  history: {
+    time: string;
+    delay: number;
+  }[];
+  now: string;
+  all: IProxyItem[];
+  hidden?: boolean;
+  icon?: string;
+  testUrl?: string;
+  provider?: string;
+};
 
 export interface IRenderItem {
   // 组 | head | item | empty | item col
   type: 0 | 1 | 2 | 3 | 4;
   key: string;
-  group: IProxyGroupItem;
+  group: ProxyGroup;
   proxy?: IProxyItem;
   col?: number;
   proxyCol?: IProxyItem[];
@@ -51,16 +89,8 @@ const groupProxies = <T = any>(list: T[], size: number): T[][] => {
 };
 
 export const useRenderList = (mode: string) => {
-  const { data: proxiesData, mutate: mutateProxies } = useSWR(
-    "getProxies",
-    getProxies,
-    {
-      refreshInterval: 2000,
-      revalidateOnFocus: false,
-      revalidateOnReconnect: true,
-    },
-  );
-
+  // 使用全局数据提供者
+  const { proxies: proxiesData, refreshProxy } = useAppData();
   const { verge } = useVerge();
   const { width } = useWindowWidth();
   const [headStates, setHeadState] = useHeadStateNew();
@@ -80,9 +110,9 @@ export const useRenderList = (mode: string) => {
       (mode === "rule" && !groups.length) ||
       (mode === "global" && proxies.length < 2)
     ) {
-      setTimeout(() => mutateProxies(), 500);
+      setTimeout(() => refreshProxy(), 500);
     }
-  }, [proxiesData, mode, mutateProxies]);
+  }, [proxiesData, mode, refreshProxy]);
 
   // 处理渲染列表
   const renderList: IRenderItem[] = useMemo(() => {
@@ -94,7 +124,7 @@ export const useRenderList = (mode: string) => {
         ? proxiesData.groups
         : [proxiesData.global!];
 
-    const retList = renderGroups.flatMap((group) => {
+    const retList = renderGroups.flatMap((group: ProxyGroup) => {
       const headState = headStates[group.name] || DEFAULT_STATE;
       const ret: IRenderItem[] = [
         {
@@ -131,9 +161,9 @@ export const useRenderList = (mode: string) => {
           });
         } else if (col > 1) {
           return ret.concat(
-            groupProxies(proxies, col).map((proxyCol) => ({
+            groupProxies(proxies, col).map((proxyCol, colIndex) => ({
               type: 4,
-              key: `col-${group.name}-${proxyCol[0].name}`,
+              key: `col-${group.name}-${proxyCol[0].name}-${colIndex}`,
               group,
               headState,
               col,
@@ -158,12 +188,12 @@ export const useRenderList = (mode: string) => {
     });
 
     if (!useRule) return retList.slice(1);
-    return retList.filter((item) => !item.group.hidden);
+    return retList.filter((item: IRenderItem) => !item.group.hidden);
   }, [headStates, proxiesData, mode, col]);
 
   return {
     renderList,
-    onProxies: mutateProxies,
+    onProxies: refreshProxy,
     onHeadState: setHeadState,
     currentColumns: col,
   };

src/components/rule/provider-button.tsx

@@ -1,170 +1,39 @@
-import dayjs from "dayjs";
-import useSWR, { mutate } from "swr";
 import { useState } from "react";
 import { 
   Button, 
+  Box, 
+  Dialog, 
+  DialogTitle, 
+  DialogContent,
+  DialogActions,
   IconButton,
   List,
   ListItem,
   ListItemText,
   Typography,
-  styled,
-  Box,
-  alpha,
   Divider,
-  keyframes,
+  alpha,
+  styled,
+  useTheme
 } from "@mui/material";
-import { RefreshRounded } from "@mui/icons-material";
 import { useTranslation } from "react-i18next";
-import { getRuleProviders, ruleProviderUpdate } from "@/services/api";
-import { BaseDialog } from "../base";
+import { useLockFn } from "ahooks";
+import { ruleProviderUpdate } from "@/services/api";
+import { Notice } from "@/components/base";
+import { StorageOutlined, RefreshRounded } from "@mui/icons-material";
+import { useAppData } from "@/providers/app-data-provider";
+import dayjs from "dayjs";
 
-const round = keyframes`
-  from { transform: rotate(0deg); }
-  to { transform: rotate(360deg); }
-`;
+// 定义规则提供者类型
+interface RuleProviderItem {
+  behavior: string;
+  ruleCount: number;
+  updatedAt: number;
+  vehicleType: string;
+}
 
-export const ProviderButton = () => {
-  const { t } = useTranslation();
-  const { data } = useSWR("getRuleProviders", getRuleProviders);
-
-  const [open, setOpen] = useState(false);
-
-  const hasProvider = Object.keys(data || {}).length > 0;
-  const [updating, setUpdating] = useState(
-    Object.keys(data || {}).map(() => false),
-  );
-
-  const setUpdatingAt = (status: boolean, index: number) => {
-    setUpdating((prev) => {
-      const next = [...prev];
-      next[index] = status;
-      return next;
-    });
-  };
-  const handleUpdate = async (key: string, index: number) => {
-    setUpdatingAt(true, index);
-    ruleProviderUpdate(key)
-      .then(async () => {
-        setUpdatingAt(false, index);
-        await mutate("getRules");
-        await mutate("getRuleProviders");
-      })
-      .catch(async () => {
-        setUpdatingAt(false, index);
-        await mutate("getRules");
-        await mutate("getRuleProviders");
-      });
-  };
-
-  if (!hasProvider) return null;
-
-  return (
-    <>
-      <Button
-        size="small"
-        variant="outlined"
-        sx={{ textTransform: "capitalize" }}
-        onClick={() => setOpen(true)}
-      >
-        {t("Rule Provider")}
-      </Button>
-
-      <BaseDialog
-        open={open}
-        title={
-          <Box display="flex" justifyContent="space-between" gap={1}>
-            <Typography variant="h6">{t("Rule Provider")}</Typography>
-            <Button
-              variant="contained"
-              size="small"
-              onClick={async () => {
-                Object.entries(data || {}).forEach(async ([key], index) => {
-                  await handleUpdate(key, index);
-                });
-              }}
-            >
-              {t("Update All")}
-            </Button>
-          </Box>
-        }
-        contentSx={{ width: 400 }}
-        disableOk
-        cancelBtn={t("Close")}
-        onClose={() => setOpen(false)}
-        onCancel={() => setOpen(false)}
-      >
-        <List sx={{ py: 0, minHeight: 250 }}>
-          {Object.entries(data || {}).map(([key, item], index) => {
-            const time = dayjs(item.updatedAt);
-            return (
-              <>
-                <ListItem
-                  sx={{
-                    p: 0,
-                    borderRadius: "10px",
-                    border: "solid 2px var(--divider-color)",
-                    mb: 1,
-                  }}
-                  key={key}
-                >
-                  <ListItemText
-                    sx={{ px: 1 }}
-                    primary={
-                      <>
-                        <Typography
-                          variant="h6"
-                          component="span"
-                          noWrap
-                          title={key}
-                        >
-                          {key}
-                        </Typography>
-                        <TypeBox component="span" sx={{ marginLeft: "8px" }}>
-                          {item.ruleCount}
-                        </TypeBox>
-                      </>
-                    }
-                    secondary={
-                      <>
-                        <StyledTypeBox component="span">
-                          {item.vehicleType}
-                        </StyledTypeBox>
-                        <StyledTypeBox component="span">
-                          {item.behavior}
-                        </StyledTypeBox>
-                        <StyledTypeBox component="span">
-                          {t("Update At")} {time.fromNow()}
-                        </StyledTypeBox>
-                      </>
-                    }
-                  />
-                  <Divider orientation="vertical" flexItem />
-                  <IconButton
-                    size="small"
-                    color="inherit"
-                    title={`${t("Update")}${t("Rule Provider")}`}
-                    onClick={() => handleUpdate(key, index)}
-                    sx={{
-                      animation: updating[index]
-                        ? `1s linear infinite ${round}`
-                        : "none",
-                    }}
-                  >
-                    <RefreshRounded />
-                  </IconButton>
-                </ListItem>
-              </>
-            );
-          })}
-        </List>
-      </BaseDialog>
-    </>
-  );
-};
-const TypeBox = styled(Box, {
-  shouldForwardProp: (prop) => prop !== "component",
-})<{ component?: React.ElementType }>(({ theme }) => ({
+// 辅助组件 - 类型框
+const TypeBox = styled(Box)<{ component?: React.ElementType }>(({ theme }) => ({
   display: "inline-block",
   border: "1px solid #ccc",
   borderColor: alpha(theme.palette.secondary.main, 0.5),
@@ -176,16 +45,222 @@ const TypeBox = styled(Box, {
   lineHeight: 1.25,
 }));
 
-const StyledTypeBox = styled(Box, {
-  shouldForwardProp: (prop) => prop !== "component",
-})<{ component?: React.ElementType }>(({ theme }) => ({
-  display: "inline-block",
-  border: "1px solid #ccc",
-  borderColor: alpha(theme.palette.primary.main, 0.5),
-  color: alpha(theme.palette.primary.main, 0.8),
-  borderRadius: 4,
-  fontSize: 10,
-  marginRight: "4px",
-  padding: "0 2px",
-  lineHeight: 1.25,
-}));
+export const ProviderButton = () => {
+  const { t } = useTranslation();
+  const theme = useTheme();
+  const [open, setOpen] = useState(false);
+  const { ruleProviders, refreshRules, refreshRuleProviders } = useAppData();
+  const [updating, setUpdating] = useState<Record<string, boolean>>({});
+
+  // 检查是否有提供者
+  const hasProviders = Object.keys(ruleProviders || {}).length > 0;
+  
+  // 更新单个规则提供者
+  const updateProvider = useLockFn(async (name: string) => {
+    try {
+      // 设置更新状态
+      setUpdating(prev => ({ ...prev, [name]: true }));
+      
+      await ruleProviderUpdate(name);
+      
+      // 刷新数据
+      await refreshRules();
+      await refreshRuleProviders();
+      
+      Notice.success(`${name} 更新成功`);
+    } catch (err: any) {
+      Notice.error(`${name} 更新失败: ${err?.message || err.toString()}`);
+    } finally {
+      // 清除更新状态
+      setUpdating(prev => ({ ...prev, [name]: false }));
+    }
+  });
+  
+  // 更新所有规则提供者
+  const updateAllProviders = useLockFn(async () => {
+    try {
+      // 获取所有provider的名称
+      const allProviders = Object.keys(ruleProviders || {});
+      if (allProviders.length === 0) {
+        Notice.info("没有可更新的规则提供者");
+        return;
+      }
+      
+      // 设置所有provider为更新中状态
+      const newUpdating = allProviders.reduce((acc, key) => {
+        acc[key] = true;
+        return acc;
+      }, {} as Record<string, boolean>);
+      setUpdating(newUpdating);
+      
+      // 改为串行逐个更新所有provider
+      for (const name of allProviders) {
+        try {
+          await ruleProviderUpdate(name);
+          // 每个更新完成后更新状态
+          setUpdating(prev => ({ ...prev, [name]: false }));
+        } catch (err) {
+          console.error(`更新 ${name} 失败`, err);
+          // 继续执行下一个，不中断整体流程
+        }
+      }
+      
+      // 刷新数据
+      await refreshRules();
+      await refreshRuleProviders();
+      
+      Notice.success("全部规则提供者更新成功");
+    } catch (err: any) {
+      Notice.error(`更新失败: ${err?.message || err.toString()}`);
+    } finally {
+      // 清除所有更新状态
+      setUpdating({});
+    }
+  });
+  
+  const handleClose = () => {
+    setOpen(false);
+  };
+  
+  if (!hasProviders) return null;
+
+  return (
+    <>
+      <Button
+        variant="outlined"
+        size="small"
+        startIcon={<StorageOutlined />}
+        onClick={() => setOpen(true)}
+      >
+        {t("Rule Provider")}
+      </Button>
+      
+      <Dialog
+        open={open}
+        onClose={handleClose}
+        maxWidth="sm"
+        fullWidth
+      >
+        <DialogTitle>
+          <Box display="flex" justifyContent="space-between" alignItems="center">
+            <Typography variant="h6">{t("Rule Providers")}</Typography>
+            <Button
+              variant="contained"
+              size="small"
+              onClick={updateAllProviders}
+            >
+              {t("Update All")}
+            </Button>
+          </Box>
+        </DialogTitle>
+        
+        <DialogContent>
+          <List sx={{ py: 0, minHeight: 250 }}>
+            {Object.entries(ruleProviders || {}).map(([key, item]) => {
+              const provider = item as RuleProviderItem;
+              const time = dayjs(provider.updatedAt);
+              const isUpdating = updating[key];
+              
+              return (
+                <ListItem
+                  key={key}
+                  sx={[
+                    { 
+                      p: 0, 
+                      mb: "8px",
+                      borderRadius: 2,
+                      overflow: "hidden",
+                      transition: "all 0.2s"
+                    },
+                    ({ palette: { mode, primary } }) => {
+                      const bgcolor = mode === "light" ? "#ffffff" : "#24252f";
+                      const hoverColor = mode === "light" 
+                        ? alpha(primary.main, 0.1)
+                        : alpha(primary.main, 0.2);
+                      
+                      return {
+                        backgroundColor: bgcolor,
+                        "&:hover": {
+                          backgroundColor: hoverColor,
+                          borderColor: alpha(primary.main, 0.3)
+                        }
+                      };
+                    }
+                  ]}
+                >
+                  <ListItemText
+                    sx={{ px: 2, py: 1 }}
+                    primary={
+                      <Box sx={{ 
+                        display: "flex", 
+                        justifyContent: "space-between",
+                        alignItems: "center", 
+                      }}>
+                        <Typography
+                          variant="subtitle1"
+                          component="div"
+                          noWrap
+                          title={key}
+                          sx={{ display: "flex", alignItems: "center" }}
+                        >
+                          <span style={{ marginRight: "8px" }}>{key}</span> 
+                          <TypeBox component="span">
+                            {provider.ruleCount}
+                          </TypeBox>
+                        </Typography>
+                        
+                        <Typography variant="body2" color="text.secondary" noWrap>
+                          <small>{t("Update At")}: </small>{time.fromNow()}
+                        </Typography>
+                      </Box>
+                    }
+                    secondary={
+                      <Box sx={{ display: "flex" }}>
+                        <TypeBox component="span">
+                          {provider.vehicleType}
+                        </TypeBox>
+                        <TypeBox component="span">
+                          {provider.behavior}
+                        </TypeBox>
+                      </Box>
+                    }
+                  />
+                  <Divider orientation="vertical" flexItem />
+                  <Box sx={{ 
+                    width: 40, 
+                    display: "flex", 
+                    justifyContent: "center",
+                    alignItems: "center"
+                  }}>
+                    <IconButton
+                      size="small"
+                      color="primary"
+                      onClick={() => updateProvider(key)}
+                      disabled={isUpdating}
+                      sx={{
+                        animation: isUpdating ? "spin 1s linear infinite" : "none",
+                        "@keyframes spin": {
+                          "0%": { transform: "rotate(0deg)" },
+                          "100%": { transform: "rotate(360deg)" }
+                        }
+                      }}
+                      title={t("Update Provider") as string}
+                    >
+                      <RefreshRounded />
+                    </IconButton>
+                  </Box>
+                </ListItem>
+              );
+            })}
+          </List>
+        </DialogContent>
+        
+        <DialogActions>
+          <Button onClick={handleClose} variant="outlined">
+            {t("Close")}
+          </Button>
+        </DialogActions>
+      </Dialog>
+    </>
+  );
+};

src/components/setting/mods/dns-viewer.tsx

@@ -57,21 +57,18 @@ const DEFAULT_DNS_CONFIG = {
     "*.msftncsi.com",
     "www.msftconnecttest.com",
   ],
-  "default-nameserver": ["223.6.6.6", "8.8.8.8"],
+  "default-nameserver": ["system", "223.6.6.6", "8.8.8.8"],
   nameserver: [
     "8.8.8.8",
     "https://doh.pub/dns-query",
     "https://dns.alidns.com/dns-query",
   ],
-  fallback: [
-    "https://dns.alidns.com/dns-query",
-    "https://dns.google/dns-query",
-    "https://cloudflare-dns.com/dns-query",
-  ],
+  fallback: [],
   "nameserver-policy": {},
   "proxy-server-nameserver": [
     "https://doh.pub/dns-query",
     "https://dns.alidns.com/dns-query",
+    "tls://223.5.5.5"
   ],
   "direct-nameserver": [],
   "direct-nameserver-follow-policy": false,
@@ -98,12 +95,12 @@ export const DnsViewer = forwardRef<DialogRef>((props, ref) => {
     fakeIpFilterMode: "blacklist" | "whitelist";
     preferH3: boolean;
     respectRules: boolean;
+    useHosts: boolean;
+    useSystemHosts: boolean;
     fakeIpFilter: string;
     nameserver: string;
     fallback: string;
     defaultNameserver: string;
-    useHosts: boolean;
-    useSystemHosts: boolean;
     proxyServerNameserver: string;
     directNameserver: string;
     directNameserverFollowPolicy: boolean;
@@ -120,12 +117,12 @@ export const DnsViewer = forwardRef<DialogRef>((props, ref) => {
     fakeIpFilterMode: DEFAULT_DNS_CONFIG["fake-ip-filter-mode"],
     preferH3: DEFAULT_DNS_CONFIG["prefer-h3"],
     respectRules: DEFAULT_DNS_CONFIG["respect-rules"],
+    useHosts: DEFAULT_DNS_CONFIG["use-hosts"],
+    useSystemHosts: DEFAULT_DNS_CONFIG["use-system-hosts"],
     fakeIpFilter: DEFAULT_DNS_CONFIG["fake-ip-filter"].join(", "),
     defaultNameserver: DEFAULT_DNS_CONFIG["default-nameserver"].join(", "),
     nameserver: DEFAULT_DNS_CONFIG.nameserver.join(", "),
     fallback: DEFAULT_DNS_CONFIG.fallback.join(", "),
-    useHosts: DEFAULT_DNS_CONFIG["use-hosts"],
-    useSystemHosts: DEFAULT_DNS_CONFIG["use-system-hosts"],
     proxyServerNameserver:
       DEFAULT_DNS_CONFIG["proxy-server-nameserver"]?.join(", ") || "",
     directNameserver: DEFAULT_DNS_CONFIG["direct-nameserver"]?.join(", ") || "",
@@ -209,6 +206,9 @@ export const DnsViewer = forwardRef<DialogRef>((props, ref) => {
       preferH3: config["prefer-h3"] ?? DEFAULT_DNS_CONFIG["prefer-h3"],
       respectRules:
         config["respect-rules"] ?? DEFAULT_DNS_CONFIG["respect-rules"],
+        useHosts: config["use-hosts"] ?? DEFAULT_DNS_CONFIG["use-hosts"],
+        useSystemHosts:
+          config["use-system-hosts"] ?? DEFAULT_DNS_CONFIG["use-system-hosts"],
       fakeIpFilter:
         config["fake-ip-filter"]?.join(", ") ??
         DEFAULT_DNS_CONFIG["fake-ip-filter"].join(", "),
@@ -220,9 +220,6 @@ export const DnsViewer = forwardRef<DialogRef>((props, ref) => {
       defaultNameserver:
         config["default-nameserver"]?.join(", ") ??
         DEFAULT_DNS_CONFIG["default-nameserver"].join(", "),
-      useHosts: config["use-hosts"] ?? DEFAULT_DNS_CONFIG["use-hosts"],
-      useSystemHosts:
-        config["use-system-hosts"] ?? DEFAULT_DNS_CONFIG["use-system-hosts"],
       proxyServerNameserver:
         config["proxy-server-nameserver"]?.join(", ") ??
         (DEFAULT_DNS_CONFIG["proxy-server-nameserver"]?.join(", ") || ""),
@@ -259,12 +256,12 @@ export const DnsViewer = forwardRef<DialogRef>((props, ref) => {
       fakeIpFilterMode: DEFAULT_DNS_CONFIG["fake-ip-filter-mode"],
       preferH3: DEFAULT_DNS_CONFIG["prefer-h3"],
       respectRules: DEFAULT_DNS_CONFIG["respect-rules"],
+      useHosts: DEFAULT_DNS_CONFIG["use-hosts"],
+      useSystemHosts: DEFAULT_DNS_CONFIG["use-system-hosts"],
       fakeIpFilter: DEFAULT_DNS_CONFIG["fake-ip-filter"].join(", "),
       defaultNameserver: DEFAULT_DNS_CONFIG["default-nameserver"].join(", "),
       nameserver: DEFAULT_DNS_CONFIG.nameserver.join(", "),
       fallback: DEFAULT_DNS_CONFIG.fallback.join(", "),
-      useHosts: DEFAULT_DNS_CONFIG["use-hosts"],
-      useSystemHosts: DEFAULT_DNS_CONFIG["use-system-hosts"],
       proxyServerNameserver:
         DEFAULT_DNS_CONFIG["proxy-server-nameserver"]?.join(", ") || "",
       directNameserver:
@@ -330,6 +327,10 @@ export const DnsViewer = forwardRef<DialogRef>((props, ref) => {
         preferH3: dnsConfig["prefer-h3"] ?? DEFAULT_DNS_CONFIG["prefer-h3"],
         respectRules:
           dnsConfig["respect-rules"] ?? DEFAULT_DNS_CONFIG["respect-rules"],
+        useHosts: dnsConfig["use-hosts"] ?? DEFAULT_DNS_CONFIG["use-hosts"],
+        useSystemHosts:
+          dnsConfig["use-system-hosts"] ??
+          DEFAULT_DNS_CONFIG["use-system-hosts"],
         fakeIpFilter:
           dnsConfig["fake-ip-filter"]?.join(", ") ??
           DEFAULT_DNS_CONFIG["fake-ip-filter"].join(", "),
@@ -342,10 +343,6 @@ export const DnsViewer = forwardRef<DialogRef>((props, ref) => {
         fallback:
           dnsConfig.fallback?.join(", ") ??
           DEFAULT_DNS_CONFIG.fallback.join(", "),
-        useHosts: dnsConfig["use-hosts"] ?? DEFAULT_DNS_CONFIG["use-hosts"],
-        useSystemHosts:
-          dnsConfig["use-system-hosts"] ??
-          DEFAULT_DNS_CONFIG["use-system-hosts"],
         proxyServerNameserver:
           dnsConfig["proxy-server-nameserver"]?.join(", ") ??
           (DEFAULT_DNS_CONFIG["proxy-server-nameserver"]?.join(", ") || ""),
@@ -458,12 +455,12 @@ export const DnsViewer = forwardRef<DialogRef>((props, ref) => {
       "fake-ip-filter-mode": values.fakeIpFilterMode,
       "prefer-h3": values.preferH3,
       "respect-rules": values.respectRules,
+      "use-hosts": values.useHosts,
+      "use-system-hosts": values.useSystemHosts,
       "fake-ip-filter": parseList(values.fakeIpFilter),
       "default-nameserver": parseList(values.defaultNameserver),
       nameserver: parseList(values.nameserver),
-      fallback: parseList(values.fallback),
-      "use-hosts": values.useHosts,
-      "use-system-hosts": values.useSystemHosts,
+      "direct-nameserver-follow-policy": values.directNameserverFollowPolicy,
       "fallback-filter": {
         geoip: values.fallbackGeoip,
         "geoip-code": values.fallbackGeoipCode,
@@ -472,13 +469,16 @@ export const DnsViewer = forwardRef<DialogRef>((props, ref) => {
       },
     };
 
-    // 只在有nameserverPolicy时添加
+    // 只在有值时添加其他可选字段
+    if (values.fallback) {
+      dnsConfig["fallback"] = parseList(values.fallback);
+    }
+
     const policy = parseNameserverPolicy(values.nameserverPolicy);
     if (Object.keys(policy).length > 0) {
       dnsConfig["nameserver-policy"] = policy;
     }
 
-    // 只在有值时添加其他可选字段
     if (values.proxyServerNameserver) {
       dnsConfig["proxy-server-nameserver"] = parseList(
         values.proxyServerNameserver,
@@ -489,9 +489,6 @@ export const DnsViewer = forwardRef<DialogRef>((props, ref) => {
       dnsConfig["direct-nameserver"] = parseList(values.directNameserver);
     }
 
-    dnsConfig["direct-nameserver-follow-policy"] =
-      values.directNameserverFollowPolicy;
-
     return dnsConfig;
   };
 
@@ -576,7 +573,7 @@ export const DnsViewer = forwardRef<DialogRef>((props, ref) => {
       open={open}
       title={
         <Box display="flex" justifyContent="space-between" alignItems="center">
-          {t("DNS Settings")}
+          {t("DNS Overwrite")}
           <Box display="flex" alignItems="center" gap={1}>
             <Button
               variant="outlined"
@@ -755,7 +752,7 @@ export const DnsViewer = forwardRef<DialogRef>((props, ref) => {
               size="small"
               value={values.defaultNameserver}
               onChange={handleChange("defaultNameserver")}
-              placeholder="223.6.6.6, 8.8.8.8"
+              placeholder="system,223.6.6.6, 8.8.8.8"
             />
           </Item>
 

src/components/setting/mods/hotkey-viewer.tsx

@@ -20,6 +20,7 @@ const HOTKEY_FUNC = [
   "clash_mode_direct",
   "toggle_system_proxy",
   "toggle_tun_mode",
+  "entry_lightweight_mode",
 ];
 
 export const HotkeyViewer = forwardRef<DialogRef>((props, ref) => {

src/components/setting/mods/layout-viewer.tsx

@@ -198,6 +198,26 @@ export const LayoutViewer = forwardRef<DialogRef>((props, ref) => {
             </GuardState>
           </Item>
         )}
+        {OS === "macos" && (
+          <Item>
+            <ListItemText primary={t("Enable Tray Icon")} />
+            <GuardState
+              value={
+                verge?.enable_tray_icon === false &&
+                verge?.enable_tray_speed === false
+                  ? true
+                  : (verge?.enable_tray_icon ?? true)
+              }
+              valueProps="checked"
+              onCatch={onError}
+              onFormat={onSwitchFormat}
+              onChange={(e) => onChangeData({ enable_tray_icon: e })}
+              onGuard={(e) => patchVerge({ enable_tray_icon: e })}
+            >
+              <Switch edge="end" />
+            </GuardState>
+          </Item>
+        )}
 
         <Item>
           <ListItemText primary={t("Common Tray Icon")} />

src/components/setting/mods/lite-mode-viewer.tsx

@@ -66,9 +66,9 @@ export const LiteModeViewer = forwardRef<DialogRef>((props, ref) => {
             sx={{
               cursor: "pointer",
               color: "primary.main",
-              "&:hover": { textDecoration: "underline" }
+              "&:hover": { textDecoration: "underline" },
             }}
-            onClick={() => entry_lightweight_mode()}
+            onClick={async () => await entry_lightweight_mode()}
           >
             {t("Enable")}
           </Typography>
@@ -115,17 +115,25 @@ export const LiteModeViewer = forwardRef<DialogRef>((props, ref) => {
                 slotProps={{
                   input: {
                     endAdornment: (
-                      <InputAdornment position="end">{t("mins")}</InputAdornment>
-                    )
-                  }
+                      <InputAdornment position="end">
+                        {t("mins")}
+                      </InputAdornment>
+                    ),
+                  },
                 }}
               />
             </ListItem>
 
             <ListItem sx={{ padding: "5px 2px" }}>
-              <Typography variant="body2" color="text.secondary" sx={{ fontStyle: "italic" }}>
-                {t("When closing the window, LightWeight Mode will be automatically activated after _n minutes",
-                  { n: values.autoEnterLiteModeDelay })}
+              <Typography
+                variant="body2"
+                color="text.secondary"
+                sx={{ fontStyle: "italic" }}
+              >
+                {t(
+                  "When closing the window, LightWeight Mode will be automatically activated after _n minutes",
+                  { n: values.autoEnterLiteModeDelay },
+                )}
               </Typography>
             </ListItem>
           </>

src/components/setting/setting-clash.tsx

@@ -5,7 +5,6 @@ import {
   SettingsRounded,
   ShuffleRounded,
   LanRounded,
-  DnsRounded,
 } from "@mui/icons-material";
 import { DialogRef, Notice, Switch } from "@/components/base";
 import { useClash } from "@/hooks/use-clash";
@@ -49,7 +48,16 @@ const SettingClash = ({ onError }: Props) => {
   const { enable_random_port = false, verge_mixed_port } = verge ?? {};
 
   // 独立跟踪DNS设置开关状态
-  const [dnsSettingsEnabled, setDnsSettingsEnabled] = useState(false);
+  const [dnsSettingsEnabled, setDnsSettingsEnabled] = useState(() => {
+    // 尝试从localStorage获取之前保存的状态
+    const savedState = localStorage.getItem("dns_settings_enabled");
+    if (savedState !== null) {
+      return savedState === "true";
+    }
+    // 如果没有保存的状态，则从verge配置中获取
+    return verge?.enable_dns_settings ?? false;
+  });
+  
   const { addListener } = useListen();
 
   const webRef = useRef<DialogRef>(null);
@@ -59,12 +67,6 @@ const SettingClash = ({ onError }: Props) => {
   const networkRef = useRef<DialogRef>(null);
   const dnsRef = useRef<DialogRef>(null);
 
-  // 初始化时从verge配置中加载DNS设置开关状态
-  useEffect(() => {
-    const dnsSettingsState = verge?.enable_dns_settings ?? false;
-    setDnsSettingsEnabled(dnsSettingsState);
-  }, [verge]);
-
   const onSwitchFormat = (_e: any, value: boolean) => value;
   const onChangeData = (patch: Partial<IConfigData>) => {
     mutateClash((old) => ({ ...(old! || {}), ...patch }), false);
@@ -84,15 +86,21 @@ const SettingClash = ({ onError }: Props) => {
   // 实现DNS设置开关处理函数
   const handleDnsToggle = useLockFn(async (enable: boolean) => {
     try {
+      // 立即更新UI状态
       setDnsSettingsEnabled(enable);
+      // 保存到localStorage，用于记住用户的选择
+      localStorage.setItem("dns_settings_enabled", String(enable));
+      // 更新verge配置
       await patchVerge({ enable_dns_settings: enable });
       await invoke("apply_dns_config", { apply: enable });
       setTimeout(() => {
         mutateClash();
       }, 500); // 延迟500ms确保后端完成处理
     } catch (err: any) {
-      Notice.error(err.message || err.toString());
+      // 如果出错，恢复原始状态
       setDnsSettingsEnabled(!enable);
+      localStorage.setItem("dns_settings_enabled", String(!enable));
+      Notice.error(err.message || err.toString());
       await patchVerge({ enable_dns_settings: !enable }).catch(() => {
         // 忽略恢复状态时的错误
       });
@@ -143,7 +151,6 @@ const SettingClash = ({ onError }: Props) => {
           />
         }
       >
-        {/* 使用独立状态，不再依赖dns?.enable */}
         <Switch
           edge="end"
           checked={dnsSettingsEnabled}

src/components/setting/setting-system.tsx

@@ -18,12 +18,12 @@ import { TooltipIcon } from "@/components/base/base-tooltip-icon";
 import {
   getSystemProxy,
   getAutotemProxy,
-  getRunningMode,
   installService,
   getAutoLaunchStatus,
 } from "@/services/cmds";
 import { useLockFn } from "ahooks";
-import { Box, Button, Tooltip } from "@mui/material";
+import { Button, Tooltip } from "@mui/material";
+import { useSystemState } from "@/hooks/use-system-state";
 
 interface Props {
   onError?: (err: Error) => void;
@@ -36,23 +36,29 @@ const SettingSystem = ({ onError }: Props) => {
 
   const { data: sysproxy } = useSWR("getSystemProxy", getSystemProxy);
   const { data: autoproxy } = useSWR("getAutotemProxy", getAutotemProxy);
-  const { data: runningMode, mutate: mutateRunningMode } = useSWR(
-    "getRunningMode",
-    getRunningMode,
+  const { data: autoLaunchEnabled } = useSWR(
+    "getAutoLaunchStatus",
+    getAutoLaunchStatus,
+    { revalidateOnFocus: false }
   );
-  const { data: autoLaunchEnabled } = useSWR("getAutoLaunchStatus", getAutoLaunchStatus);
+
+  const { isAdminMode, isSidecarMode, mutateRunningMode } = useSystemState();
+
+  // 判断Tun模式是否可用 - 当处于服务模式或管理员模式时可用
+  const isTunAvailable = !isSidecarMode || isAdminMode;
 
   // 当实际自启动状态与配置不同步时更新配置
   useEffect(() => {
-    if (autoLaunchEnabled !== undefined && verge && verge.enable_auto_launch !== autoLaunchEnabled) {
+    if (
+      autoLaunchEnabled !== undefined &&
+      verge &&
+      verge.enable_auto_launch !== autoLaunchEnabled
+    ) {
       // 静默更新配置，不触发UI刷新
       mutateVerge({ ...verge, enable_auto_launch: autoLaunchEnabled }, false);
     }
   }, [autoLaunchEnabled]);
 
-  // 是否以sidecar模式运行
-  const isSidecarMode = runningMode === "sidecar";
-
   const sysproxyRef = useRef<DialogRef>(null);
   const tunRef = useRef<DialogRef>(null);
 
@@ -103,12 +109,12 @@ const SettingSystem = ({ onError }: Props) => {
               icon={SettingsRounded}
               onClick={() => tunRef.current?.open()}
             />
-            {isSidecarMode && (
+            {isSidecarMode && !isAdminMode && (
               <Tooltip title={t("TUN requires Service Mode")}>
                 <WarningRounded sx={{ color: "warning.main", mr: 1 }} />
               </Tooltip>
             )}
-            {isSidecarMode && (
+            {isSidecarMode && !isAdminMode && (
               <Tooltip title={t("Install Service")}>
                 <Button
                   variant="outlined"
@@ -130,20 +136,20 @@ const SettingSystem = ({ onError }: Props) => {
           onCatch={onError}
           onFormat={onSwitchFormat}
           onChange={(e) => {
-            // 当在sidecar模式下禁用切换
-            if (isSidecarMode) return;
+            // 当在sidecar模式下且非管理员模式时禁用切换
+            if (isSidecarMode && !isAdminMode) return;
             onChangeData({ enable_tun_mode: e });
           }}
           onGuard={(e) => {
-            // 当在sidecar模式下禁用切换
-            if (isSidecarMode) {
+            // 当在sidecar模式下且非管理员模式时禁用切换
+            if (isSidecarMode && !isAdminMode) {
               Notice.error(t("TUN requires Service Mode"), 2000);
               return Promise.reject(new Error(t("TUN requires Service Mode")));
             }
             return patchVerge({ enable_tun_mode: e });
           }}
         >
-          <Switch edge="end" disabled={isSidecarMode} />
+          <Switch edge="end" disabled={isSidecarMode && !isAdminMode} />
         </GuardState>
       </SettingItem>
       <SettingItem
@@ -184,14 +190,32 @@ const SettingSystem = ({ onError }: Props) => {
         </GuardState>
       </SettingItem>
 
-      <SettingItem label={t("Auto Launch")}>
+      <SettingItem 
+        label={t("Auto Launch")}
+        extra={
+          isAdminMode && (
+            <Tooltip title={t("Administrator mode does not support auto launch")}>
+              <WarningRounded sx={{ color: "warning.main", mr: 1 }} />
+            </Tooltip>
+          )
+        }
+      >
         <GuardState
           value={enable_auto_launch ?? false}
           valueProps="checked"
           onCatch={onError}
           onFormat={onSwitchFormat}
-          onChange={(e) => onChangeData({ enable_auto_launch: e })}
+          onChange={(e) => {
+            // 在管理员模式下禁用更改
+            if (isAdminMode) return;
+            onChangeData({ enable_auto_launch: e });
+          }}
           onGuard={async (e) => {
+            if (isAdminMode) {
+              Notice.error(t("Administrator mode does not support auto launch"), 2000);
+              return Promise.reject(new Error(t("Administrator mode does not support auto launch")));
+            }
+            
             try {
               // 在应用更改之前先触发UI更新，让用户立即看到反馈
               onChangeData({ enable_auto_launch: e });
@@ -206,7 +230,7 @@ const SettingSystem = ({ onError }: Props) => {
             }
           }}
         >
-          <Switch edge="end" />
+          <Switch edge="end" disabled={isAdminMode} />
         </GuardState>
       </SettingItem>
 

src/components/shared/ProxyControlSwitches.tsx

@@ -52,7 +52,7 @@ const ProxyControlSwitches = ({ label, onError }: ProxySwitchProps) => {
   );
 
   // 是否以sidecar模式运行
-  const isSidecarMode = runningMode === "sidecar";
+  const isSidecarMode = runningMode === "Sidecar";
 
   const sysproxyRef = useRef<DialogRef>(null);
   const tunRef = useRef<DialogRef>(null);
@@ -120,17 +120,7 @@ const ProxyControlSwitches = ({ label, onError }: ProxySwitchProps) => {
           }}
         >
           <Box sx={{ display: "flex", alignItems: "center" }}>
-            {proxy_auto_config ? (
-              autoproxy?.enable ? (
-                <PlayCircleOutlineRounded
-                  sx={{ color: "success.main", mr: 1.5, fontSize: 28 }}
-                />
-              ) : (
-                <PauseCircleOutlineRounded
-                  sx={{ color: "text.disabled", mr: 1.5, fontSize: 28 }}
-                />
-              )
-            ) : sysproxy?.enable ? (
+            {enable_system_proxy ? (
               <PlayCircleOutlineRounded
                 sx={{ color: "success.main", mr: 1.5, fontSize: 28 }}
               />

src/hooks/use-current-proxy.ts

@@ -1,32 +1,25 @@
-import useSWR from "swr";
 import { useMemo } from "react";
-import { getProxies } from "@/services/api";
-import { getClashConfig } from "@/services/api";
+import { useAppData } from "@/providers/app-data-provider";
+
+// 定义代理组类型
+interface ProxyGroup {
+  name: string;
+  now: string;
+}
 
 // 获取当前代理节点信息的自定义Hook
 export const useCurrentProxy = () => {
-  // 获取代理信息
-  const { data: proxiesData, mutate: mutateProxies } = useSWR(
-    "getProxies",
-    getProxies,
-    {
-      refreshInterval: 2000,
-      revalidateOnFocus: false,
-      revalidateOnReconnect: true,
-    },
-  );
-
-  // 获取当前Clash配置（包含模式信息）
-  const { data: clashConfig } = useSWR("getClashConfig", getClashConfig);
+  // 从AppDataProvider获取数据
+  const { proxies, clashConfig, refreshProxy } = useAppData();
 
   // 获取当前模式
   const currentMode = clashConfig?.mode?.toLowerCase() || "rule";
 
   // 获取当前代理节点信息
   const currentProxyInfo = useMemo(() => {
-    if (!proxiesData) return { currentProxy: null, primaryGroupName: null };
+    if (!proxies) return { currentProxy: null, primaryGroupName: null };
 
-    const { global, groups, records } = proxiesData;
+    const { global, groups, records } = proxies;
 
     // 默认信息
     let primaryGroupName = "GLOBAL";
@@ -43,11 +36,11 @@ export const useCurrentProxy = () => {
         "自动选择",
       ];
       const primaryGroup =
-        groups.find((group) =>
+        groups.find((group: ProxyGroup) =>
           primaryKeywords.some((keyword) =>
             group.name.toLowerCase().includes(keyword.toLowerCase()),
           ),
-        ) || groups.filter((g) => g.name !== "GLOBAL")[0];
+        ) || groups.filter((g: ProxyGroup) => g.name !== "GLOBAL")[0];
 
       if (primaryGroup) {
         primaryGroupName = primaryGroup.name;
@@ -71,12 +64,12 @@ export const useCurrentProxy = () => {
     };
 
     return { currentProxy, primaryGroupName };
-  }, [proxiesData, currentMode]);
+  }, [proxies, currentMode]);
 
   return {
     currentProxy: currentProxyInfo.currentProxy,
     primaryGroupName: currentProxyInfo.primaryGroupName,
     mode: currentMode,
-    refreshProxy: mutateProxies,
+    refreshProxy,
   };
 };

src/hooks/use-system-state.ts

@@ -0,0 +1,29 @@
+import useSWR from "swr";
+import { getRunningMode, isAdmin } from "@/services/cmds";
+
+/**
+ * 自定义 hook 用于获取系统运行状态
+ * 包括运行模式和管理员状态
+ */
+export function useSystemState() {
+  // 获取运行模式
+  const { data: runningMode = "Sidecar", mutate: mutateRunningMode } = 
+    useSWR("getRunningMode", getRunningMode, { 
+      suspense: false,
+      revalidateOnFocus: false 
+    });
+  
+  // 获取管理员状态
+  const { data: isAdminMode = false } = 
+    useSWR("isAdmin", isAdmin, { 
+      suspense: false,
+      revalidateOnFocus: false 
+    });
+  
+  return {
+    runningMode,
+    isAdminMode,
+    isSidecarMode: runningMode === "Sidecar",
+    mutateRunningMode
+  };
+} 

src/locales/en.json

@@ -27,6 +27,7 @@
   "Proxies": "Proxies",
   "Proxy Groups": "Proxy Groups",
   "Proxy Provider": "Proxy Provider",
+  "Proxy Count": "Proxy Count",
   "Update All": "Update All",
   "Update At": "Update At",
   "rule": "rule",
@@ -201,12 +202,16 @@
   "Tun Mode": "Tun Mode",
   "TUN requires Service Mode": "TUN mode requires install service",
   "Install Service": "Install Service",
+  "Install Service failed": "Install Service failed",
+  "Restart Core failed": "Restart Core failed",
   "Reset to Default": "Reset to Default",
   "Tun Mode Info": "Tun (Virtual NIC) mode: Captures all system traffic, when enabled, there is no need to enable system proxy.",
   "System Proxy Enabled": "System proxy is enabled, your applications will access the network through the proxy",
   "System Proxy Disabled": "System proxy is disabled, it is recommended for most users to turn on this option",
+  "TUN Mode Enabled": "TUN mode is enabled, applications will access the network through the virtual network card",
+  "TUN Mode Disabled": "TUN mode is disabled, suitable for special applications",
   "TUN Mode Service Required": "TUN mode requires service mode, please install the service first",
-  "TUN Mode Intercept Info": "TUN mode can take over all application traffic, suitable for special applications",
+  "TUN Mode Intercept Info": "TUN mode can take over all application traffic, suitable for special applications that do not follow the system proxy settings",
   "rule Mode Description": "Routes traffic according to preset rules, provides flexible proxy strategies",
   "global Mode Description": "All traffic goes through proxy servers, suitable for scenarios requiring global internet access",
   "direct Mode Description": "All traffic doesn't go through proxy nodes, but is forwarded by Clash kernel to target servers, suitable for specific scenarios requiring kernel traffic distribution",
@@ -250,6 +255,7 @@
   "PAC Script Content": "PAC Script Content",
   "PAC URL": "PAC URL: ",
   "Auto Launch": "Auto Launch",
+  "Administrator mode does not support auto launch": "Administrator mode does not support auto launch",
   "Silent Start": "Silent Start",
   "Silent Start Info": "Start the program in background mode without displaying the panel",
   "TG Channel": "Telegram Channel",
@@ -351,6 +357,7 @@
   "clash_mode_direct": "Direct Mode",
   "toggle_system_proxy": "Enable/Disable System Proxy",
   "toggle_tun_mode": "Enable/Disable Tun Mode",
+  "entry_lightweight_mode": "Entry Lightweight Mode",
   "Backup Setting": "Backup Setting",
   "Backup Setting Info": "Support WebDAV backup configuration files",
   "Runtime Config": "Runtime Config",
@@ -451,6 +458,7 @@
   "Global Mode": "Global Mode",
   "Direct Mode": "Direct Mode",
   "Enable Tray Speed": "Enable Tray Speed",
+  "Enable Tray Icon": "Enable Tray Icon",
   "LightWeight Mode": "Lightweight Mode",
   "LightWeight Mode Info": "Close the GUI and keep only the kernel running",
   "LightWeight Mode Settings": "LightWeight Mode Settings",
@@ -484,8 +492,9 @@
   "Validation Failed": "Validation Failed",
   "Service Administrator Prompt": "Clash Verge requires administrator privileges to reinstall the system service",
   "DNS Settings": "DNS Settings",
+  "DNS settings saved": "DNS settings saved",
   "DNS Overwrite": "DNS Overwrite",
-  "DNS Settings Warning": "If you are not familiar with these settings, please do not modify them and keep DNS Settings enabled",
+  "DNS Settings Warning": "If you are not familiar with these settings, please do not modify them and keep DNS Overwrite enabled",
   "Enable DNS": "Enable DNS",
   "DNS Listen": "DNS Listen",
   "Enhanced Mode": "Enhanced Mode",
@@ -546,9 +555,19 @@
   "OS Info": "OS Info",
   "Running Mode": "Running Mode",
   "Sidecar Mode": "User Mode",
+  "Administrator Mode": "Administrator Mode",
+  "Administrator + Service Mode": "Admin + Service Mode",
   "Last Check Update": "Last Check Update",
   "Click to import subscription": "Click to import subscription",
   "Update subscription successfully": "Update subscription successfully",
+  "Update failed, retrying with Clash proxy...": "Update failed, retrying with Clash proxy...",
+  "Update with Clash proxy successfully": "Update with Clash proxy successfully",
+  "Update failed even with Clash proxy": "Update failed even with Clash proxy",
+  "Profile creation failed, retrying with Clash proxy...": "Profile creation failed, retrying with Clash proxy...",
+  "Profile creation succeeded with Clash proxy": "Profile creation succeeded with Clash proxy",
+  "Import failed, retrying with Clash proxy...": "Import failed, retrying with Clash proxy...",
+  "Profile Imported with Clash proxy": "Profile Imported with Clash proxy",
+  "Import failed even with Clash proxy": "Import failed even with Clash proxy",
   "Current Node": "Current Node",
   "No active proxy node": "No active proxy node",
   "Network Settings": "Network Settings",
@@ -570,7 +589,6 @@
   "No": "No",
   "Failed": "Failed",
   "Completed": "Completed",
-  "Bahamut Anime": "Bahamut Anime",
   "Disallowed ISP": "Disallowed ISP",
   "Originals Only": "Originals Only",
   "No (IP Banned By Disney+)": "No (IP Banned By Disney+)",

src/locales/ru.json

@@ -16,12 +16,13 @@
   "Delete": "Удалить",
   "Enable": "Включить",
   "Disable": "Отключить",
+  "Label-Home": "Главная",
   "Label-Proxies": "Прокси",
   "Label-Profiles": "Профили",
   "Label-Connections": "Соединения",
   "Label-Rules": "Правила",
   "Label-Logs": "Логи",
-  "Label-Test": "Тест",
+  "Label-Unlock": "Тест",
   "Label-Settings": "Настройки",
   "Proxies": "Прокси",
   "Proxy Groups": "Группы прокси",
@@ -39,12 +40,12 @@
   "Sort by name": "Сортировать по названию",
   "Delay check URL": "URL проверки задержки",
   "Delay check to cancel fixed": "Проверка задержки для отмены фиксированного",
-  "Proxy basic": "Резюме о прокси",
-  "Proxy detail": "Подробности о прокси",
+  "Proxy basic": "Отображать меньше сведений о прокси",
+  "Proxy detail": "Отображать больше сведений о прокси",
   "Profiles": "Профили",
   "Update All Profiles": "Обновить все профили",
   "View Runtime Config": "Просмотреть используемый конфиг",
-  "Reactivate Profiles": "Реактивировать профили",
+  "Reactivate Profiles": "Перезапустить профиль",
   "Paste": "Вставить",
   "Profile URL": "URL профиля",
   "Import": "Импорт",
@@ -135,19 +136,19 @@
   "Hidden": "Скрытый",
   "Group Name Required": "Требуется имя группы",
   "Group Name Already Exists": "Имя группы уже существует",
-  "Extend Config": "Изменить Merge.",
+  "Extend Config": "Изменить Merge",
   "Extend Script": "Изменить Script",
   "Global Merge": "Глобальный расширенный Настройки",
   "Global Script": "Глобальный расширенный скрипт",
   "Type": "Тип",
   "Name": "Название",
-  "Descriptions": "Описания",
+  "Descriptions": "Описание",
   "Subscription URL": "URL подписки",
   "Update Interval": "Интервал обновления",
   "Choose File": "Выбрать файл",
   "Use System Proxy": "Использовать системный прокси для обновления",
   "Use Clash Proxy": "Использовать прокси Clash для обновления",
-  "Accept Invalid Certs (Danger)": "Принимать недействительные сертификаты (Опасно)",
+  "Accept Invalid Certs (Danger)": "Принимать недействительные сертификаты (ОПАСНО)",
   "Refresh": "Обновить",
   "Home": "Главная",
   "Select": "Выбрать",
@@ -162,17 +163,19 @@
   "To Top": "Наверх",
   "To End": "Вниз",
   "Connections": "Соединения",
-  "Table View": "Tablichnyy vid",
-  "List View": "Spiskovyy vid",
+  "Table View": "Отображать в виде таблицы",
+  "List View": "Отображать в виде списка",
   "Close All": "Закрыть всё",
-  "Default": "По умолчанию",
-  "Download Speed": "Скорость загрузки",
+  "Upload": "Загрузка",
+  "Download": "Скачивание",
+  "Download Speed": "Скорость скачивания",
   "Upload Speed": "Скорость загрузки",
   "Host": "Хост",
   "Downloaded": "Скачано",
   "Uploaded": "Загружено",
-  "DL Speed": "Скорость загрузки",
-  "UL Speed": "Скорость выгрузки",
+  "DL Speed": "Скорость скачивания",
+  "UL Speed": "Скорость загрузки",
+  "Active Connections": "Активные соединения",
   "Chains": "Цепочки",
   "Rule": "Правило",
   "Process": "Процесс",
@@ -182,31 +185,43 @@
   "DestinationPort": "Целевой порт",
   "Close Connection": "Закрыть соединение",
   "Rules": "Правила",
-  "Rule Provider": "Провайдер правило",
+  "Rule Provider": "Провайдеры правил",
   "Logs": "Логи",
   "Pause": "Пауза",
   "Clear": "Очистить",
   "Test": "Тест",
-  "Test All": "Тест Все",
+  "Test All": "Тестировать все",
+  "Testing...": "Тестирование ...",
   "Create Test": "Создать тест",
   "Edit Test": "Редактировать тест",
-  "Icon": "Икона",
-  "Test URL": "Тестовый URL",
+  "Icon": "Иконка",
+  "Test URL": "URL проверка",
   "Settings": "Настройки",
   "System Setting": "Настройки системы",
-  "Tun Mode": "Tun (виртуальный сетевой адаптер) режим",
-  "Reset to Default": "Сбросить настройки по умолчанию",
-  "Tun Mode Info": "Режим Tun (виртуальный сетевой адаптер): захватывает весь системный трафик, при включении нет необходимости включать системный прокси-сервер.",
+  "Tun Mode": "Режим TUN",
+  "TUN requires Service Mode": "Режим TUN требует установленную службу Clash Verge",
+  "Install Service": "Установить службу",
+  "Reset to Default": "Сбросить настройки",
+  "Tun Mode Info": "Режим Tun: захватывает весь системный трафик, при включении нет необходимости включать системный прокси-сервер.",
+  "System Proxy Enabled": "Системный прокси включен, ваши приложения будут получать доступ к сети через него",
+  "System Proxy Disabled": "Системный прокси отключен, большинству пользователей рекомендуется включить эту опцию",
+  "TUN Mode Enabled": "Режим TUN включен, приложения будут получать доступ к сети через виртуальную сетевую карту",
+  "TUN Mode Disabled": "Режим TUN отключен",
+  "TUN Mode Service Required": "Режим TUN требует установленную службу Clash Verge",
+  "TUN Mode Intercept Info": "Режим TUN может перехватить трафик всех приложений, подходит для приложений, которые не работают в режиме системного прокси.",
+  "rule Mode Description": "Направляет трафик в соответствии с предустановленными правилами",
+  "global Mode Description": "Направляет весь трафик через прокси-серверы",
+  "direct Mode Description": "Весь трафик обходит прокси, но передается ядром Clash для целевых серверов, подходит для конкретных сценариев, требующих распределения трафика ядра",
   "Stack": "Стек",
-  "System and Mixed Can Only be Used in Service Mode": "Система и смешанные могут использоваться только в сервисном режиме",
+  "System and Mixed Can Only be Used in Service Mode": "Стэк System и Mixed могут использоваться только в режиме системной службы",
   "Device": "Имя устройства",
   "Auto Route": "Автоматическая маршрутизация",
-  "Strict Route": "Строгий маршрут",
+  "Strict Route": "Строгая маршрутизация",
   "Auto Detect Interface": "Автоопределение интерфейса",
   "DNS Hijack": "DNS-перехват",
-  "MTU": "Максимальная единица передачи",
-  "Service Mode": "Режим сервиса",
-  "Service Mode Info": "Установите сервисный режим перед включением режима TUN. Процесс ядра, запущенный службой, может получить разрешение на установку виртуальной сетевой карты (режим TUN).",
+  "MTU": "MTU",
+  "Service Mode": "Режим системной службы",
+  "Service Mode Info": "Установите режим системной службы перед включением режима TUN. Процесс ядра, запущенный службой, может получить разрешение на установку виртуальной сетевой карты (режим TUN).",
   "Current State": "Текущее состояние",
   "pending": "Ожидающий",
   "installed": "Установленный",
@@ -216,7 +231,7 @@
   "Information: Please make sure that the Clash Verge Service is installed and enabled": "Информация: Пожалуйста, убедитесь, что сервис Clash Verge Service установлен и включен",
   "Install": "Установить",
   "Uninstall": "Удалить",
-  "Disable Service Mode": "Отключить режим обслуживания",
+  "Disable Service Mode": "Отключить режим системной службы",
   "System Proxy": "Системный прокси",
   "System Proxy Info": "Разрешить изменение настроек прокси-сервера операционной системы. Если разрешение не удастся, измените настройки прокси-сервера операционной системы вручную",
   "System Proxy Setting": "Настройка системного прокси",
@@ -226,30 +241,30 @@
   "Disabled": "Отключено",
   "Server Addr": "Адрес сервера: ",
   "Not available": "Недоступно",
-  "Proxy Guard": "Защита прокси",
-  "Proxy Guard Info": "Включите эту функцию чтобы предотвратить изменение настроек прокси-сервера операционной системы другим программным обеспечением",
+  "Proxy Guard": "Proxy Guard",
+  "Proxy Guard Info": "Включите эту функцию чтобы предотвратить изменение настроек прокси-сервера операционной системы другим ПО",
   "Guard Duration": "Период защиты",
   "Always use Default Bypass": "Всегда использовать стандартное обходное решение",
   "Use Bypass Check": "Используйте проверку обхода",
-  "Proxy Bypass": "Игнорирование прокси: ",
-  "Bypass": "Игнорирование: ",
+  "Proxy Bypass": "Игнорируемые адреса: ",
+  "Bypass": "Игнорируемые адреса: ",
   "Use PAC Mode": "Используйте режим PAC",
   "PAC Script Content": "Содержание сценария PAC",
   "PAC URL": "Адрес PAC: ",
   "Auto Launch": "Автозапуск",
   "Silent Start": "Тихий запуск",
   "Silent Start Info": "Запускать программу в фоновом режиме без отображения панели",
-  "TG Channel": "Канал Telegram",
+  "TG Channel": "Telegram-канал",
   "Manual": "Документация",
   "Github Repo": "GitHub репозиторий",
   "Clash Setting": "Настройки Clash",
-  "Allow Lan": "Разрешить локальную сеть",
+  "Allow Lan": "Разрешить доступ из локальной сети",
   "Network Interface": "Сетевой интерфейс",
   "Ip Address": "IP адрес",
   "Mac Address": "MAC адрес",
   "IPv6": "IPv6",
-  "Unified Delay": "Общий задержка",
-  "Unified Delay Info": "Когда унифицированная задержка включена, будут выполнены два теста задержки, чтобы устранить различия в задержке между разными типами узлов, вызванные подтверждением соединения и т. д",
+  "Unified Delay": "Точная задержка",
+  "Unified Delay Info": "Когда унифицированная(точная) задержка включена, будут выполнены два теста задержки, чтобы устранить различия в задержке между разными типами узлов, вызванные подтверждением соединения и т. д",
   "Log Level": "Уровень логов",
   "Log Level Info": "Это действует только на файлы журнала ядра в служебном файле в каталоге журналов.",
   "Port Config": "Настройка порта",
@@ -259,32 +274,34 @@
   "Http Port": "Порт Http(s)-прокси",
   "Redir Port": "Порт прозрачного прокси Redir",
   "Tproxy Port": "Порт прозрачного прокси Tproxy",
-  "External": "Внешний",
+  "External": "Внешний контроллер",
   "External Controller": "Адрес прослушивания внешнего контроллера",
   "Core Secret": "Секрет",
   "Recommended": "Рекомендуется",
-  "Open URL": "Открыть URL",
-  "Replace host, port, secret with %host, %port, %secret": "Замените хост, порт, секрет на %host, %port, %secret",
-  "Support %host, %port, %secret": "Поддержка %host, %port, %secret",
-  "Clash Core": "Ядра Clash",
-  "Upgrade": "Обновлять",
-  "Restart": "Перезапуск",
+  "Open URL": "Перейти по адресу",
+  "Replace host, port, secret with %host, %port, %secret": "Замените хост, порт и секрет на %host, %port, %secret",
+  "Support %host, %port, %secret": "Поддерживаются %host, %port, %secret",
+  "Clash Core": "Ядро Clash",
+  "Upgrade": "Обновить",
+  "Restart": "Перезапустить",
   "Release Version": "Официальная версия",
   "Alpha Version": "Альфа-версия",
-  "Please Enable Service Mode": "Пожалуйста, сначала установите и включите режим обслуживания",
+  "Please Enable Service Mode": "Пожалуйста, сначала установите и включите режим системной службы",
   "Please enter your root password": "Пожалуйста, введите ваш пароль root",
   "Grant": "Предоставить",
   "Open UWP tool": "Открыть UWP инструмент",
   "Open UWP tool Info": "С Windows 8 приложения UWP (такие как Microsoft Store) ограничены в прямом доступе к сетевым службам локального хоста, и этот инструмент позволяет обойти это ограничение",
-  "Update GeoData": "Обновление GeoData",
-  "Verge Setting": "Настройки Verge",
+  "Update GeoData": "Обновить GeoData",
+  "Verge Basic Setting": "Основные настройки Verge",
+  "Verge Advanced Setting": "Расширенные настройки Verge",
   "Language": "Язык",
-  "Theme Mode": "Режим темы",
+  "Theme Mode": "Цветовая тема",
   "theme.light": "Светлая",
   "theme.dark": "Тёмная",
   "theme.system": "Системная",
-  "Tray Click Event": "Событие щелчка в лотке",
+  "Tray Click Event": "Событие при щелчке по иконке в трее",
   "Show Main Window": "Показать главное окно",
+  "Show Tray Menu": "Показать меню в трее",
   "Copy Env Type": "Скопировать тип Env",
   "Copy Success": "Скопировано",
   "Start Page": "Главная страница",
@@ -293,8 +310,8 @@
   "Theme Setting": "Настройки темы",
   "Primary Color": "Основной цвет",
   "Secondary Color": "Вторичный цвет",
-  "Primary Text Color": "Основной текст",
-  "Secondary Text Color": "Вторичный текст",
+  "Primary Text": "Первичный текст",
+  "Secondary Text": "Вторичный текст",
   "Info Color": "Информационный цвет",
   "Warning Color": "Цвет предупреждения",
   "Error Color": "Цвет ошибки",
@@ -306,50 +323,53 @@
   "Memory Usage": "Использование памяти",
   "Memory Cleanup": "Нажмите, чтобы очистить память",
   "Proxy Group Icon": "Иконка Группы прокси",
-  "Nav Icon": "Иконка навигации",
-  "Monochrome": "Монохромный",
-  "Colorful": "Полноцветный",
-  "Tray Icon": "Иконка лотка",
-  "Common Tray Icon": "Общий значок в лотке",
-  "System Proxy Tray Icon": "Значок системного прокси в лотке",
-  "Tun Tray Icon": "Значок туннеля в лотке",
-  "Miscellaneous": "Настройки Прочие",
+  "Nav Icon": "Иконки навигации",
+  "Monochrome": "Монохромные",
+  "Colorful": "Цветные",
+  "Tray Icon": "Иконка в трее",
+  "Common Tray Icon": "Общий значок в трее",
+  "System Proxy Tray Icon": "Значок системного прокси в трее",
+  "Tun Tray Icon": "Значок TUN в трее",
+  "Miscellaneous": "Расширенные настройки",
   "App Log Level": "Уровень журнала приложения",
   "Auto Close Connections": "Автоматическое закрытие соединений",
-  "Auto Close Connections Info": "Завершить установленные соединения при изменении выбора группы прокси или режима прокси",
+  "Auto Close Connections Info": "Закрыть установленные соединения при изменении выбора группы прокси или режима прокси",
   "Auto Check Update": "Автоматическая проверка обновлений",
   "Enable Builtin Enhanced": "Включить встроенные улучшения",
   "Enable Builtin Enhanced Info": "Обработка совместимости для файла конфигурации",
   "Proxy Layout Columns": "Количество столбцов в макете прокси",
   "Auto Columns": "Авто колонки",
-  "Auto Log Clean": "Автоматическая очистка журналов",
+  "Auto Log Clean": "Автоматическая очистка логов",
   "Never Clean": "Никогда не очищать",
   "Retain _n Days": "Сохранять {{n}} дней",
-  "Default Latency Test": "Ссылка на тестирование задержки по умолчанию",
+  "Default Latency Test": "Ссылка на тест задержки",
   "Default Latency Test Info": "Используется только для тестирования HTTP-запросов клиента и не влияет на файл конфигурации",
   "Default Latency Timeout": "Таймаут задержки по умолчанию",
-  "Hotkey Setting": "Настройки клавиатурных сокращений",
+  "Hotkey Setting": "Настройки сочетаний клавиш",
   "Enable Global Hotkey": "Включить глобальную горячую клавишу",
   "open_or_close_dashboard": "Открыть/Закрыть панель управления",
   "clash_mode_rule": "Режим правил",
   "clash_mode_global": "Глобальный режим",
   "clash_mode_direct": "Прямой режим",
   "toggle_system_proxy": "Включить/Отключить системный прокси",
-  "toggle_tun_mode": "Включить/Отключить режим туннеля",
+  "toggle_tun_mode": "Включить/Отключить режим TUN",
+  "entry_lightweight_mode": "Вход в LightWeight Mode",
   "Backup Setting": "Настройки резервного копирования",
   "Backup Setting Info": "Поддерживает файлы конфигурации резервного копирования WebDAV",
   "Runtime Config": "Используемый конфиг",
   "Open Conf Dir": "Открыть папку приложения",
-  "Open Conf Dir Info": "Если программное обеспечение работает ненормально, сделайте резервную копию и удалите все файлы в этой папке, а затем перезапустите программное обеспечение",
+  "Open Conf Dir Info": "Если программное обеспечение работает неправильно, сделайте резервную копию и удалите все файлы в этой папке, а затем перезапустите ПО",
   "Open Core Dir": "Открыть папку ядра",
   "Open Logs Dir": "Открыть папку логов",
   "Check for Updates": "Проверить обновления",
   "Go to Release Page": "Перейти на страницу релизов",
-  "Portable Updater Error": "Портативная версия не поддерживает обновление внутри приложения, пожалуйста, скачайте и замените вручную",
+  "Portable Updater Error": "Портативная версия не поддерживает обновление внутри приложения, пожалуйста, скачайте и замените файлы вручную",
   "Break Change Update Error": "Это крупное обновление, которое не поддерживает обновление внутри приложения. Пожалуйста, удалите его и загрузите установочный файл вручную.",
-  "Open Dev Tools": "Открыть инструменты разработчика",
+  "Open Dev Tools": "Открыть Dev Tools",
+  "Export Diagnostic Info": "Экспорт диагностической информации",
+  "Export Diagnostic Info For Issue Reporting": "Экспорт диагностической информации для отчета об ошибке",
   "Exit": "Выход",
-  "Verge Version": "Версия Verge",
+  "Verge Version": "Версия Clash Verge Rev",
   "ReadOnly": "Только для чтения",
   "ReadOnlyMessage": "Невозможно редактировать в режиме только для чтения",
   "Filter": "Фильтр",
@@ -359,23 +379,24 @@
   "Use Regular Expression": "Использовать регулярные выражения",
   "Profile Imported Successfully": "Профиль успешно импортирован",
   "Profile Switched": "Профиль изменен",
-  "Profile Reactivated": "Профиль повторно активирован",
+  "Profile Reactivated": "Профиль перезапущен",
   "Only YAML Files Supported": "Поддерживаются только файлы YAML",
-  "Settings Applied": "Применены настройки",
+  "Settings Applied": "Настройки применены",
+  "Installing Service...": "Установка службы...",
   "Service Installed Successfully": "Служба успешно установлена",
   "Service Uninstalled Successfully": "Служба успешно удалена",
   "Proxy Daemon Duration Cannot be Less than 1 Second": "Продолжительность работы прокси-демона не может быть меньше 1 секунды",
   "Invalid Bypass Format": "Неверный формат обхода",
-  "Clash Port Modified": "Clash порт изменен",
+  "Clash Port Modified": "Порт Clash изменен",
   "Port Conflict": "Конфликт портов",
   "Restart Application to Apply Modifications": "Чтобы изменения вступили в силу, необходимо перезапустить приложение",
-  "External Controller Address Modified": "Изменен адрес внешнего контроллера",
+  "External Controller Address Modified": "Настройки внешнего контроллера изменены",
   "Permissions Granted Successfully for _clash Core": "Разрешения успешно предоставлены для ядра {{core}}",
-  "Core Version Updated": "Обновлена версия ядра",
-  "Clash Core Restarted": "Clash ядра перезапущено",
-  "GeoData Updated": "GeoData Обновлена",
-  "Currently on the Latest Version": "В настоящее время используется последняя версия",
-  "Import subscription successful": "Импорт подписки успешно",
+  "Core Version Updated": "Ядро обновлено до последней версии",
+  "Clash Core Restarted": "Ядро перезапущено",
+  "GeoData Updated": "Файлы GeoData обновлены",
+  "Currently on the Latest Version": "Обновление не требуется",
+  "Import Subscription Successful": "Подписка успешно импортирована",
   "WebDAV Server URL": "URL-адрес сервера WebDAV http(s)://",
   "Username": "Имя пользователя",
   "Password": "Пароль",
@@ -410,12 +431,12 @@
   "PAC File": "PAC файл",
   "Web UI": "Веб-интерфейс",
   "Hotkeys": "Горячие клавиши",
-  "Verge Mixed Port": "Смешанный порт Verge",
-  "Verge Socks Port": "Порт Verge Socks",
-  "Verge Redir Port": "Порт перенаправления Verge",
-  "Verge Tproxy Port": "Порт Verge Tproxy",
+  "Verge Mixed Port": "Mixed порт",
+  "Verge Socks Port": "Порт Socks",
+  "Verge Redir Port": "Порт Redir",
+  "Verge Tproxy Port": "Порт Tproxy",
   "Verge Port": "Порт Verge",
-  "Verge HTTP Enabled": "HTTP Verge включен",
+  "Verge HTTP Enabled": "HTTP включен",
   "WebDAV URL": "URL WebDAV",
   "WebDAV Username": "Имя пользователя WebDAV",
   "WebDAV Password": "Пароль WebDAV",
@@ -432,9 +453,16 @@
   "Rule Mode": "Режим правил",
   "Global Mode": "Глобальный режим",
   "Direct Mode": "Прямой режим",
-  "Enable Tray Speed": "Включить скорость в лотке",
-  "LightWeight Mode": "Облегченный режим",
-  "LightWeight Mode Info": "Закройте графический интерфейс и оставьте работать только ядро",
+  "Enable Tray Speed": "Показывать скорость в трее",
+  "Enable Tray Icon": "Показывать значок в трее",
+  "LightWeight Mode": "LightWeight Mode",
+  "LightWeight Mode Info": "Режим, в котором работает только ядро Clash, а графический интрефейс закрыт",
+  "LightWeight Mode Settings": "Настройки LightWeight Mode",
+  "Enter LightWeight Mode Now": "Войти в LightWeight Mode",
+  "Auto Enter LightWeight Mode": "Автоматический вход в LightWeight Mode",
+  "Auto Enter LightWeight Mode Info": "Автоматически включать LightWeight Mode, если окно закрыто определенное время",
+  "Auto Enter LightWeight Mode Delay": "Задержка включения LightWeight Mode",
+  "When closing the window, LightWeight Mode will be automatically activated after _n minutes": "При закрытии окна LightWeight Mode будет автоматически активирован через {{n}} минут",
   "Config Validation Failed": "Ошибка проверки конфигурации подписки, проверьте файл конфигурации, изменения отменены, ошибка:",
   "Boot Config Validation Failed": "Ошибка проверки конфигурации при запуске, используется конфигурация по умолчанию, проверьте файл конфигурации, ошибка:",
   "Core Change Config Validation Failed": "Ошибка проверки конфигурации при смене ядра, используется конфигурация по умолчанию, проверьте файл конфигурации, ошибка:",
@@ -443,12 +471,112 @@
   "Script Missing Main": "Ошибка скрипта, изменения отменены",
   "File Not Found": "Файл не найден, изменения отменены",
   "Script File Error": "Ошибка файла скрипта, изменения отменены",
-  "Core Changed Successfully": "Ядро успешно сменено",
+  "Core Changed Successfully": "Ядро успешно изменено",
   "Failed to Change Core": "Не удалось сменить ядро",
-  "Verge Basic Setting": "Основные настройки Verge",
-  "Verge Advanced Setting": "Расширенные настройки Verge",
-  "TUN requires Service Mode": "Режим TUN требует обслуживания",
-  "Install Service": "Установить службу",
-  "Installing Service...": "Установка службы...",
-  "Service Administrator Prompt": "Clash Verge требует прав администратора для переустановки системной службы"
+  "YAML Syntax Error": "Ошибка синтаксиса YAML, откат изменений",
+  "YAML Read Error": "Ошибка чтения YAML, откат изменений",
+  "YAML Mapping Error": "Ошибка YAML Mapping, откат изменений",
+  "YAML Key Error": "Ошибка ключа YAML, откат изменений",
+  "YAML Error": "Ошибка YAML, откат изменений",
+  "Merge File Syntax Error": "Ошибка синтаксиса Merge File, откат изменений",
+  "Merge File Mapping Error": "Ошибка сопоставления в Merge File, откат изменений",
+  "Merge File Key Error": "Ошибка ключа в Merge File, откат изменений",
+  "Merge File Error": "Ошибка Merge File, откат изменений",
+  "Validate YAML File": "Проверить YAML файл",
+  "Validate Merge File": "Проверить Merge File",
+  "Validation Success": "Файл успешно проверен",
+  "Validation Failed": "Проверка не удалась",
+  "Service Administrator Prompt": "Clash Verge требует прав администратора для переустановки системной службы",
+  "DNS Settings": "Настройки DNS",
+  "DNS Overwrite": "Переопределение настроек DNS",
+  "DNS Settings Warning": "Если вы не знакомы с этими настройками, пожалуйста, не изменяйте и не отключайте их",
+  "Enable DNS": "Включить DNS",
+  "DNS Listen": "Прослушивание DNS",
+  "Enhanced Mode": "Enhanced Mode",
+  "Fake IP Range": "Диапазон FakeIP",
+  "Fake IP Filter Mode": "FakeIP Filter Mode",
+  "Prefer H3": "Предпочитать H3",
+  "DNS DOH使用HTTP/3": "DNS DOH использует http/3",
+  "Respect Rules": "Приоритизировать правила",
+  "DNS连接遵守路由规则": "Соединения DNS следуют правилам маршрутизации",
+  "Use Hosts": "Использовать файл Hosts",
+  "Enable to resolve hosts through hosts file": "Включить разрешение хостов через файл Hosts",
+  "Use System Hosts": "Использовать системный файл Hosts",
+  "Enable to resolve hosts through system hosts file": "Включить разрешение хостов через системный файл Hosts",
+  "Direct Nameserver Follow Policy": "Прямой сервер имен следует политике",
+  "是否遵循nameserver-policy": "Следовать ли политике DNS-серверов",
+  "Default Nameserver": "DNS-сервер по умолчанию",
+  "Default DNS servers used to resolve DNS servers": "DNS-серверы по умолчанию, используемые для разрешения адресов серверов DNS",
+  "Nameserver": "DNS-сервер",
+  "List of DNS servers": "Список DNS-серверов, разделенных запятой",
+  "Fallback": "Fallback",
+  "List of fallback DNS servers": "Список резервных DNS-серверов, разделенных запятой",
+  "Proxy Server Nameserver": "Proxy Server Nameserver",
+  "Proxy Node Nameserver": "DNS-серверы для разрешения домена прокси-узлов",
+  "Direct Nameserver": "DNS-сервер для прямых соединений",
+  "Direct outbound Nameserver": "Список DNS-серверов для прямых соединений, разделенных запятой",
+  "Fake IP Filter": "Фильтр FakeIP",
+  "Domains that skip fake IP resolution": "Домены, которые пропускают разрешение FakeIP, разделенные запятой",
+  "Nameserver Policy": "Политика серверов имен",
+  "Domain-specific DNS server": "DNS-сервер, специфичный для домена, несколько серверов разделяются знаком ';'",
+  "Fallback Filter Settings": "Настройки фильтра Fallback",
+  "GeoIP Filtering": "Фильтрация GeoIP",
+  "Enable GeoIP filtering for fallback": "Включить фильтрацию GeoIP",
+  "GeoIP Code": "Код GeoIP",
+  "Fallback IP CIDR": "Fallback IP CIDR",
+  "IP CIDRs not using fallback servers": "Диапазоны IP-адресов, не использующие резервные серверы, разделенные запятой",
+  "Fallback Domain": "Fallback домены",
+  "Domains using fallback servers": "Домены, использующие резервные серверы, разделенные запятой",
+  "Enable Alpha Channel": "Включить альфа-канал",
+  "Alpha versions may contain experimental features and bugs": "Альфа-версии могут содержать экспериментальные функции и ошибки",
+  "Home Settings": "Настройки главной страницы",
+  "Profile Card": "Карточка профиля",
+  "Current Proxy Card": "Карточка текущего прокси",
+  "Network Settings Card": "Карточка настроек сети",
+  "Proxy Mode Card": "Карточка режима работы",
+  "Clash Mode Card": "Карточка режима Clash",
+  "Traffic Stats Card": "Карточка статистики по трафику",
+  "Clash Info Cards": "Информация о Clash",
+  "System Info Cards": "Информация о системе",
+  "Website Tests Card": "Карточка тестов доступности веб-сайтов",
+  "Traffic Stats": "Статистика по трафику",
+  "Website Tests": "Проверка доступности веб-сайтов",
+  "Clash Info": "Информация о Clash",
+  "Core Version": "Версия ядра",
+  "System Proxy Address": "Адрес системного прокси",
+  "Uptime": "Время работы",
+  "Rules Count": "Количество правил",
+  "System Info": "Информация о системе",
+  "OS Info": "Версия ОС",
+  "Running Mode": "Режим работы",
+  "Sidecar Mode": "Пользовательский режим",
+  "Last Check Update": "Последняя проверка обновлений",
+  "Click to import subscription": "Нажмите, чтобы импортировать подписку",
+  "Update subscription successfully": "Подписка успешно обновлена",
+  "Current Node": "Текущий сервер",
+  "No active proxy node": "Нет активного прокси-узла",
+  "Network Settings": "Настройки сети",
+  "Proxy Mode": "Режим работы",
+  "Group": "Группа",
+  "Proxy": "Прокси",
+  "IP Information Card": "Информация об IP",
+  "IP Information": "Информация об IP",
+  "Failed to get IP info": "Не удалось получить информацию об IP",
+  "ISP": "ISP",
+  "ASN": "ASN",
+  "ORG": "ORG",
+  "Location": "Location",
+  "Timezone": "Timezone",
+  "Auto refresh": "Автоматическое обновление через",
+  "Unlock Test": "Тест доступности веб-сайтов",
+  "Pending": "В ожидании",
+  "Yes": "Да",
+  "No": "Нет",
+  "Failed": "Ошибка",
+  "Completed": "Завершено",
+  "Disallowed ISP": "ISP заблокирован",
+  "Originals Only": "Только Originals",
+  "No (IP Banned By Disney+)": "Нет (IP забанен Disney+)",
+  "Unsupported Country": "Страна не поддерживается",
+  "Failed (Network Connection)": "Ошибка подключения"
 }

src/locales/zh.json

@@ -27,6 +27,7 @@
   "Proxies": "代理",
   "Proxy Groups": "代理组",
   "Proxy Provider": "代理集合",
+  "Proxy Count": "节点数量",
   "Update All": "更新全部",
   "Update At": "更新于",
   "rule": "规则",
@@ -201,12 +202,16 @@
   "Tun Mode": "虚拟网卡模式",
   "TUN requires Service Mode": "TUN 模式需要安装服务",
   "Install Service": "安装服务",
+  "Install Service failed": "安装服务失败",
+  "Restart Core failed": "重启核心失败",
   "Reset to Default": "重置为默认值",
   "Tun Mode Info": "TUN（虚拟网卡）模式接管系统所有流量，启用时无须打开系统代理",
   "System Proxy Enabled": "系统代理已启用，您的应用将通过代理访问网络",
   "System Proxy Disabled": "系统代理已关闭，建议大多数用户打开此选项",
+  "TUN Mode Enabled": "TUN 模式已启用，应用将通过虚拟网卡访问网络",
+  "TUN Mode Disabled": "TUN 模式已关闭，适用于特殊应用",
   "TUN Mode Service Required": "TUN模式需要服务模式，请先安装服务",
-  "TUN Mode Intercept Info": "TUN模式可以接管所有应用流量，适用于特殊应用",
+  "TUN Mode Intercept Info": "TUN模式可以接管所有应用流量，适用于特殊不遵循系统代理设置的应用",
   "rule Mode Description": "基于预设规则智能判断流量走向，提供灵活的代理策略",
   "global Mode Description": "所有流量均通过代理服务器，适用于需要全局科学上网的场景",
   "direct Mode Description": "所有流量不经过代理节点，但经过Clash内核转发连接目标服务器，适用于需要通过内核进行分流的特定场景",
@@ -250,6 +255,7 @@
   "PAC Script Content": "PAC 脚本内容",
   "PAC URL": "PAC 地址：",
   "Auto Launch": "开机自启",
+  "Administrator mode does not support auto launch": "管理员模式不支持开机自启",
   "Silent Start": "静默启动",
   "Silent Start Info": "程序启动时以后台模式运行，不显示程序面板",
   "TG Channel": "Telegram 频道",
@@ -351,6 +357,7 @@
   "clash_mode_direct": "直连模式",
   "toggle_system_proxy": "打开/关闭系统代理",
   "toggle_tun_mode": "打开/关闭 TUN 模式",
+  "entry_lightweight_mode": "进入轻量模式",
   "Backup Setting": "备份设置",
   "Backup Setting Info": "支持 WebDAV 备份配置文件",
   "Runtime Config": "当前配置",
@@ -451,6 +458,7 @@
   "Global Mode": "全局模式",
   "Direct Mode": "直连模式",
   "Enable Tray Speed": "启用托盘速率",
+  "Enable Tray Icon": "启用托盘图标",
   "LightWeight Mode": "轻量模式",
   "LightWeight Mode Info": "关闭GUI界面，仅保留内核运行",
   "LightWeight Mode Settings": "轻量模式设置",
@@ -482,8 +490,9 @@
   "Validate Merge File": "验证覆写文件",
   "Validation Success": "验证成功",
   "Validation Failed": "验证失败",
-  "Service Administrator Prompt": "Clash Verge 需要使用管理员权限来重新安装系统服务",
+  "Service Administrator Prompt": "Clash Verge 需要管理员权限安装系统服务",
   "DNS Settings": "DNS 设置",
+  "DNS settings saved": "DNS 设置已保存",
   "DNS Overwrite": "DNS 覆写",
   "DNS Settings Warning": "如果你不清楚这里的设置请不要修改，并保持 DNS 覆写开启",
   "Enable DNS": "启用 DNS",
@@ -546,9 +555,19 @@
   "OS Info": "操作系统信息",
   "Running Mode": "运行模式",
   "Sidecar Mode": "用户模式",
+  "Administrator Mode": "管理员模式",
+  "Administrator + Service Mode": "管理员 + 服务模式",
   "Last Check Update": "最后检查更新",
   "Click to import subscription": "点击导入订阅",
   "Update subscription successfully": "订阅更新成功",
+  "Update failed, retrying with Clash proxy...": "订阅更新失败，尝试使用 Clash 代理更新",
+  "Update with Clash proxy successfully": "使用 Clash 代理更新成功",
+  "Update failed even with Clash proxy": "使用 Clash 代理更新也失败",
+  "Profile creation failed, retrying with Clash proxy...": "订阅创建失败，尝试使用 Clash 代理创建",
+  "Profile creation succeeded with Clash proxy": "使用 Clash 代理创建订阅成功",
+  "Import failed, retrying with Clash proxy...": "订阅导入失败，尝试使用 Clash 代理导入",
+  "Profile Imported with Clash proxy": "使用 Clash 代理导入订阅成功",
+  "Import failed even with Clash proxy": "使用 Clash 代理导入订阅也失败",
   "Current Node": "当前节点",
   "No active proxy node": "暂无激活的代理节点",
   "Network Settings": "网络设置",
@@ -570,7 +589,6 @@
   "No": "不支持",
   "Failed": "测试失败",
   "Completed": "检测完成",
-  "Bahamut Anime": "动画疯",
   "Disallowed ISP": "不允许的 ISP",
   "Originals Only": "仅限原创",
   "No (IP Banned By Disney+)": "不支持（IP被Disney+禁止）",

src/main.tsx

@@ -19,6 +19,7 @@ import {
   ThemeModeProvider,
   UpdateStateProvider,
 } from "./services/states";
+import { AppDataProvider } from "./providers/app-data-provider";
 
 const mainElementId = "root";
 const container = document.getElementById(mainElementId);
@@ -51,9 +52,11 @@ createRoot(container).render(
   <React.StrictMode>
     <ComposeContextProvider contexts={contexts}>
       <BaseErrorBoundary>
-        <BrowserRouter>
-          <Layout />
-        </BrowserRouter>
+        <AppDataProvider>
+          <BrowserRouter>
+            <Layout />
+          </BrowserRouter>
+        </AppDataProvider>
       </BaseErrorBoundary>
     </ComposeContextProvider>
   </React.StrictMode>

src/pages/_layout.tsx

@@ -249,8 +249,8 @@ const Layout = () => {
               ? {
                   borderRadius: "8px",
                   border: "1px solid var(--divider-color)",
-                  width: "calc(100vw - 0px)",
-                  height: "calc(100vh - 0px)",
+                  width: "calc(100vw - 4px)",
+                  height: "calc(100vh - 4px)",
                 }
               : {},
           ]}

src/pages/connections.tsx

@@ -11,7 +11,6 @@ import {
 } from "@mui/icons-material";
 import { closeAllConnections } from "@/services/api";
 import { useConnectionSetting } from "@/services/states";
-import { useClashInfo } from "@/hooks/use-clash";
 import { BaseEmpty, BasePage } from "@/components/base";
 import { ConnectionItem } from "@/components/connection/connection-item";
 import { ConnectionTable } from "@/components/connection/connection-table";
@@ -25,10 +24,9 @@ import {
   type SearchState,
 } from "@/components/base/base-search-box";
 import { BaseStyledSelect } from "@/components/base/base-styled-select";
-import useSWRSubscription from "swr/subscription";
-import { createSockette, createAuthSockette } from "@/utils/websocket";
 import { useTheme } from "@mui/material/styles";
 import { useVisibility } from "@/hooks/use-visibility";
+import { useAppData } from "@/providers/app-data-provider";
 
 const initConn: IConnections = {
   uploadTotal: 0,
@@ -40,13 +38,15 @@ type OrderFunc = (list: IConnectionsItem[]) => IConnectionsItem[];
 
 const ConnectionsPage = () => {
   const { t } = useTranslation();
-  const { clashInfo } = useClashInfo();
   const pageVisible = useVisibility();
   const theme = useTheme();
   const isDark = theme.palette.mode === "dark";
   const [match, setMatch] = useState(() => (_: string) => true);
   const [curOrderOpt, setOrderOpt] = useState("Default");
   
+  // 使用全局数据
+  const { connections } = useAppData();
+
   const [setting, setSetting] = useConnectionSetting();
 
   const isTableLayout = setting.layout === "table";
@@ -66,99 +66,37 @@ const ConnectionsPage = () => {
   const [isPaused, setIsPaused] = useState(false);
   const [frozenData, setFrozenData] = useState<IConnections | null>(null);
 
-  const { data: connData = initConn } = useSWRSubscription<
-    IConnections,
-    any,
-    "getClashConnections" | null
-  >(
-    clashInfo && pageVisible ? "getClashConnections" : null,
-    (_key, { next }) => {
-      const { server = "", secret = "" } = clashInfo!;
-
-      if (!server) {
-        console.warn("[Connections] 服务器地址为空，无法建立连接");
-        next(null, initConn);
-        return () => {};
-      }
-
-      console.log(`[Connections] 正在连接: ${server}/connections`);
-
-      // 设置较长的超时时间，确保连接可以建立
-      const s = createAuthSockette(`${server}/connections`, secret, {
-        timeout: 8000, // 8秒超时
-        onmessage(event) {
-          const data = JSON.parse(event.data) as IConnections;
-          next(null, (old = initConn) => {
-            const oldConn = old.connections;
-            const maxLen = data.connections?.length;
-
-            const connections: IConnectionsItem[] = [];
-
-            const rest = (data.connections || []).filter((each) => {
-              const index = oldConn.findIndex((o) => o.id === each.id);
-
-              if (index >= 0 && index < maxLen) {
-                const old = oldConn[index];
-                each.curUpload = each.upload - old.upload;
-                each.curDownload = each.download - old.download;
-
-                connections[index] = each;
-                return false;
-              }
-              return true;
-            });
-
-            for (let i = 0; i < maxLen; ++i) {
-              if (!connections[i] && rest.length > 0) {
-                connections[i] = rest.shift()!;
-                connections[i].curUpload = 0;
-                connections[i].curDownload = 0;
-              }
-            }
-
-            return { ...data, connections };
-          });
-        },
-        onerror(event) {
-          console.error("[Connections] WebSocket 连接错误", event);
-          // 报告错误但提供空数据，避免UI崩溃
-          next(null, initConn);
-        },
-        onclose(event) {
-          console.log("[Connections] WebSocket 连接关闭", event);
-        },
-        onopen(event) {
-          console.log("[Connections] WebSocket 连接已建立");
-        },
-      });
-
-      return () => {
-        console.log("[Connections] 清理WebSocket连接");
-        try {
-          s.close();
-        } catch (e) {
-          console.error("[Connections] 关闭连接时出错", e);
-        }
-      };
-    },
-  );
-
+  // 使用全局连接数据
   const displayData = useMemo(() => {
-    return isPaused ? (frozenData ?? connData) : connData;
-  }, [isPaused, frozenData, connData]);
+    if (!pageVisible) return initConn;
+    
+    if (isPaused) {
+      return frozenData ?? {
+        uploadTotal: connections.uploadTotal,
+        downloadTotal: connections.downloadTotal,
+        connections: connections.data
+      };
+    }
+    
+    return {
+      uploadTotal: connections.uploadTotal,
+      downloadTotal: connections.downloadTotal,
+      connections: connections.data
+    };
+  }, [isPaused, frozenData, connections, pageVisible]);
 
   const [filterConn] = useMemo(() => {
     const orderFunc = orderOpts[curOrderOpt];
-    let connections = displayData.connections.filter((conn) => {
+    let conns = displayData.connections.filter((conn) => {
       const { host, destinationIP, process } = conn.metadata;
       return (
         match(host || "") || match(destinationIP || "") || match(process || "")
       );
     });
 
-    if (orderFunc) connections = orderFunc(connections);
+    if (orderFunc) conns = orderFunc(conns);
 
-    return [connections];
+    return [conns];
   }, [displayData, match, curOrderOpt]);
 
   const onCloseAll = useLockFn(closeAllConnections);
@@ -172,13 +110,17 @@ const ConnectionsPage = () => {
   const handlePauseToggle = useCallback(() => {
     setIsPaused((prev) => {
       if (!prev) {
-        setFrozenData(connData);
+        setFrozenData({
+          uploadTotal: connections.uploadTotal,
+          downloadTotal: connections.downloadTotal,
+          connections: connections.data
+        });
       } else {
         setFrozenData(null);
       }
       return !prev;
     });
-  }, [connData]);
+  }, [connections]);
 
   return (
     <BasePage

src/pages/home.tsx

@@ -37,7 +37,11 @@ import { BasePage } from "@/components/base";
 import { ClashInfoCard } from "@/components/home/clash-info-card";
 import { SystemInfoCard } from "@/components/home/system-info-card";
 import { useLockFn } from "ahooks";
-import { entry_lightweight_mode, openWebUrl, patchVergeConfig } from "@/services/cmds";
+import {
+  entry_lightweight_mode,
+  openWebUrl,
+  patchVergeConfig,
+} from "@/services/cmds";
 import { TestCard } from "@/components/home/test-card";
 import { IpInfoCard } from "@/components/home/ip-info-card";
 
@@ -199,7 +203,7 @@ const HomeSettingsDialog = ({
   );
 };
 
-const HomePage = () => {
+export const HomePage = () => {
   const { t } = useTranslation();
   const { verge } = useVerge();
   const { current, mutateProfiles } = useProfiles();
@@ -260,7 +264,11 @@ const HomePage = () => {
       header={
         <Box sx={{ display: "flex", alignItems: "center" }}>
           <Tooltip title={t("LightWeight Mode")} arrow>
-            <IconButton onClick={() => entry_lightweight_mode()} size="small" color="inherit">
+            <IconButton
+              onClick={async () => await entry_lightweight_mode()}
+              size="small"
+              color="inherit"
+            >
               <HistoryEduOutlined />
             </IconButton>
           </Tooltip>
@@ -314,7 +322,6 @@ const HomePage = () => {
               title={t("Traffic Stats")}
               icon={<SpeedOutlined />}
               iconColor="secondary"
-              minHeight={280}
             >
               <EnhancedTrafficStats />
             </EnhancedCard>

src/pages/profiles.tsx

@@ -142,15 +142,36 @@ const ProfilePage = () => {
     setLoading(true);
 
     try {
+      // 尝试正常导入
       await importProfile(url);
       Notice.success(t("Profile Imported Successfully"));
       setUrl("");
-      setLoading(false);
       mutateProfiles();
       await onEnhance(false);
     } catch (err: any) {
-      Notice.error(err.message || err.toString());
-      setLoading(false);
+      // 首次导入失败，尝试使用自身代理
+      const errmsg = err.message || err.toString();
+      Notice.info(t("Import failed, retrying with Clash proxy..."));
+      
+      try {
+        // 使用自身代理尝试导入
+        await importProfile(url, {
+          with_proxy: false,
+          self_proxy: true
+        });
+        
+        // 回退导入成功
+        Notice.success(t("Profile Imported with Clash proxy"));
+        setUrl("");
+        mutateProfiles();
+        await onEnhance(false);
+      } catch (retryErr: any) {
+        // 回退导入也失败
+        const retryErrmsg = retryErr?.message || retryErr.toString();
+        Notice.error(
+          `${t("Import failed even with Clash proxy")}: ${retryErrmsg}`,
+        );
+      }
     } finally {
       setDisabled(false);
       setLoading(false);

src/pages/proxies.tsx

@@ -16,6 +16,12 @@ const ProxyPage = () => {
   const { data: clashConfig, mutate: mutateClash } = useSWR(
     "getClashConfig",
     getClashConfig,
+    {
+      revalidateOnFocus: false,
+      revalidateIfStale: true,
+      dedupingInterval: 1000,
+      errorRetryInterval: 5000
+    }
   );
 
   const { verge } = useVerge();

src/pages/rules.tsx

@@ -1,28 +1,27 @@
-import useSWR from "swr";
 import { useState, useMemo, useRef } from "react";
 import { useTranslation } from "react-i18next";
 import { Virtuoso, VirtuosoHandle } from "react-virtuoso";
 import { Box } from "@mui/material";
-import { getRules } from "@/services/api";
 import { BaseEmpty, BasePage } from "@/components/base";
 import RuleItem from "@/components/rule/rule-item";
 import { ProviderButton } from "@/components/rule/provider-button";
 import { BaseSearchBox } from "@/components/base/base-search-box";
 import { useTheme } from "@mui/material/styles";
 import { ScrollTopButton } from "@/components/layout/scroll-top-button";
+import { useAppData } from "@/providers/app-data-provider";
 
 const RulesPage = () => {
   const { t } = useTranslation();
-  const { data = [] } = useSWR("getRules", getRules);
+  const { rules = [] } = useAppData();
   const theme = useTheme();
   const isDark = theme.palette.mode === "dark";
   const [match, setMatch] = useState(() => (_: string) => true);
   const virtuosoRef = useRef<VirtuosoHandle>(null);
   const [showScrollTop, setShowScrollTop] = useState(false);
 
-  const rules = useMemo(() => {
-    return data.filter((item) => match(item.payload));
-  }, [data, match]);
+  const filteredRules = useMemo(() => {
+    return rules.filter((item) => match(item.payload));
+  }, [rules, match]);
 
   const scrollToTop = () => {
     virtuosoRef.current?.scrollTo({
@@ -64,11 +63,11 @@ const RulesPage = () => {
         <BaseSearchBox onSearch={(match) => setMatch(() => match)} />
       </Box>
 
-      {rules.length > 0 ? (
+      {filteredRules.length > 0 ? (
         <>
           <Virtuoso
             ref={virtuosoRef}
-            data={rules}
+            data={filteredRules}
             style={{
               flex: 1,
             }}

src/providers/app-data-provider.tsx

@@ -0,0 +1,299 @@
+import { createContext, useContext, useMemo } from "react";
+import useSWR from "swr";
+import useSWRSubscription from "swr/subscription";
+import { getProxies, getConnections, getRules, getClashConfig, getProxyProviders, getRuleProviders } from "@/services/api";
+import { getSystemProxy, getRunningMode, getAppUptime } from "@/services/cmds";
+import { useClashInfo } from "@/hooks/use-clash";
+import { createAuthSockette } from "@/utils/websocket";
+import { useVisibility } from "@/hooks/use-visibility";
+
+// 定义AppDataContext类型 - 使用宽松类型
+interface AppDataContextType {
+  proxies: any;
+  clashConfig: any;
+  rules: any[];
+  sysproxy: any;
+  runningMode?: string;
+  uptime: number;
+  proxyProviders: any;
+  ruleProviders: any;
+  connections: {
+    data: any[];
+    count: number;
+    uploadTotal: number;
+    downloadTotal: number;
+  };
+  traffic: {up: number; down: number};
+  memory: {inuse: number};
+  refreshProxy: () => Promise<any>;
+  refreshClashConfig: () => Promise<any>;
+  refreshRules: () => Promise<any>;
+  refreshSysproxy: () => Promise<any>;
+  refreshProxyProviders: () => Promise<any>;
+  refreshRuleProviders: () => Promise<any>;
+  refreshAll: () => Promise<any>;
+}
+
+// 创建上下文
+const AppDataContext = createContext<AppDataContextType | null>(null);
+
+// 全局数据提供者组件
+export const AppDataProvider = ({ children }: { children: React.ReactNode }) => {
+  const { clashInfo } = useClashInfo();
+  const pageVisible = useVisibility();
+  
+  // 基础数据 - 中频率更新 (5秒)
+  const { data: proxiesData, mutate: refreshProxy } = useSWR(
+    "getProxies", 
+    getProxies, 
+    { 
+      refreshInterval: 5000, 
+      revalidateOnFocus: false,
+      suspense: false,
+      errorRetryCount: 3
+    }
+  );
+  
+  const { data: clashConfig, mutate: refreshClashConfig } = useSWR(
+    "getClashConfig", 
+    getClashConfig, 
+    { 
+      refreshInterval: 5000, 
+      revalidateOnFocus: false,
+      suspense: false,
+      errorRetryCount: 3 
+    }
+  );
+  
+  // 提供者数据
+  const { data: proxyProviders, mutate: refreshProxyProviders } = useSWR(
+    "getProxyProviders",
+    getProxyProviders,
+    {
+      revalidateOnFocus: false,
+      suspense: false,
+      errorRetryCount: 3
+    }
+  );
+  
+  const { data: ruleProviders, mutate: refreshRuleProviders } = useSWR(
+    "getRuleProviders",
+    getRuleProviders,
+    {
+      revalidateOnFocus: false,
+      suspense: false,
+      errorRetryCount: 3
+    }
+  );
+  
+  // 低频率更新数据
+  const { data: rulesData, mutate: refreshRules } = useSWR(
+    "getRules", 
+    getRules,
+    { 
+      revalidateOnFocus: false,
+      suspense: false,
+      errorRetryCount: 3
+    }
+  );
+  
+  const { data: sysproxy, mutate: refreshSysproxy } = useSWR(
+    "getSystemProxy", 
+    getSystemProxy,
+    { 
+      revalidateOnFocus: false,
+      suspense: false,
+      errorRetryCount: 3
+    }
+  );
+  
+  const { data: runningMode } = useSWR(
+    "getRunningMode", 
+    getRunningMode,
+    { 
+      revalidateOnFocus: false,
+      suspense: false,
+      errorRetryCount: 3
+    }
+  );
+  
+  // 高频率更新数据 (1秒)
+  const { data: uptimeData } = useSWR(
+    "appUptime", 
+    getAppUptime, 
+    { 
+      refreshInterval: 1000, 
+      revalidateOnFocus: false,
+      suspense: false
+    }
+  );
+  
+  // 连接数据 - 使用WebSocket实时更新
+  const { data: connectionsData = { connections: [], uploadTotal: 0, downloadTotal: 0 } } = 
+    useSWRSubscription(
+      clashInfo && pageVisible ? "connections" : null,
+      (_key, { next }) => {
+        if (!clashInfo || !pageVisible) return () => {};
+        
+        const { server = "", secret = "" } = clashInfo;
+        if (!server) return () => {};
+        
+        const socket = createAuthSockette(`${server}/connections`, secret, {
+          timeout: 5000,
+          onmessage(event) {
+            try {
+              const data = JSON.parse(event.data);
+              // 处理连接数据，计算当前上传下载速度
+              next(null, (prev: any = { connections: [], uploadTotal: 0, downloadTotal: 0 }) => {
+                const oldConns = prev.connections || [];
+                const newConns = data.connections || [];
+                
+                // 计算当前速度
+                const processedConns = newConns.map((conn: any) => {
+                  const oldConn = oldConns.find((old: any) => old.id === conn.id);
+                  if (oldConn) {
+                    return {
+                      ...conn,
+                      curUpload: conn.upload - oldConn.upload,
+                      curDownload: conn.download - oldConn.download
+                    };
+                  }
+                  return { ...conn, curUpload: 0, curDownload: 0 };
+                });
+                
+                return {
+                  ...data,
+                  connections: processedConns
+                };
+              });
+            } catch (err) {
+              console.error("[Connections] 解析数据错误:", err);
+            }
+          },
+          onerror() {
+            next(null, { connections: [], uploadTotal: 0, downloadTotal: 0 });
+          }
+        });
+        
+        return () => socket.close();
+      }
+    );
+  
+  // 流量和内存数据 - 通过WebSocket获取实时流量数据
+  const { data: trafficData = { up: 0, down: 0 } } = useSWRSubscription(
+    clashInfo && pageVisible ? "traffic" : null,
+    (_key, { next }) => {
+      if (!clashInfo || !pageVisible) return () => {};
+      
+      const { server = "", secret = "" } = clashInfo;
+      if (!server) return () => {};
+      
+      const socket = createAuthSockette(`${server}/traffic`, secret, {
+        onmessage(event) {
+          try {
+            const data = JSON.parse(event.data);
+            next(null, data);
+          } catch (err) {
+            console.error("[Traffic] 解析数据错误:", err);
+          }
+        }
+      });
+      
+      return () => socket.close();
+    }
+  );
+  
+  const { data: memoryData = { inuse: 0 } } = useSWRSubscription(
+    clashInfo && pageVisible ? "memory" : null,
+    (_key, { next }) => {
+      if (!clashInfo || !pageVisible) return () => {};
+      
+      const { server = "", secret = "" } = clashInfo;
+      if (!server) return () => {};
+      
+      const socket = createAuthSockette(`${server}/memory`, secret, {
+        onmessage(event) {
+          try {
+            const data = JSON.parse(event.data);
+            next(null, data);
+          } catch (err) {
+            console.error("[Memory] 解析数据错误:", err);
+          }
+        }
+      });
+      
+      return () => socket.close();
+    }
+  );
+  
+  // 提供统一的刷新方法
+  const refreshAll = async () => {
+    await Promise.all([
+      refreshProxy(),
+      refreshClashConfig(),
+      refreshRules(),
+      refreshSysproxy(),
+      refreshProxyProviders(),
+      refreshRuleProviders()
+    ]);
+  };
+  
+  // 聚合所有数据
+  const value = useMemo(() => ({
+    // 数据
+    proxies: proxiesData,
+    clashConfig,
+    rules: rulesData || [],
+    sysproxy,
+    runningMode,
+    uptime: uptimeData || 0,
+    
+    // 提供者数据
+    proxyProviders: proxyProviders || {},
+    ruleProviders: ruleProviders || {},
+    
+    // 连接数据
+    connections: {
+      data: connectionsData.connections || [],
+      count: connectionsData.connections?.length || 0,
+      uploadTotal: connectionsData.uploadTotal || 0,
+      downloadTotal: connectionsData.downloadTotal || 0
+    },
+    
+    // 实时流量数据
+    traffic: trafficData,
+    memory: memoryData,
+    
+    // 刷新方法
+    refreshProxy,
+    refreshClashConfig,
+    refreshRules,
+    refreshSysproxy,
+    refreshProxyProviders,
+    refreshRuleProviders,
+    refreshAll
+  }), [
+    proxiesData, clashConfig, rulesData, sysproxy, 
+    runningMode, uptimeData, connectionsData,
+    trafficData, memoryData, proxyProviders, ruleProviders,
+    refreshProxy, refreshClashConfig, refreshRules, refreshSysproxy,
+    refreshProxyProviders, refreshRuleProviders
+  ]);
+
+  return (
+    <AppDataContext.Provider value={value}>
+      {children}
+    </AppDataContext.Provider>
+  );
+};
+
+// 自定义Hook访问全局数据
+export const useAppData = () => {
+  const context = useContext(AppDataContext);
+  
+  if (!context) {
+    throw new Error("useAppData必须在AppDataProvider内使用");
+  }
+  
+  return context;
+}; 

src/services/api.ts

@@ -3,13 +3,9 @@ import { getClashInfo } from "./cmds";
 import { invoke } from "@tauri-apps/api/core";
 import { useLockFn } from "ahooks";
 
-let axiosIns: AxiosInstance = null!;
-
-/// initialize some information
-/// enable force update axiosIns
-export const getAxios = async (force: boolean = false) => {
-  if (axiosIns && !force) return axiosIns;
+let instancePromise: Promise<AxiosInstance> = null!;
 
+async function getInstancePromise() {
   let server = "";
   let secret = "";
 
@@ -26,13 +22,22 @@ export const getAxios = async (force: boolean = false) => {
     if (info?.secret) secret = info?.secret;
   } catch {}
 
-  axiosIns = axios.create({
+  const axiosIns = axios.create({
     baseURL: `http://${server}`,
     headers: secret ? { Authorization: `Bearer ${secret}` } : {},
     timeout: 15000,
   });
   axiosIns.interceptors.response.use((r) => r.data);
   return axiosIns;
+}
+
+/// initialize some information
+/// enable force update axiosIns
+export const getAxios = async (force: boolean = false) => {
+  if (!instancePromise || force) {
+    instancePromise = getInstancePromise();
+  }
+  return instancePromise;
 };
 
 /// Get Version

src/services/cmds.ts

@@ -1,4 +1,3 @@
-import dayjs from "dayjs";
 import { invoke } from "@tauri-apps/api/core";
 import { Notice } from "@/components/base";
 
@@ -37,10 +36,10 @@ export async function saveProfileFile(index: string, fileData: string) {
   return invoke<void>("save_profile_file", { index, fileData });
 }
 
-export async function importProfile(url: string) {
+export async function importProfile(url: string, option?: IProfileOption) {
   return invoke<void>("import_profile", {
     url,
-    option: { with_proxy: true },
+    option: option || { with_proxy: true },
   });
 }
 
@@ -320,15 +319,39 @@ export const getAppUptime = async () => {
   return invoke<number>("get_app_uptime");
 };
 
-// 安装/重装系统服务
+// 安装系统服务
 export const installService = async () => {
   return invoke<void>("install_service");
 };
 
+// 卸载系统服务
+export const uninstallService = async () => {
+  return invoke<void>("uninstall_service");
+};
+
+// 重装系统服务
+export const reinstallService = async () => {
+  return invoke<void>("reinstall_service");
+};
+
+// 修复系统服务
+export const repairService = async () => {
+  return invoke<void>("repair_service");
+};
+
 export const entry_lightweight_mode = async () => {
   return invoke<void>("entry_lightweight_mode");
-}
+};
 
 export const exit_lightweight_mode = async () => {
   return invoke<void>("exit_lightweight_mode");
-}
+};
+
+export const isAdmin = async () => {
+  try {
+    return await invoke<boolean>("is_admin");
+  } catch (error) {
+    console.error("检查管理员权限失败:", error);
+    return false;
+  }
+};

src/services/types.d.ts

@@ -738,6 +738,7 @@ interface IVergeConfig {
   sysproxy_tray_icon?: boolean;
   tun_tray_icon?: boolean;
   enable_tray_speed?: boolean;
+  enable_tray_icon?: boolean;
   enable_tun_mode?: boolean;
   enable_auto_light_weight_mode?: boolean;
   auto_light_weight_minutes?: number;

vite.config.mts

@@ -36,11 +36,96 @@ export default defineConfig({
           entry: "monaco-yaml/yaml.worker",
         },
       ],
+      globalAPI: false,
     }),
   ],
   build: {
     outDir: "../dist",
     emptyOutDir: true,
+    target: "es2020",
+    minify: "terser",
+    chunkSizeWarningLimit: 4000,
+    reportCompressedSize: false,
+    sourcemap: false,
+    cssCodeSplit: true,
+    cssMinify: true,
+    rollupOptions: {
+      treeshake: {
+        preset: "recommended",
+        moduleSideEffects: (id) => !/\.css$/.test(id),
+        tryCatchDeoptimization: false,
+      },
+      output: {
+        compact: true,
+        experimentalMinChunkSize: 30000,
+        dynamicImportInCjs: true,
+        manualChunks(id) {
+          if (id.includes("node_modules")) {
+            // Monaco Editor should be a separate chunk
+            if (id.includes("monaco-editor")) return "monaco-editor";
+
+            // React-related libraries (react, react-dom, react-router-dom, etc.)
+            if (
+              id.includes("react") ||
+              id.includes("react-dom") ||
+              id.includes("react-router-dom") ||
+              id.includes("react-transition-group") ||
+              id.includes("react-error-boundary") ||
+              id.includes("react-hook-form") ||
+              id.includes("react-markdown") ||
+              id.includes("react-virtuoso")
+            ) {
+              return "react";
+            }
+
+            // Utilities chunk: group commonly used utility libraries
+            if (
+              id.includes("axios") ||
+              id.includes("lodash-es") ||
+              id.includes("dayjs") ||
+              id.includes("js-base64") ||
+              id.includes("js-yaml") ||
+              id.includes("cli-color") ||
+              id.includes("nanoid")
+            ) {
+              return "utils";
+            }
+
+            // Tauri-related plugins: grouping together Tauri plugins
+            if (
+              id.includes("@tauri-apps/api") ||
+              id.includes("@tauri-apps/plugin-clipboard-manager") ||
+              id.includes("@tauri-apps/plugin-dialog") ||
+              id.includes("@tauri-apps/plugin-fs") ||
+              id.includes("@tauri-apps/plugin-global-shortcut") ||
+              id.includes("@tauri-apps/plugin-notification") ||
+              id.includes("@tauri-apps/plugin-process") ||
+              id.includes("@tauri-apps/plugin-shell") ||
+              id.includes("@tauri-apps/plugin-updater")
+            ) {
+              return "tauri-plugins";
+            }
+
+            // Material UI libraries (grouped together)
+            if (
+              id.includes("@mui/material") ||
+              id.includes("@mui/icons-material") ||
+              id.includes("@mui/lab") ||
+              id.includes("@mui/x-data-grid")
+            ) {
+              return "mui";
+            }
+
+            // Small vendor packages
+            const pkg = id.match(/node_modules\/([^\/]+)/)?.[1];
+            if (pkg && pkg.length < 8) return "small-vendors";
+
+            // Large vendor packages
+            return "large-vendor";
+          }
+        },
+      },
+    },
   },
   resolve: {
     alias: {