Release 2.2.2

This reverts commit aeaab10fcb.

.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
@@ -55,17 +57,6 @@ body:
       description: 请提供你的操作系统版本，Linux请额外提供桌面环境及窗口系统 / Please provide your OS version, for Linux, please also provide the desktop environment and window system
     validations:
       required: true
-  - type: checkboxes
-    id: os-labels
-    attributes:
-      label: 系统标签 / OS Labels
-      description: 请选择受影响的操作系统（至少选择一个） / Please select the affected operating system(s) (select at least one)
-      options:
-        - label: windows
-        - label: macos
-        - label: linux
-    validations:
-      required: true
   - type: textarea
     attributes:
       label: 日志 / Log

.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 commit changed
+      - name: Check if version changed
         id: check
         run: |
           # For manual workflow_dispatch, always run
@@ -34,21 +34,165 @@ jobs:
             exit 0
           fi
 
-          # Check if current commit is different from the previous one
-          CURRENT_COMMIT=$(git rev-parse HEAD)
-          PREVIOUS_COMMIT=$(git rev-parse HEAD~1)
+          # Store current version from package.json
+          CURRENT_VERSION=$(cat package.json | jq -r '.version')
+          echo "Current version: $CURRENT_VERSION"
 
-          if [ "$CURRENT_COMMIT" != "$PREVIOUS_COMMIT" ]; then
-            echo "New commit detected: $CURRENT_COMMIT"
+          # Get the previous commit's package.json version
+          git checkout HEAD~1 package.json
+          PREVIOUS_VERSION=$(cat package.json | jq -r '.version')
+          echo "Previous version: $PREVIOUS_VERSION"
+
+          # Reset back to current commit
+          git checkout HEAD package.json
+
+          # Check if version changed
+          if [ "$CURRENT_VERSION" != "$PREVIOUS_VERSION" ]; then
+            echo "Version changed from $PREVIOUS_VERSION to $CURRENT_VERSION"
             echo "should_run=true" >> $GITHUB_OUTPUT
           else
-            echo "No new commits since last run"
+            echo "Version unchanged: $CURRENT_VERSION"
             echo "should_run=false" >> $GITHUB_OUTPUT
           fi
 
-  alpha:
+  delete_old_assets:
     needs: check_commit
     if: ${{ needs.check_commit.outputs.should_run == 'true' }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Delete Old Alpha Release Assets
+        uses: actions/github-script@v7
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          script: |
+            const releaseTag = 'alpha';
+
+            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
+              });
+
+              console.log(`Found release with ID: ${release.id}`);
+
+              // Delete each asset
+              if (release.assets && release.assets.length > 0) {
+                console.log(`Deleting ${release.assets.length} assets`);
+
+                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
+                  });
+                }
+
+                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_assets
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Fetch Alpha update logs
+        id: fetch_alpha_logs
+        run: |
+          # 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 '/^## v/{if(flag) exit; flag=1} flag' UPDATELOG.md)
+
+            if [ -n "$ALPHA_LOGS" ]; then
+              echo "Found alpha update logs"
+              echo "ALPHA_LOGS<<EOF" >> $GITHUB_ENV
+              echo "$ALPHA_LOGS" >> $GITHUB_ENV
+              echo "EOF" >> $GITHUB_ENV
+            else
+              echo "No alpha sections found in UPDATELOG.md"
+            fi
+          else
+            echo "UPDATELOG.md file not found"
+          fi
+        shell: bash
+
+      - name: Set Env
+        run: |
+          echo "BUILDTIME=$(TZ=Asia/Shanghai date)" >> $GITHUB_ENV
+        shell: bash
+
+      - run: |
+          # 检查 ALPHA_LOGS 是否存在，如果不存在则使用默认消息
+          if [ -z "$ALPHA_LOGS" ]; then
+            echo "No alpha logs found, using default message"
+            ALPHA_LOGS="More new features are now supported. Check for detailed changelog soon."
+          else
+            echo "Using found alpha logs"
+          fi
+
+          # 生成 release.txt 文件
+          cat > release.txt << EOF
+          $ALPHA_LOGS
+
+          ## 我应该下载哪个版本？
+
+          ### MacOS
+          - MacOS intel芯片: x64.dmg
+          - MacOS apple M芯片: aarch64.dmg
+
+          ### Linux
+          - Linux 64位: amd64.deb/amd64.rpm
+          - Linux arm64 architecture: arm64.deb/aarch64.rpm
+          - Linux armv7架构: armhf.deb/armhfp.rpm
+
+          ### Windows (不再支持Win7)
+          #### 正常版本(推荐)
+          - 64位: x64-setup.exe
+          - arm64架构: arm64-setup.exe
+          #### 便携版问题很多不再提供
+          #### 内置Webview2版(体积较大，仅在企业版系统或无法安装webview2时使用)
+          - 64位: x64_fixed_webview2-setup.exe
+          - arm64架构: arm64_fixed_webview2-setup.exe
+
+          ### FAQ
+
+          - [常见问题](https://clash-verge-rev.github.io/faq/windows.html)
+
+          ### 稳定机场VPN推荐
+          - [狗狗加速](https://verge.dginv.click/#/register?code=oaxsAGo6)
+
+          Created at ${{ env.BUILDTIME }}.
+          EOF
+
+      - name: Upload Release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: alpha
+          name: "Clash Verge Rev Alpha"
+          body_path: release.txt
+          prerelease: true
+          token: ${{ secrets.GITHUB_TOKEN }}
+          generate_release_notes: true
+
+  alpha:
+    needs: update_tag
     strategy:
       fail-fast: false
       matrix:
@@ -86,7 +230,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
@@ -103,8 +247,8 @@ jobs:
           pnpm i
           pnpm check ${{ matrix.target }}
 
-      - name: Alpha Version update
-        run: pnpm run fix-alpha-version
+      - name: Release Alpha Version
+        run: pnpm release-alpha-version
 
       - name: Tauri build
         uses: tauri-apps/tauri-action@v0
@@ -129,8 +273,7 @@ jobs:
           args: --target ${{ matrix.target }}
 
   alpha-for-linux-arm:
-    needs: check_commit
-    if: ${{ needs.check_commit.outputs.should_run == 'true' }}
+    needs: update_tag
     strategy:
       fail-fast: false
       matrix:
@@ -173,6 +316,9 @@ jobs:
           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/
@@ -196,6 +342,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 }} \
@@ -244,7 +391,6 @@ jobs:
         with:
           tag_name: alpha
           name: "Clash Verge Rev Alpha"
-          body: "More new features are now supported."
           prerelease: true
           token: ${{ secrets.GITHUB_TOKEN }}
           files: |
@@ -252,8 +398,7 @@ jobs:
             src-tauri/target/${{ matrix.target }}/release/bundle/rpm/*.rpm
 
   alpha-for-fixed-webview2:
-    needs: check_commit
-    if: ${{ needs.check_commit.outputs.should_run == 'true' }}
+    needs: update_tag
     strategy:
       fail-fast: false
       matrix:
@@ -294,6 +439,9 @@ jobs:
           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
@@ -338,7 +486,6 @@ jobs:
         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*
@@ -347,66 +494,3 @@ jobs:
         run: pnpm portable-fixed-webview2 ${{ matrix.target }} --alpha
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-  update_tag:
-    name: Update tag
-    runs-on: ubuntu-latest
-    needs: [check_commit, alpha, alpha-for-linux-arm, alpha-for-fixed-webview2]
-    if: ${{ needs.check_commit.outputs.should_run == 'true' }}
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Set Env
-        run: |
-          echo "BUILDTIME=$(TZ=Asia/Shanghai date)" >> $GITHUB_ENV
-        shell: bash
-
-      # - name: Update Tag
-      #   uses: richardsimko/update-tag@v1
-      #   with:
-      #     tag_name: alpha
-      # env:
-      #   GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-      - run: |
-          cat > release.txt << 'EOF'
-          ## 我应该下载哪个版本？
-
-          ### MacOS
-          - MacOS intel芯片: x64.dmg
-          - MacOS apple M芯片: aarch64.dmg
-
-          ### Linux
-          - Linux 64位: amd64.deb/amd64.rpm
-          - Linux arm64 architecture: arm64.deb/aarch64.rpm
-          - Linux armv7架构: armhf.deb/armhfp.rpm
-
-          ### Windows (不再支持Win7)
-          #### 正常版本(推荐)
-          - 64位: x64-setup.exe
-          - arm64架构: arm64-setup.exe
-          #### 便携版问题很多不再提供
-          #### 内置Webview2版(体积较大，仅在企业版系统或无法安装webview2时使用)
-          - 64位: x64_fixed_webview2-setup.exe
-          - arm64架构: arm64_fixed_webview2-setup.exe
-
-          ### FAQ
-
-          - [常见问题](https://clash-verge-rev.github.io/faq/windows.html)
-
-          ### 稳定机场VPN推荐
-          - [狗狗加速](https://verge.dginv.click/#/register?code=oaxsAGo6)
-
-          Created at  ${{ env.BUILDTIME }}.
-          EOF
-
-      - name: Upload Release
-        uses: softprops/action-gh-release@v2
-        with:
-          tag_name: alpha
-          name: "Clash Verge Rev Alpha"
-          body_path: release.txt
-          prerelease: true
-          token: ${{ secrets.GITHUB_TOKEN }}
-          generate_release_notes: true

.github/workflows/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

@@ -1 +1,16 @@
-pnpm pretty-quick --staged
+#!/bin/bash
+
+#pnpm pretty-quick --staged
+
+# 运行 clippy fmt
+#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
+
+#git add .
+
+# 允许提交
+exit 0

.husky/pre-push

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

UPDATELOG.md

@@ -1,3 +1,129 @@
+## 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. **首页**
+   - 新增首页功能，默认启动页面改为首页。
+   - 首页流量图卡片显示上传/下载名称。
+   - 首页支持轻量模式切换。
+   - 流量统计数据持久保存。
+   - 限制首页配置文件卡片URL长度。
+
+2. **DNS 设置与覆写**
+   - 新增 DNS 覆写功能。
+   - 默认启用 DNS 覆写。
+
+3. **解锁测试**
+   - 新增解锁测试页面。
+
+4. **轻量模式**
+   - 新增轻量模式及设置。
+   - 添加自动轻量模式定时器。
+
+5. **系统支持**
+   - Mihomo(meta)内核升级 1.19.3
+   - macOS 支持 CMD+W 关闭窗口。
+   - 新增 macOS 应用菜单。
+   - 添加 macOS 安装服务时候的管理员权限提示。
+   - 新增 sidecar(用户空间启动内核) 模式。
+
+6. **其他**
+   - 增强延迟测试日志和错误处理。
+   - 添加诊断信息导出。
+   - 新增代理命令。
+
+#### 修复
+1. **系统**
+   - 修复 Windows 热键崩溃。
+   - 修复 macOS 无框标题。
+   - 修复 macOS 静默启动崩溃。
+   - 修复 macOS tray图标错位到左上角的问题。
+   - 修复 Windows/Linux 运行时崩溃。
+   - 修复 Win10 阴影和边框问题。
+   - 修复 升级或重装后开机自启状态检测和同步问题。
+
+2. **构建**
+   - 修复构建失败问题。
+
+#### 优化
+1. **性能**
+   - 重构后端，巨幅性能优化。
+   - 优化首页组件性能。
+   - 优化流量图表资源使用。
+   - 提升代理组列表滚动性能。
+   - 加快应用退出速度。
+   - 加快进入轻量模式速度。
+   - 优化小数值速度更新。
+   - 增加请求超时至 60 秒。
+   - 修复代理节点选择同步。
+   - 优化修改verge配置性能。
+
+2. **重构**
+   - 重构后端，巨幅性能优化。
+   - 优化定时器管理。
+   - 重构 MihomoManager 处理流量。
+   - 优化 WebSocket 连接。
+
+3. **其他**
+   - 更新依赖。
+   - 默认 TUN 堆栈改为 gvisor。
+
+---
+
 ## v2.1.2
 
 **发行代号：臻**

package.json

@@ -1,6 +1,6 @@
 {
   "name": "clash-verge",
-  "version": "2.1.3-alpha",
+  "version": "2.2.2",
   "license": "GPL-3.0-only",
   "scripts": {
     "dev": "cross-env RUST_BACKTRACE=1 tauri dev -f verge-dev -- --profile fast-dev",
@@ -16,7 +16,8 @@
     "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-alpha-version": "node scripts/release-alpha_version.mjs",
     "prepare": "husky",
     "clean": "cd ./src-tauri && cargo clean && cd -"
   },
@@ -27,46 +28,49 @@
     "@emotion/react": "^11.14.0",
     "@emotion/styled": "^11.14.0",
     "@juggle/resize-observer": "^3.4.0",
-    "@mui/icons-material": "^6.4.2",
+    "@mui/icons-material": "^6.4.8",
     "@mui/lab": "6.0.0-beta.25",
-    "@mui/material": "^6.4.2",
-    "@mui/x-data-grid": "^7.25.0",
+    "@mui/material": "^6.4.8",
+    "@mui/x-data-grid": "^7.28.0",
     "@tauri-apps/api": "2.2.0",
-    "@tauri-apps/plugin-clipboard-manager": "^2.2.1",
+    "@tauri-apps/plugin-clipboard-manager": "^2.2.2",
     "@tauri-apps/plugin-dialog": "^2.2.0",
     "@tauri-apps/plugin-fs": "^2.2.0",
     "@tauri-apps/plugin-global-shortcut": "^2.2.0",
-    "@tauri-apps/plugin-notification": "^2.2.1",
+    "@tauri-apps/plugin-notification": "^2.2.2",
     "@tauri-apps/plugin-process": "^2.2.0",
     "@tauri-apps/plugin-shell": "2.2.0",
     "@tauri-apps/plugin-updater": "2.3.0",
+    "@types/d3-shape": "^3.1.7",
     "@types/json-schema": "^7.0.15",
     "ahooks": "^3.8.4",
-    "axios": "^1.7.9",
+    "axios": "^1.8.3",
     "cli-color": "^2.0.4",
+    "d3-shape": "^3.2.0",
     "dayjs": "1.11.13",
-    "foxact": "^0.2.43",
+    "foxact": "^0.2.44",
     "glob": "^11.0.1",
-    "i18next": "^24.2.2",
+    "i18next": "^24.2.3",
     "js-base64": "^3.7.7",
     "js-yaml": "^4.1.0",
     "lodash-es": "^4.17.21",
     "monaco-editor": "^0.52.2",
-    "monaco-yaml": "^5.2.3",
-    "nanoid": "^5.0.9",
+    "monaco-yaml": "^5.3.1",
+    "nanoid": "^5.1.5",
     "peggy": "^4.2.0",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
-    "react-error-boundary": "^4.0.12",
+    "react-error-boundary": "^4.1.2",
     "react-hook-form": "^7.54.2",
     "react-i18next": "^13.5.0",
-    "react-markdown": "^9.0.1",
-    "react-monaco-editor": "^0.56.0",
-    "react-router-dom": "^6.22.3",
+    "react-markdown": "^9.1.0",
+    "react-monaco-editor": "^0.56.2",
+    "react-router-dom": "^6.30.0",
     "react-transition-group": "^4.4.5",
-    "react-virtuoso": "^4.6.3",
+    "react-virtuoso": "^4.12.5",
+    "recharts": "^2.15.1",
     "sockette": "^2.0.6",
-    "swr": "^2.3.0",
+    "swr": "^2.3.3",
     "tar": "^7.4.3",
     "types-pac": "^1.0.3",
     "zustand": "^5.0.3"
@@ -80,20 +84,20 @@
     "@types/react": "^18.3.18",
     "@types/react-dom": "^18.3.5",
     "@types/react-transition-group": "^4.4.12",
-    "@vitejs/plugin-legacy": "^6.0.0",
-    "@vitejs/plugin-react": "^4.2.1",
+    "@vitejs/plugin-legacy": "^6.0.2",
+    "@vitejs/plugin-react": "^4.3.4",
     "adm-zip": "^0.5.16",
     "cross-env": "^7.0.3",
     "https-proxy-agent": "^7.0.6",
     "husky": "^9.1.7",
-    "meta-json-schema": "^1.19.1",
+    "meta-json-schema": "^1.19.3",
     "node-fetch": "^3.3.2",
-    "prettier": "^3.4.2",
-    "pretty-quick": "^4.0.0",
-    "sass": "^1.83.4",
-    "terser": "^5.37.0",
-    "typescript": "^5.7.3",
-    "vite": "^6.0.11",
+    "prettier": "^3.5.3",
+    "pretty-quick": "^4.1.1",
+    "sass": "^1.86.0",
+    "terser": "^5.39.0",
+    "typescript": "^5.8.2",
+    "vite": "^6.2.2",
     "vite-plugin-monaco-editor": "^1.1.0",
     "vite-plugin-svgr": "^4.3.0"
   },

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/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,10 +1,15 @@
 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";
 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.json";
+const ALPHA_UPDATE_JSON_PROXY = "update-proxy.json";
 
 /// generate update.json
 /// upload to update tag's release asset
@@ -16,182 +21,293 @@ async function resolveUpdater() {
   const options = { owner: context.repo.owner, repo: context.repo.repo };
   const github = getOctokit(process.env.GITHUB_TOKEN);
 
-  const { data: tags } = await github.rest.repos.listTags({
-    ...options,
-    per_page: 10,
-    page: 1,
-  });
+  // Fetch all tags using pagination
+  let allTags = [];
+  let page = 1;
+  const perPage = 100;
 
-  // get the latest publish tag
-  const tag = tags.find((t) => t.name.startsWith("v"));
+  while (true) {
+    const { data: pageTags } = await github.rest.repos.listTags({
+      ...options,
+      per_page: perPage,
+      page: page,
+    });
 
-  console.log(tag);
-  console.log();
+    allTags = allTags.concat(pageTags);
 
-  const { data: latestRelease } = await github.rest.repos.getReleaseByTag({
-    ...options,
-    tag: tag.name,
-  });
-
-  const updateData = {
-    name: tag.name,
-    notes: await resolveUpdateLog(tag.name), // use updatelog.md
-    pub_date: new Date().toISOString(),
-    platforms: {
-      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 = latestRelease.assets.map(async (asset) => {
-    const { name, browser_download_url } = asset;
-
-    // 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;
+    // Break if we received fewer tags than requested (last page)
+    if (pageTags.length < perPage) {
+      break;
     }
 
-    // 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];
-    }
-  });
-
-  // 生成一个代理github的更新文件
-  // 使用 https://hub.fastgit.xyz/ 做github资源的加速
-  const updateDataNew = JSON.parse(JSON.stringify(updateData));
-
-  Object.entries(updateDataNew.platforms).forEach(([key, value]) => {
-    if (value.url) {
-      updateDataNew.platforms[key].url =
-        "https://download.clashverge.dev/" + value.url;
-    } else {
-      console.log(`[Error]: updateDataNew.platforms.${key} is null`);
-    }
-  });
-
-  // update the update.json
-  const { data: updateRelease } = await github.rest.repos.getReleaseByTag({
-    ...options,
-    tag: UPDATE_TAG_NAME,
-  });
-
-  // delete the old assets
-  for (let asset of updateRelease.assets) {
-    if (asset.name === UPDATE_JSON_FILE) {
-      await github.rest.repos.deleteReleaseAsset({
-        ...options,
-        asset_id: asset.id,
-      });
-    }
-
-    if (asset.name === UPDATE_JSON_PROXY) {
-      await github.rest.repos
-        .deleteReleaseAsset({ ...options, asset_id: asset.id })
-        .catch(console.error); // do not break the pipeline
-    }
+    page++;
   }
 
-  // upload new assets
-  await github.rest.repos.uploadReleaseAsset({
-    ...options,
-    release_id: updateRelease.id,
-    name: UPDATE_JSON_FILE,
-    data: JSON.stringify(updateData, null, 2),
-  });
+  const tags = allTags;
+  console.log(`Retrieved ${tags.length} tags in total`);
 
-  await github.rest.repos.uploadReleaseAsset({
-    ...options,
-    release_id: updateRelease.id,
-    name: UPDATE_JSON_PROXY,
-    data: JSON.stringify(updateDataNew, null, 2),
-  });
+  // More flexible tag detection with regex patterns
+  const stableTagRegex = /^v\d+\.\d+\.\d+$/; // Matches vX.Y.Z format
+  // const preReleaseRegex = /^v\d+\.\d+\.\d+-(alpha|beta|rc|pre)/i; // Matches vX.Y.Z-alpha/beta/rc format
+  const preReleaseRegex = /^(alpha|beta|rc|pre)$/i; // Matches exact alpha/beta/rc/pre tags
+
+  // Get the latest stable tag and pre-release tag
+  const stableTag = tags.find((t) => stableTagRegex.test(t.name));
+  const preReleaseTag = tags.find((t) => preReleaseRegex.test(t.name));
+
+  console.log("All tags:", tags.map((t) => t.name).join(", "));
+  console.log("Stable tag:", stableTag ? stableTag.name : "None found");
+  console.log(
+    "Pre-release tag:",
+    preReleaseTag ? preReleaseTag.name : "None found",
+  );
+  console.log();
+
+  // Process stable release
+  if (stableTag) {
+    await processRelease(github, options, stableTag, false);
+  }
+
+  // Process pre-release if found
+  if (preReleaseTag) {
+    await processRelease(github, options, preReleaseTag, true);
+  }
+}
+
+// Process a release (stable or alpha) and generate update files
+async function processRelease(github, options, tag, isAlpha) {
+  if (!tag) return;
+
+  try {
+    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 {
+      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,
+        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,
+      );
+    }
+  } catch (error) {
+    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,
+      );
+    }
+  }
 }
 
 // get the signature file content

src-tauri/.clippy.toml

@@ -0,0 +1 @@
+avoid-breaking-exported-api = true

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "clash-verge"
-version = "2.1.2"
+version = "2.2.2"
 description = "clash verge"
 authors = ["zzzgydi", "wonfen", "MystiPanda"]
 license = "GPL-3.0-only"
@@ -34,10 +34,12 @@ port_scanner = "0.1.5"
 delay_timer = "0.11.6"
 parking_lot = "0.12"
 percent-encoding = "2.3.1"
+fs2 = "0.4.3"
 window-shadows = { version = "0.2.2" }
 tokio = { version = "1.43", features = ["full"] }
 serde = { version = "1.0", features = ["derive"] }
-reqwest = { version = "0.12", features = ["json", "rustls-tls"] }
+reqwest = { version = "0.12", features = ["json", "rustls-tls", "cookies"] }
+regex = "1.10.5"
 sysproxy = { git = "https://github.com/clash-verge-rev/sysproxy-rs", rev = "3d748b5" }
 image = "0.25.5"
 imageproc = "0.25.0"
@@ -68,10 +70,11 @@ tokio-tungstenite = "0.26.2"
 futures = "0.3"
 sys-locale = "0.3.1"
 async-trait = "0.1.87"
-mihomo_api = { path = "./src/crate_mihomo_api" }
+mihomo_api = { path = "src_crates/crate_mihomo_api" }
 ab_glyph = "0.2.29"
 tungstenite = "0.26.2"
 
+
 [target.'cfg(windows)'.dependencies]
 runas = "=1.2.0"
 deelevate = "0.2.0"
@@ -131,5 +134,4 @@ tempfile = "3.17.1"
 
 [workspace]
 members = [
-    "src/crate_mihomo_api"
-]
+    "src_crates/crate_mihomo_api",]

src-tauri/src/cmd/app.rs

@@ -70,45 +70,53 @@ pub fn get_app_dir() -> CmdResult<String> {
     Ok(app_home_dir)
 }
 
+/// 获取当前自启动状态
+#[tauri::command]
+pub fn get_auto_launch_status() -> CmdResult<bool> {
+    use crate::core::sysopt::Sysopt;
+    wrap_err!(Sysopt::global().get_launch_status())
+}
+
 /// 下载图标缓存
 #[tauri::command]
 pub async fn download_icon_cache(url: String, name: String) -> CmdResult<String> {
     let icon_cache_dir = wrap_err!(dirs::app_home_dir())?.join("icons").join("cache");
     let icon_path = icon_cache_dir.join(&name);
-    
+
     // 如果文件已存在，直接返回路径
     if icon_path.exists() {
         return Ok(icon_path.to_string_lossy().to_string());
     }
-    
+
     // 确保缓存目录存在
     if !icon_cache_dir.exists() {
         let _ = std::fs::create_dir_all(&icon_cache_dir);
     }
-    
+
     // 使用临时文件名来下载
     let temp_path = icon_cache_dir.join(format!("{}.downloading", &name));
-    
+
     // 下载文件到临时位置
     let response = wrap_err!(reqwest::get(&url).await)?;
-    
+
     // 检查内容类型是否为图片
-    let content_type = response.headers()
+    let content_type = response
+        .headers()
         .get(reqwest::header::CONTENT_TYPE)
         .and_then(|v| v.to_str().ok())
         .unwrap_or("");
-    
+
     let is_image = content_type.starts_with("image/");
-    
+
     // 获取响应内容
     let content = wrap_err!(response.bytes().await)?;
-    
+
     // 检查内容是否为HTML (针对CDN错误页面)
-    let is_html = content.len() > 15 && 
-        (content.starts_with(b"<!DOCTYPE html") || 
-         content.starts_with(b"<html") || 
-         content.starts_with(b"<?xml"));
-    
+    let is_html = content.len() > 15
+        && (content.starts_with(b"<!DOCTYPE html")
+            || content.starts_with(b"<html")
+            || content.starts_with(b"<?xml"));
+
     // 只有当内容确实是图片时才保存
     if is_image && !is_html {
         {
@@ -122,14 +130,14 @@ pub async fn download_icon_cache(url: String, name: String) -> CmdResult<String>
                     }
                 }
             };
-            
+
             wrap_err!(std::io::copy(&mut content.as_ref(), &mut file))?;
         }
-        
+
         // 再次检查目标文件是否已存在，避免重命名覆盖其他线程已完成的文件
         if !icon_path.exists() {
             match std::fs::rename(&temp_path, &icon_path) {
-                Ok(_) => {},
+                Ok(_) => {}
                 Err(_) => {
                     let _ = std::fs::remove_file(&temp_path);
                     if icon_path.exists() {
@@ -140,11 +148,11 @@ pub async fn download_icon_cache(url: String, name: String) -> CmdResult<String>
         } else {
             let _ = std::fs::remove_file(&temp_path);
         }
-        
+
         Ok(icon_path.to_string_lossy().to_string())
     } else {
         let _ = std::fs::remove_file(&temp_path);
-        Err(format!("下载的内容不是有效图片: {}", url).into())
+        Err(format!("下载的内容不是有效图片: {}", url))
     }
 }
 
@@ -158,8 +166,7 @@ pub struct IconInfo {
 /// 复制图标文件
 #[tauri::command]
 pub fn copy_icon_file(path: String, icon_info: IconInfo) -> CmdResult<String> {
-    use std::fs;
-    use std::path::Path;
+    use std::{fs, path::Path};
 
     let file_path = Path::new(&path);
 

src-tauri/src/cmd/clash.rs

@@ -24,7 +24,8 @@ pub async fn patch_clash_config(payload: Mapping) -> CmdResult {
 /// 修改Clash模式
 #[tauri::command]
 pub async fn patch_clash_mode(payload: String) -> CmdResult {
-    Ok(feat::change_clash_mode(payload))
+    feat::change_clash_mode(payload);
+    Ok(())
 }
 
 /// 切换Clash核心
@@ -98,9 +99,11 @@ pub async fn save_dns_config(dns_config: Mapping) -> CmdResult {
 /// 应用或撤销DNS配置
 #[tauri::command]
 pub fn apply_dns_config(apply: bool) -> CmdResult {
-    use crate::config::Config;
-    use crate::core::{handle, CoreManager};
-    use crate::utils::dirs;
+    use crate::{
+        config::Config,
+        core::{handle, CoreManager},
+        utils::dirs,
+    };
     use tauri::async_runtime;
 
     // 使用spawn来处理异步操作

src-tauri/src/cmd/core.rs

@@ -0,0 +1,8 @@
+use super::CmdResult;
+use crate::{core::CoreManager, wrap_err};
+
+/// 修复系统服务
+#[tauri::command]
+pub async fn repair_service() -> CmdResult {
+    wrap_err!(CoreManager::global().repair_service().await)
+} 

src-tauri/src/cmd/lighteweight.rs

@@ -0,0 +1,9 @@
+use crate::module::lightweight;
+
+use super::CmdResult;
+
+#[tauri::command]
+pub async fn entry_lightweight_mode() -> CmdResult {
+    lightweight::entry_lightweight_mode();
+    Ok(())
+}

src-tauri/src/cmd/mod.rs

@@ -4,29 +4,35 @@ use anyhow::Result;
 pub type CmdResult<T = ()> = Result<T, String>;
 
 // Command modules
-pub mod profile;
-pub mod validate;
-pub mod uwp;
-pub mod webdav;
 pub mod app;
-pub mod network;
 pub mod clash;
-pub mod verge;
+pub mod core;
+pub mod media_unlock_checker;
+pub mod network;
+pub mod profile;
+pub mod proxy;
 pub mod runtime;
 pub mod save_profile;
 pub mod system;
-pub mod proxy;
+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 profile::*;
-pub use validate::*;
-pub use uwp::*;
-pub use webdav::*;
 pub use app::*;
-pub use network::*;
 pub use clash::*;
-pub use verge::*;
+pub use core::*;
+pub use media_unlock_checker::*;
+pub use network::*;
+pub use profile::*;
+pub use proxy::*;
 pub use runtime::*;
 pub use save_profile::*;
 pub use system::*;
-pub use proxy::*;
+pub use uwp::*;
+pub use validate::*;
+pub use verge::*;
+pub use webdav::*;
+pub use lighteweight::*;

src-tauri/src/cmd/network.rs

@@ -1,8 +1,8 @@
-use crate::wrap_err;
 use super::CmdResult;
-use sysproxy::{Autoproxy, Sysproxy};
-use serde_yaml::Mapping;
+use crate::wrap_err;
 use network_interface::NetworkInterface;
+use serde_yaml::Mapping;
+use sysproxy::{Autoproxy, Sysproxy};
 
 /// get the system proxy
 #[tauri::command]
@@ -46,8 +46,7 @@ pub fn get_network_interfaces() -> Vec<String> {
 /// 获取网络接口详细信息
 #[tauri::command]
 pub fn get_network_interfaces_info() -> CmdResult<Vec<NetworkInterface>> {
-    use network_interface::NetworkInterface;
-    use network_interface::NetworkInterfaceConfig;
+    use network_interface::{NetworkInterface, NetworkInterfaceConfig};
 
     let names = get_network_interfaces();
     let interfaces = wrap_err!(NetworkInterface::show())?;

src-tauri/src/cmd/profile.rs

@@ -1,11 +1,11 @@
+use super::CmdResult;
 use crate::{
     config::*,
     core::*,
-    feat,
+    feat, log_err, ret_err,
     utils::{dirs, help},
-    log_err, ret_err, wrap_err,
+    wrap_err,
 };
-use super::CmdResult;
 
 /// 获取配置文件列表
 #[tauri::command]
@@ -31,7 +31,7 @@ pub async fn enhance_profiles() -> CmdResult {
         }
         Err(e) => {
             println!("[enhance_profiles] 更新过程发生错误: {}", e);
-            handle::Handle::notice_message("config_validate::process_terminated", &e.to_string());
+            handle::Handle::notice_message("config_validate::process_terminated", e.to_string());
             Ok(())
         }
     }
@@ -76,19 +76,17 @@ pub async fn delete_profile(index: String) -> CmdResult {
 
 /// 修改profiles的配置
 #[tauri::command]
-pub async fn patch_profiles_config(
-    profiles: IProfiles
-) -> CmdResult<bool> {
+pub async fn patch_profiles_config(profiles: IProfiles) -> CmdResult<bool> {
     println!("[cmd配置patch] 开始修改配置文件");
-    
+
     // 保存当前配置，以便在验证失败时恢复
     let current_profile = Config::profiles().latest().current.clone();
     println!("[cmd配置patch] 当前配置: {:?}", current_profile);
-    
+
     // 更新profiles配置
     println!("[cmd配置patch] 正在更新配置草稿");
     wrap_err!({ Config::profiles().draft().patch_config(profiles) })?;
-    
+
     // 更新配置并进行验证
     match CoreManager::global().update_config().await {
         Ok((true, _)) => {
@@ -102,7 +100,7 @@ pub async fn patch_profiles_config(
         Ok((false, error_msg)) => {
             println!("[cmd配置patch] 配置验证失败: {}", error_msg);
             Config::profiles().discard();
-            
+
             // 如果验证失败，恢复到之前的配置
             if let Some(prev_profile) = current_profile {
                 println!("[cmd配置patch] 尝试恢复到之前的配置: {}", prev_profile);
@@ -124,7 +122,7 @@ pub async fn patch_profiles_config(
         Err(e) => {
             println!("[cmd配置patch] 更新过程发生错误: {}", e);
             Config::profiles().discard();
-            handle::Handle::notice_message("config_validate::boot_error", &e.to_string());
+            handle::Handle::notice_message("config_validate::boot_error", e.to_string());
             Ok(false)
         }
     }
@@ -134,9 +132,12 @@ pub async fn patch_profiles_config(
 #[tauri::command]
 pub async fn patch_profiles_config_by_profile_index(
     _app_handle: tauri::AppHandle,
-    profile_index: String
+    profile_index: String,
 ) -> CmdResult<bool> {
-    let profiles = IProfiles{current: Some(profile_index), items: None};
+    let profiles = IProfiles {
+        current: Some(profile_index),
+        items: None,
+    };
     patch_profiles_config(profiles).await
 }
 

src-tauri/src/cmd/proxy.rs

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

src-tauri/src/cmd/runtime.rs

@@ -1,11 +1,8 @@
-use crate::{
-    config::*,
-    wrap_err,
-};
 use super::CmdResult;
+use crate::{config::*, wrap_err};
 use anyhow::Context;
-use std::collections::HashMap;
 use serde_yaml::Mapping;
+use std::collections::HashMap;
 
 /// 获取运行时配置
 #[tauri::command]

src-tauri/src/cmd/save_profile.rs

@@ -1,10 +1,5 @@
-use crate::{
-    config::*,
-    core::*,
-    utils::dirs,
-    wrap_err,
-};
 use super::CmdResult;
+use crate::{config::*, core::*, utils::dirs, wrap_err};
 use std::fs;
 
 /// 保存profiles的配置
@@ -20,7 +15,7 @@ pub async fn save_profile_file(index: String, file_data: Option<String>) -> CmdR
         let profiles_guard = profiles.latest();
         let item = wrap_err!(profiles_guard.get_item(&index))?;
         // 确定是否为merge类型文件
-        let is_merge = item.itype.as_ref().map_or(false, |t| t == "merge");
+        let is_merge = item.itype.as_ref().is_some_and(|t| t == "merge");
         let content = wrap_err!(item.read_file())?;
         let path = item.file.clone().ok_or("file field is null")?;
         let profiles_dir = wrap_err!(dirs::app_profiles_dir())?;
@@ -29,14 +24,20 @@ pub async fn save_profile_file(index: String, file_data: Option<String>) -> CmdR
 
     // 保存新的配置文件
     wrap_err!(fs::write(&file_path, file_data.clone().unwrap()))?;
-    
+
     let file_path_str = file_path.to_string_lossy().to_string();
-    println!("[cmd配置save] 开始验证配置文件: {}, 是否为merge文件: {}", file_path_str, is_merge_file);
-    
+    println!(
+        "[cmd配置save] 开始验证配置文件: {}, 是否为merge文件: {}",
+        file_path_str, is_merge_file
+    );
+
     // 对于 merge 文件，只进行语法验证，不进行后续内核验证
     if is_merge_file {
         println!("[cmd配置save] 检测到merge文件，只进行语法验证");
-        match CoreManager::global().validate_config_file(&file_path_str, Some(true)).await {
+        match CoreManager::global()
+            .validate_config_file(&file_path_str, Some(true))
+            .await
+        {
             Ok((true, _)) => {
                 println!("[cmd配置save] merge文件语法验证通过");
                 // 成功后尝试更新整体配置
@@ -63,9 +64,12 @@ pub async fn save_profile_file(index: String, file_data: Option<String>) -> CmdR
             }
         }
     }
-    
+
     // 非merge文件使用完整验证流程
-    match CoreManager::global().validate_config_file(&file_path_str, None).await {
+    match CoreManager::global()
+        .validate_config_file(&file_path_str, None)
+        .await
+    {
         Ok((true, _)) => {
             println!("[cmd配置save] 验证成功");
             Ok(())
@@ -74,16 +78,17 @@ pub async fn save_profile_file(index: String, file_data: Option<String>) -> CmdR
             println!("[cmd配置save] 验证失败: {}", error_msg);
             // 恢复原始配置文件
             wrap_err!(fs::write(&file_path, original_content))?;
-            
+
             // 智能判断错误类型
-            let is_script_error = file_path_str.ends_with(".js") || 
-                               error_msg.contains("Script syntax error") || 
-                               error_msg.contains("Script must contain a main function") ||
-                               error_msg.contains("Failed to read script file");
-            
-            if error_msg.contains("YAML syntax error") || 
-               error_msg.contains("Failed to read file:") ||
-               (!file_path_str.ends_with(".js") && !is_script_error) {
+            let is_script_error = file_path_str.ends_with(".js")
+                || error_msg.contains("Script syntax error")
+                || error_msg.contains("Script must contain a main function")
+                || error_msg.contains("Failed to read script file");
+
+            if error_msg.contains("YAML syntax error")
+                || error_msg.contains("Failed to read file:")
+                || (!file_path_str.ends_with(".js") && !is_script_error)
+            {
                 // 普通YAML错误使用YAML通知处理
                 println!("[cmd配置save] YAML配置文件验证失败，发送通知");
                 let result = (false, error_msg.clone());
@@ -98,7 +103,7 @@ pub async fn save_profile_file(index: String, file_data: Option<String>) -> CmdR
                 println!("[cmd配置save] 其他类型验证失败，发送一般通知");
                 handle::Handle::notice_message("config_validate::error", &error_msg);
             }
-            
+
             Ok(())
         }
         Err(e) => {

src-tauri/src/cmd/system.rs

@@ -1,8 +1,26 @@
 use super::CmdResult;
-use crate::core::handle;
-use crate::module::sysinfo::PlatformSpecification;
+use crate::{
+    core::{self, handle, service, CoreManager},
+    module::sysinfo::PlatformSpecification,
+    wrap_err,
+};
+use once_cell::sync::Lazy;
+use std::{
+    sync::atomic::{AtomicI64, Ordering},
+    time::{SystemTime, UNIX_EPOCH},
+};
 use tauri_plugin_clipboard_manager::ClipboardExt;
-use crate::{core::{self, CoreManager, service}, wrap_err};
+
+// 存储应用启动时间的全局变量
+static APP_START_TIME: Lazy<AtomicI64> = Lazy::new(|| {
+    // 获取当前系统时间，转换为毫秒级时间戳
+    let now = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_millis() as i64;
+
+    AtomicI64::new(now)
+});
 
 #[tauri::command]
 pub async fn export_diagnostic_info() -> CmdResult<()> {
@@ -11,13 +29,19 @@ pub async fn export_diagnostic_info() -> CmdResult<()> {
 
     let app_handle = handle::Handle::global().app_handle().unwrap();
     let cliboard = app_handle.clipboard();
-    
-    if let Err(_) = cliboard.write_text(info) {
+    if cliboard.write_text(info).is_err() {
         log::error!(target: "app", "Failed to write to clipboard");
     }
     Ok(())
 }
 
+#[tauri::command]
+pub async fn get_system_info() -> CmdResult<String> {
+    let sysinfo = PlatformSpecification::new();
+    let info = format!("{:?}", sysinfo);
+    Ok(info)
+}
+
 /// 获取当前内核运行模式
 #[tauri::command]
 pub async fn get_running_mode() -> Result<String, String> {
@@ -33,3 +57,15 @@ pub async fn get_running_mode() -> Result<String, String> {
 pub async fn install_service() -> CmdResult {
     wrap_err!(service::reinstall_service().await)
 }
+
+/// 获取应用的运行时间（毫秒）
+#[tauri::command]
+pub fn get_app_uptime() -> CmdResult<i64> {
+    let start_time = APP_START_TIME.load(Ordering::Relaxed);
+    let now = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_millis() as i64;
+
+    Ok(now - start_time)
+}

src-tauri/src/cmd/uwp.rs

@@ -4,8 +4,7 @@ use super::CmdResult;
 #[cfg(windows)]
 mod platform {
     use super::CmdResult;
-    use crate::core::win_uwp;
-    use crate::wrap_err;
+    use crate::{core::win_uwp, wrap_err};
 
     pub async fn invoke_uwp_tool() -> CmdResult {
         wrap_err!(win_uwp::invoke_uwptools().await)

src-tauri/src/cmd/validate.rs

@@ -1,5 +1,5 @@
-use crate::core::*;
 use super::CmdResult;
+use crate::core::*;
 
 /// 发送脚本验证通知消息
 #[tauri::command]
@@ -13,7 +13,7 @@ pub async fn script_validate_notice(status: String, msg: String) -> CmdResult {
 pub fn handle_script_validation_notice(result: &(bool, String), file_type: &str) {
     if !result.0 {
         let error_msg = &result.1;
-        
+
         // 根据错误消息内容判断错误类型
         let status = if error_msg.starts_with("File not found:") {
             "config_validate::file_not_found"
@@ -27,7 +27,7 @@ pub fn handle_script_validation_notice(result: &(bool, String), file_type: &str)
             // 如果是其他类型错误，作为一般脚本错误处理
             "config_validate::script_error"
         };
-        
+
         log::warn!(target: "app", "{} 验证失败: {}", file_type, error_msg);
         handle::Handle::notice_message(status, error_msg);
     }
@@ -37,12 +37,15 @@ pub fn handle_script_validation_notice(result: &(bool, String), file_type: &str)
 #[tauri::command]
 pub async fn validate_script_file(file_path: String) -> CmdResult<bool> {
     log::info!(target: "app", "验证脚本文件: {}", file_path);
-    
-    match CoreManager::global().validate_config_file(&file_path, None).await {
+
+    match CoreManager::global()
+        .validate_config_file(&file_path, None)
+        .await
+    {
         Ok(result) => {
             handle_script_validation_notice(&result, "脚本文件");
-            Ok(result.0)  // 返回验证结果布尔值
-        },
+            Ok(result.0) // 返回验证结果布尔值
+        }
         Err(e) => {
             let error_msg = e.to_string();
             log::error!(target: "app", "验证脚本文件过程发生错误: {}", error_msg);
@@ -58,10 +61,10 @@ pub fn handle_yaml_validation_notice(result: &(bool, String), file_type: &str) {
     if !result.0 {
         let error_msg = &result.1;
         println!("[通知] 处理{}验证错误: {}", file_type, error_msg);
-        
+
         // 检查是否为merge文件
         let is_merge_file = file_type.contains("合并");
-        
+
         // 根据错误消息内容判断错误类型
         let status = if error_msg.starts_with("File not found:") {
             "config_validate::file_not_found"
@@ -93,7 +96,7 @@ pub fn handle_yaml_validation_notice(result: &(bool, String), file_type: &str) {
                 "config_validate::yaml_error"
             }
         };
-        
+
         log::warn!(target: "app", "{} 验证失败: {}", file_type, error_msg);
         println!("[通知] 发送通知: status={}, msg={}", status, error_msg);
         handle::Handle::notice_message(status, error_msg);

src-tauri/src/cmd/verge.rs

@@ -1,9 +1,5 @@
-use crate::{
-    config::*,
-    feat,
-    wrap_err,
-};
 use super::CmdResult;
+use crate::{config::*, feat, wrap_err};
 
 /// 获取Verge配置
 #[tauri::command]

src-tauri/src/cmd/webdav.rs

@@ -1,10 +1,5 @@
-use crate::{
-    core,
-    config::*,
-    feat,
-    wrap_err,
-};
 use super::CmdResult;
+use crate::{config::*, core, feat, wrap_err};
 use reqwest_dav::list_cmd::ListFile;
 
 /// 保存 WebDAV 配置

src-tauri/src/config/clash.rs

@@ -33,7 +33,7 @@ impl IClashTemp {
         let mut map = Mapping::new();
         let mut tun = Mapping::new();
         tun.insert("enable".into(), false.into());
-        tun.insert("stack".into(), "mixed".into());
+        tun.insert("stack".into(), "gvisor".into());
         tun.insert("auto-route".into(), true.into());
         tun.insert("strict-route".into(), false.into());
         tun.insert("auto-detect-interface".into(), true.into());

src-tauri/src/config/config.rs

@@ -1,9 +1,9 @@
 use super::{Draft, IClashTemp, IProfiles, IRuntime, IVerge};
 use crate::{
     config::PrfItem,
+    core::{handle, CoreManager},
     enhance,
     utils::{dirs, help},
-    core::{handle, CoreManager},
 };
 use anyhow::{anyhow, Result};
 use once_cell::sync::OnceCell;
@@ -73,14 +73,17 @@ impl Config {
         // 生成运行时配置文件并验证
         let config_result = Self::generate_file(ConfigType::Run);
 
-        let validation_result = if let Ok(_) = config_result {
+        let validation_result = if config_result.is_ok() {
             // 验证配置文件
             println!("[首次启动] 开始验证配置");
-            
+
             match CoreManager::global().validate_config().await {
                 Ok((is_valid, error_msg)) => {
                     if !is_valid {
-                        println!("[首次启动] 配置验证失败，使用默认最小配置启动: {}", error_msg);
+                        println!(
+                            "[首次启动] 配置验证失败，使用默认最小配置启动: {}",
+                            error_msg
+                        );
                         CoreManager::global()
                             .use_default_config("config_validate::boot_error", &error_msg)
                             .await?;
@@ -101,10 +104,7 @@ impl Config {
         } else {
             println!("[首次启动] 生成配置文件失败，使用默认配置");
             CoreManager::global()
-                .use_default_config(
-                    "config_validate::error",
-                    "",
-                )
+                .use_default_config("config_validate::error", "")
                 .await?;
             Some(("config_validate::error", String::new()))
         };

src-tauri/src/config/mod.rs

@@ -8,14 +8,9 @@ mod profiles;
 mod runtime;
 mod verge;
 
-pub use self::clash::*;
-pub use self::config::*;
-pub use self::draft::*;
-pub use self::encrypt::*;
-pub use self::prfitem::*;
-pub use self::profiles::*;
-pub use self::runtime::*;
-pub use self::verge::*;
+pub use self::{
+    clash::*, config::*, draft::*, encrypt::*, prfitem::*, profiles::*, runtime::*, verge::*,
+};
 
 pub const DEFAULT_PAC: &str = r#"function FindProxyForURL(url, host) {
   return "PROXY 127.0.0.1:%mixed-port%; SOCKS5 127.0.0.1:%mixed-port%; DIRECT;";

src-tauri/src/config/prfitem.rs

@@ -234,10 +234,10 @@ impl PrfItem {
         option: Option<PrfOption>,
     ) -> Result<PrfItem> {
         let opt_ref = option.as_ref();
-        let with_proxy = opt_ref.map_or(false, |o| o.with_proxy.unwrap_or(false));
-        let self_proxy = opt_ref.map_or(false, |o| o.self_proxy.unwrap_or(false));
+        let with_proxy = opt_ref.is_some_and(|o| o.with_proxy.unwrap_or(false));
+        let self_proxy = opt_ref.is_some_and(|o| o.self_proxy.unwrap_or(false));
         let accept_invalid_certs =
-            opt_ref.map_or(false, |o| o.danger_accept_invalid_certs.unwrap_or(false));
+            opt_ref.is_some_and(|o| o.danger_accept_invalid_certs.unwrap_or(false));
         let user_agent = opt_ref.and_then(|o| o.user_agent.clone());
         let update_interval = opt_ref.and_then(|o| o.update_interval);
         let mut merge = opt_ref.and_then(|o| o.merge.clone());

src-tauri/src/config/profiles.rs

@@ -472,15 +472,17 @@ impl IProfiles {
 
     /// 获取所有的profiles(uid，名称)
     pub fn all_profile_uid_and_name(&self) -> Option<Vec<(String, String)>> {
-        match self.items.as_ref() {
-            Some(items) => Some(items.iter().filter_map(|e| {
-                if let (Some(uid), Some(name)) = (e.uid.clone(), e.name.clone()) {
-                    Some((uid, name))
-                } else {
-                    None
-                }
-            }).collect()),
-            None => None,
-        }
+        self.items.as_ref().map(|items| {
+            items
+                .iter()
+                .filter_map(|e| {
+                    if let (Some(uid), Some(name)) = (e.uid.clone(), e.name.clone()) {
+                        Some((uid, name))
+                    } else {
+                        None
+                    }
+                })
+                .collect()
+        })
     }
 }

src-tauri/src/config/verge.rs

@@ -1,7 +1,7 @@
-use crate::config::DEFAULT_PAC;
-use crate::config::{deserialize_encrypted, serialize_encrypted};
-use crate::utils::i18n;
-use crate::utils::{dirs, help};
+use crate::{
+    config::{deserialize_encrypted, serialize_encrypted, DEFAULT_PAC},
+    utils::{dirs, help, i18n},
+};
 use anyhow::Result;
 use log::LevelFilter;
 use serde::{Deserialize, Serialize};
@@ -101,10 +101,14 @@ pub struct IVerge {
     /// hotkey map
     /// format: {func},{key}
     pub hotkeys: Option<Vec<String>>,
-    
+
     /// enable global hotkey
     pub enable_global_hotkey: Option<bool>,
 
+    /// 首页卡片设置
+    /// 控制首页各个卡片的显示和隐藏
+    pub home_cards: Option<serde_json::Value>,
+
     /// 切换代理时自动关闭连接
     pub auto_close_connection: Option<bool>,
 
@@ -185,8 +189,16 @@ pub struct IVerge {
 
     pub enable_tray_speed: Option<bool>,
 
-    /// 轻量模式 - 只保留内核运行
-    pub enable_lite_mode: 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)]
@@ -248,7 +260,7 @@ impl IVerge {
             env_type: Some("bash".into()),
             #[cfg(target_os = "windows")]
             env_type: Some("powershell".into()),
-            start_page: Some("/".into()),
+            start_page: Some("/home".into()),
             traffic_graph: Some(true),
             enable_memory_usage: Some(true),
             enable_group_icon: Some(true),
@@ -288,9 +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_lite_mode: Some(false),
+            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()
         }
     }
@@ -372,8 +388,12 @@ impl IVerge {
         patch!(webdav_username);
         patch!(webdav_password);
         patch!(enable_tray_speed);
-        patch!(enable_lite_mode);
+        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);
     }
 
     /// 在初始化前尝试拿到单例端口的值
@@ -462,8 +482,12 @@ pub struct IVergeResponse {
     pub webdav_username: Option<String>,
     pub webdav_password: Option<String>,
     pub enable_tray_speed: Option<bool>,
-    pub enable_lite_mode: 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 {
@@ -526,8 +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_lite_mode: verge.enable_lite_mode,
+            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/backup.rs

@@ -1,16 +1,17 @@
-use crate::config::Config;
-use crate::utils::dirs;
+use crate::{config::Config, utils::dirs};
 use anyhow::Error;
 use once_cell::sync::OnceCell;
 use parking_lot::Mutex;
 use reqwest_dav::list_cmd::{ListEntity, ListFile};
-use std::collections::HashMap;
-use std::env::{consts::OS, temp_dir};
-use std::fs;
-use std::io::Write;
-use std::path::PathBuf;
-use std::sync::Arc;
-use std::time::Duration;
+use std::{
+    collections::HashMap,
+    env::{consts::OS, temp_dir},
+    fs,
+    io::Write,
+    path::PathBuf,
+    sync::Arc,
+    time::Duration,
+};
 use tokio::time::timeout;
 use zip::write::SimpleFileOptions;
 

src-tauri/src/core/core.rs

@@ -1,20 +1,25 @@
-use crate::config::*;
 #[cfg(target_os = "macos")]
 use crate::core::tray::Tray;
-use crate::core::{handle, service};
-use crate::log_err;
-use crate::module::mihomo::MihomoManager;
-use crate::utils::{dirs, help};
+use crate::{
+    config::*,
+    core::{handle, service},
+    log_err,
+    module::mihomo::MihomoManager,
+    utils::{dirs, help},
+};
 use anyhow::{bail, Result};
+use fs2::FileExt;
 use once_cell::sync::OnceCell;
 use std::{path::PathBuf, sync::Arc, time::Duration};
 use tauri_plugin_shell::ShellExt;
-use tokio::sync::Mutex;
-use tokio::time::sleep;
+use tokio::{sync::Mutex, time::sleep};
+
+use super::service::is_service_running;
 
 #[derive(Debug)]
 pub struct CoreManager {
     running: Arc<Mutex<bool>>,
+    last_check_time: Arc<Mutex<Option<std::time::Instant>>>,
 }
 
 /// 内核运行模式
@@ -33,6 +38,7 @@ impl CoreManager {
         static CORE_MANAGER: OnceCell<CoreManager> = OnceCell::new();
         CORE_MANAGER.get_or_init(|| CoreManager {
             running: Arc::new(Mutex::new(false)),
+            last_check_time: Arc::new(Mutex::new(None)),
         })
     }
 
@@ -49,10 +55,13 @@ impl CoreManager {
         let mut running = self.running.lock().await;
 
         if !*running {
+            println!("[停止内核] 内核未运行");
             log::debug!("core is not running");
             return Ok(());
         }
 
+        println!("[停止内核] 开始停止内核");
+
         // 关闭tun模式
         // Create a JSON object to disable TUN mode
         let disable = serde_json::json!({
@@ -60,17 +69,22 @@ impl CoreManager {
             "enable": false
             }
         });
+        println!("[停止内核] 禁用TUN模式");
         log::debug!(target: "app", "disable tun mode");
         log_err!(MihomoManager::global().patch_configs(disable).await);
 
         // 服务模式
         if service::check_service().await.is_ok() {
+            println!("[停止内核] 尝试通过服务停止内核");
             log::info!(target: "app", "stop the core by service");
             match service::stop_core_by_service().await {
                 Ok(_) => {
+                    println!("[停止内核] 服务模式下内核停止成功");
                     log::info!(target: "app", "core stopped successfully by service");
                 }
                 Err(err) => {
+                    println!("[停止内核] 服务模式下停止内核失败: {}", err);
+                    println!("[停止内核] 尝试停止可能的sidecar进程");
                     log::warn!(target: "app", "failed to stop core by service: {}", err);
                     // 服务停止失败，尝试停止可能的sidecar进程
                     self.stop_sidecar_process();
@@ -78,22 +92,44 @@ impl CoreManager {
             }
         } else {
             // 如果没有使用服务，尝试停止sidecar进程
+            println!("[停止内核] 服务不可用，尝试停止sidecar进程");
             self.stop_sidecar_process();
         }
 
+        // 释放文件锁
+        println!("[停止内核] 尝试释放文件锁");
+        if let Some(_) = handle::Handle::global().release_core_lock() {
+            println!("[停止内核] 文件锁释放成功");
+            log::info!(target: "app", "released core lock file");
+        } else {
+            println!("[停止内核] 没有文件锁需要释放");
+        }
+
         *running = false;
+        println!("[停止内核] 内核停止完成");
         Ok(())
     }
 
     /// 停止通过sidecar启动的进程
     fn stop_sidecar_process(&self) {
         if let Some(process) = handle::Handle::global().take_core_process() {
+            println!("[停止sidecar] 发现sidecar进程，准备停止");
             log::info!(target: "app", "stopping core process in sidecar mode");
+
+            // 尝试获取进程ID
+            let pid = process.pid();
+            println!("[停止sidecar] 进程PID: {}", pid);
+
+            // 尝试终止进程
             if let Err(e) = process.kill() {
+                println!("[停止sidecar] 终止sidecar进程失败: {}", e);
                 log::warn!(target: "app", "failed to kill core process: {}", e);
             } else {
+                println!("[停止sidecar] sidecar进程已成功终止");
                 log::info!(target: "app", "core process stopped successfully");
             }
+        } else {
+            println!("[停止sidecar] 没有找到sidecar进程");
         }
     }
 
@@ -107,15 +143,17 @@ impl CoreManager {
 
         let config_path = Config::generate_file(ConfigType::Run)?;
 
-        // 先尝试服务模式
-        if service::check_service().await.is_ok() {
+        // 先检查服务状态
+        let service_available = service::check_service().await.is_ok();
+        
+        if service_available {
             log::info!(target: "app", "try to run core in service mode");
             match service::run_core_by_service(&config_path).await {
                 Ok(_) => {
                     log::info!(target: "app", "core started successfully in service mode");
                 }
                 Err(err) => {
-                    // 服务启动失败，尝试sidecar模式
+                    // 服务启动失败，直接尝试sidecar模式，不再尝试重装服务
                     log::warn!(target: "app", "failed to start core in service mode: {}", err);
                     log::info!(target: "app", "trying to run core in sidecar mode");
                     self.run_core_by_sidecar(&config_path).await?;
@@ -142,6 +180,99 @@ impl CoreManager {
         let clash_core = clash_core.unwrap_or("verge-mihomo".into());
 
         log::info!(target: "app", "starting core {} in sidecar mode", clash_core);
+        println!("[sidecar启动] 开始以sidecar模式启动内核: {}", clash_core);
+
+        // 检查系统中是否存在同名进程
+        if let Ok(pids) = self.check_existing_processes(&clash_core).await {
+            if !pids.is_empty() {
+                println!("[sidecar启动] 警告：系统中已存在同名进程");
+                // 尝试检查端口占用
+                if let Ok(config_content) = std::fs::read_to_string(config_path) {
+                    if let Ok(config) = serde_yaml::from_str::<serde_yaml::Value>(&config_content) {
+                        // 获取配置中定义的端口
+                        let mixed_port = config
+                            .get("mixed-port")
+                            .and_then(|v| v.as_u64())
+                            .unwrap_or(7890);
+                        let http_port = config.get("port").and_then(|v| v.as_u64()).unwrap_or(7890);
+
+                        println!(
+                            "[sidecar启动] 检查端口占用: HTTP端口={}, 混合端口={}",
+                            http_port, mixed_port
+                        );
+
+                        // 检查端口是否被占用
+                        if self.is_port_in_use(mixed_port as u16).await
+                            || self.is_port_in_use(http_port as u16).await
+                        {
+                            println!("[sidecar启动] 端口已被占用，尝试终止已存在的进程");
+
+                            // 尝试终止已存在的进程
+                            for pid in pids {
+                                println!("[sidecar启动] 尝试终止进程 PID: {}", pid);
+                                self.terminate_process(pid).await;
+                            }
+
+                            // 等待短暂时间让资源释放
+                            println!("[sidecar启动] 等待500ms让资源释放");
+                            sleep(Duration::from_millis(500)).await;
+                        }
+                    }
+                }
+            }
+        } else {
+            println!("[sidecar启动] 无法检查系统进程，继续尝试启动");
+        }
+
+        // 创建锁文件路径
+        let lock_file = dirs::app_home_dir()?.join(format!("{}.lock", clash_core));
+        println!("[sidecar启动] 锁文件路径: {:?}", lock_file);
+
+        // 尝试获取文件锁
+        println!("[sidecar启动] 尝试获取文件锁");
+        let file = std::fs::OpenOptions::new()
+            .write(true)
+            .create(true)
+            .open(&lock_file)?;
+
+        match file.try_lock_exclusive() {
+            Ok(_) => {
+                // 成功获取锁，说明没有其他实例运行
+                println!("[sidecar启动] 成功获取文件锁，没有检测到其他运行的实例");
+                log::info!(target: "app", "acquired lock for core process");
+
+                // 保存锁对象到全局，防止被Drop
+                handle::Handle::global().set_core_lock(file);
+            }
+            Err(err) => {
+                // 无法获取锁，说明已有实例运行
+                println!("[sidecar启动] 无法获取文件锁，检测到其他实例可能正在运行");
+                println!("[sidecar启动] 错误信息: {:?}", err);
+                log::warn!(target: "app", "another core process appears to be running");
+
+                // 尝试强制获取锁（可能会导致其他进程崩溃）
+                println!("[sidecar启动] 尝试强制删除并重新创建锁文件");
+                std::fs::remove_file(&lock_file)?;
+                let file = std::fs::OpenOptions::new()
+                    .write(true)
+                    .create(true)
+                    .open(&lock_file)?;
+
+                println!("[sidecar启动] 尝试强制获取锁");
+                match file.lock_exclusive() {
+                    Ok(_) => println!("[sidecar启动] 成功强制获取锁"),
+                    Err(e) => println!("[sidecar启动] 强制获取锁失败: {:?}", e),
+                }
+                file.lock_exclusive()?;
+
+                // 保存新锁
+                handle::Handle::global().set_core_lock(file);
+
+                // 等待可能的其他进程退出
+                println!("[sidecar启动] 等待500ms，让可能的其他进程退出");
+                sleep(Duration::from_millis(500)).await;
+            }
+        }
 
         let app_handle = handle::Handle::global()
             .app_handle()
@@ -152,6 +283,7 @@ impl CoreManager {
         let config_path_str = dirs::path_to_str(config_path)?;
 
         // 启动核心进程并转入后台运行
+        println!("[sidecar启动] 开始启动核心进程");
         let (_, child) = app_handle
             .shell()
             .sidecar(clash_core)?
@@ -159,11 +291,13 @@ impl CoreManager {
             .spawn()?;
 
         // 保存进程ID以便后续管理
+        println!("[sidecar启动] 核心进程启动成功，PID: {:?}", child.pid());
         handle::Handle::global().set_core_process(child);
 
         // 等待短暂时间确保启动成功
         sleep(Duration::from_millis(300)).await;
 
+        println!("[sidecar启动] 内核启动完成");
         log::info!(target: "app", "core started in sidecar mode");
         Ok(())
     }
@@ -178,6 +312,19 @@ impl CoreManager {
         Ok(())
     }
 
+    /// 强制重新安装服务（供UI调用，用户主动修复服务）
+    pub async fn repair_service(&self) -> Result<()> {
+        log::info!(target: "app", "user requested service repair");
+        
+        // 调用强制重装服务
+        service::force_reinstall_service().await?;
+        
+        // 重启核心
+        self.restart_core().await?;
+        
+        Ok(())
+    }
+
     /// 使用默认配置
     pub async fn use_default_config(&self, msg_type: &str, msg_content: &str) -> Result<()> {
         let runtime_path = dirs::app_home_dir()?.join(RUNTIME_CONFIG);
@@ -536,7 +683,26 @@ impl CoreManager {
 
                 // 5. 应用新配置
                 println!("[core配置更新] 应用新配置");
-                for i in 0..3 {
+                
+                // 检查当前运行模式
+                let running_mode = self.get_running_mode().await;
+                
+                // 使用指数退避策略进行重试
+                let mut retry_count = 0;
+                let max_retries = 3;
+                
+                loop {
+                    // 仅在服务模式下确保服务在运行
+                    match running_mode {
+                        RunningMode::Service => {
+                            println!("[core配置更新] 服务模式下检查服务状态");
+                            self.ensure_running_core().await;
+                        },
+                        _ => {
+                            println!("[core配置更新] 非服务模式，跳过服务状态检查");
+                        }
+                    }
+
                     match MihomoManager::global().put_configs_force(run_path).await {
                         Ok(_) => {
                             println!("[core配置更新] 配置应用成功");
@@ -544,19 +710,21 @@ impl CoreManager {
                             return Ok((true, String::new()));
                         }
                         Err(err) => {
-                            if i < 2 {
-                                println!("[core配置更新] 第{}次重试应用配置", i + 1);
-                                log::info!(target: "app", "{err}");
-                                sleep(Duration::from_millis(100)).await;
+                            retry_count += 1;
+                            if retry_count < max_retries {
+                                // 使用指数退避策略计算下一次重试间隔
+                                let wait_time = 200 * (2_u64.pow(retry_count as u32 - 1));
+                                println!("[core配置更新] 第{}次重试应用配置，等待{}ms", retry_count, wait_time);
+                                log::info!(target: "app", "配置应用失败: {}，将在{}ms后重试", err, wait_time);
+                                sleep(Duration::from_millis(wait_time)).await;
                             } else {
-                                println!("[core配置更新] 配置应用失败: {}", err);
+                                println!("[core配置更新] 已重试{}次，配置应用失败: {}", max_retries, err);
                                 Config::runtime().discard();
                                 return Ok((false, err.to_string()));
                             }
                         }
                     }
                 }
-                Ok((true, String::new()))
             }
             Ok((false, error_msg)) => {
                 println!("[core配置更新] 配置验证失败: {}", error_msg);
@@ -617,7 +785,14 @@ impl CoreManager {
                     _ => {
                         // 服务存在但可能没有运行，检查是否有sidecar进程
                         if handle::Handle::global().has_core_process() {
-                            RunningMode::Sidecar
+                            // 检查是否持有文件锁，确保是由我们启动的进程
+                            if handle::Handle::global().has_core_lock() {
+                                RunningMode::Sidecar
+                            } else {
+                                // 有进程但没有文件锁，可能是外部启动的进程
+                                log::warn!(target: "app", "core process exists but no lock file");
+                                RunningMode::Sidecar // 仍返回Sidecar模式，但记录了警告
+                            }
                         } else {
                             RunningMode::NotRunning
                         }
@@ -627,11 +802,283 @@ impl CoreManager {
             Err(_) => {
                 // 服务不可用，检查是否有sidecar进程
                 if handle::Handle::global().has_core_process() {
-                    RunningMode::Sidecar
+                    // 检查是否持有文件锁，确保是由我们启动的进程
+                    if handle::Handle::global().has_core_lock() {
+                        RunningMode::Sidecar
+                    } else {
+                        // 有进程但没有文件锁，可能是外部启动的进程
+                        log::warn!(target: "app", "core process exists but no lock file");
+                        RunningMode::Sidecar // 仍返回Sidecar模式，但记录了警告
+                    }
                 } else {
                     RunningMode::NotRunning
                 }
             }
         }
     }
+
+    /// 检查系统中是否存在同名进程
+    async fn check_existing_processes(&self, process_name: &str) -> Result<Vec<u32>> {
+        println!("[进程检查] 检查系统中是否存在进程: {}", process_name);
+        
+        #[cfg(target_os = "windows")]
+        {
+            use std::process::Command;
+            
+            println!("[进程检查] Windows系统，使用tasklist命令");
+            let output = Command::new("tasklist")
+                .args(["/FO", "CSV", "/NH"])
+                .output()?;
+                
+            let output = String::from_utf8_lossy(&output.stdout);
+
+            let pids: Vec<u32> = output
+                .lines()
+                .filter(|line| line.contains(process_name))
+                .filter_map(|line| {
+                    println!("[进程检查] 发现匹配行: {}", line);
+                    let parts: Vec<&str> = line.split(',').collect();
+                    if parts.len() >= 2 {
+                        let pid_str = parts[1].trim_matches('"');
+                        pid_str.parse::<u32>().ok().map(|pid| {
+                            println!("[进程检查] 发现进程 PID: {}", pid);
+                            pid
+                        })
+                    } else {
+                        None
+                    }
+                })
+                .collect();
+            
+            println!("[进程检查] 共发现 {} 个相关进程", pids.len());
+            Ok(pids)
+        }
+        
+        #[cfg(target_os = "linux")]
+        {
+            use std::process::Command;
+            
+            println!("[进程检查] Linux系统，使用pgrep命令");
+            let output = Command::new("pgrep")
+                .arg("-f")
+                .arg(process_name)
+                .output()?;
+                
+            let output = String::from_utf8_lossy(&output.stdout);
+
+            let pids: Vec<u32> = output
+                .lines()
+                .filter_map(|line| {
+                    line.trim().parse::<u32>().ok().map(|pid| {
+                        println!("[进程检查] 发现进程 PID: {}", pid);
+                        pid
+                    })
+                })
+                .collect();
+            
+            println!("[进程检查] 共发现 {} 个相关进程", pids.len());
+            Ok(pids)
+        }
+        
+        #[cfg(target_os = "macos")]
+        {
+            use std::process::Command;
+            
+            println!("[进程检查] macOS系统，使用ps命令");
+            let output = Command::new("ps")
+                .args(["-ax", "-o", "pid,command"])
+                .output()?;
+                
+            let output = String::from_utf8_lossy(&output.stdout);
+
+            let pids: Vec<u32> = output
+                .lines()
+                .filter(|line| line.contains(process_name))
+                .filter_map(|line| {
+                    println!("[进程检查] 发现匹配行: {}", line);
+                    let parts: Vec<&str> = line.split_whitespace().collect();
+                    if !parts.is_empty() {
+                        parts[0].parse::<u32>().ok().map(|pid| {
+                            println!("[进程检查] 发现进程 PID: {}", pid);
+                            pid
+                        })
+                    } else {
+                        None
+                    }
+                })
+                .collect();
+            
+            println!("[进程检查] 共发现 {} 个相关进程", pids.len());
+            Ok(pids)
+        }
+    }
+
+    /// 检查端口是否被占用
+    async fn is_port_in_use(&self, port: u16) -> bool {
+        println!("[端口检查] 检查端口 {} 是否被占用", port);
+
+       use tokio::net::TcpSocket;
+
+        match TcpSocket::new_v4() {
+            Ok(socket) => {
+                let addr = format!("127.0.0.1:{}", port).parse().unwrap();
+                match socket.bind(addr) {
+                    Ok(_) => {
+                        // 如果能绑定成功，说明端口未被占用
+                        println!("[端口检查] 端口 {} 未被占用", port);
+                        false
+                    }
+                    Err(_) => {
+                        // 绑定失败，端口已被占用
+                        println!("[端口检查] 端口 {} 已被占用", port);
+                        true
+                    }
+                }
+            }
+            Err(err) => {
+                // 创建socket失败，保守返回端口被占用
+                println!("[端口检查] 创建Socket失败: {:?}, 假设端口已被占用", err);
+                true
+            }
+        }
+    }
+
+    /// 终止进程
+    async fn terminate_process(&self, pid: u32) {
+        println!("[进程终止] 尝试终止进程 PID: {}", pid);
+
+        #[cfg(target_os = "windows")]
+        {
+            use std::process::Command;
+            let output = Command::new("taskkill")
+                .args(["/F", "/PID", &pid.to_string()])
+                .output();
+
+            match output {
+                Ok(output) => {
+                    if output.status.success() {
+                        println!("[进程终止] 成功终止进程 PID: {}", pid);
+                    } else {
+                        let stderr = String::from_utf8_lossy(&output.stderr);
+                        println!("[进程终止] 终止进程失败: {}", stderr);
+                    }
+                }
+                Err(err) => {
+                    println!("[进程终止] 执行终止命令失败: {:?}", err);
+                }
+            }
+        }
+
+        #[cfg(target_os = "linux")]
+        {
+            use std::process::Command;
+            let output = Command::new("kill").args(["-9", &pid.to_string()]).output();
+
+            match output {
+                Ok(output) => {
+                    if output.status.success() {
+                        println!("[进程终止] 成功终止进程 PID: {}", pid);
+                    } else {
+                        let stderr = String::from_utf8_lossy(&output.stderr);
+                        println!("[进程终止] 终止进程失败: {}", stderr);
+                    }
+                }
+                Err(err) => {
+                    println!("[进程终止] 执行终止命令失败: {:?}", err);
+                }
+            }
+        }
+
+        #[cfg(target_os = "macos")]
+        {
+            use std::process::Command;
+            let output = Command::new("kill").args(["-9", &pid.to_string()]).output();
+
+            match output {
+                Ok(output) => {
+                    if output.status.success() {
+                        println!("[进程终止] 成功终止进程 PID: {}", pid);
+                    } else {
+                        let stderr = String::from_utf8_lossy(&output.stderr);
+                        println!("[进程终止] 终止进程失败: {}", stderr);
+                    }
+                }
+                Err(err) => {
+                    println!("[进程终止] 执行终止命令失败: {:?}", err);
+                }
+            }
+        }
+    }
+    /// 确保 Mihomo 和 Verge service 都在运行
+    pub async fn ensure_running_core(&self) {
+        // 添加时间间隔检查，避免频繁执行
+        let min_check_interval = Duration::from_secs(20); // 最小检查间隔为20秒
+        
+        let should_check = {
+            let mut last_check = self.last_check_time.lock().await;
+            let now = std::time::Instant::now();
+            
+            match *last_check {
+                Some(time) if now.duration_since(time) < min_check_interval => {
+                    // 如果距离上次检查时间不足30秒，跳过本次检查
+                    false
+                },
+                _ => {
+                    // 更新最后检查时间
+                    *last_check = Some(now);
+                    true
+                }
+            }
+        };
+        
+        if !should_check {
+            return;
+        }
+        
+        // 检查当前运行模式，只在服务模式下执行完整的检查
+        match self.get_running_mode().await {
+            RunningMode::Service => {
+                println!("[确保核心运行] 服务模式下检查核心状态");
+                
+                // 检查Mihomo是否运行
+                if MihomoManager::global().is_mihomo_running().await.is_err() {
+                    println!("[确保核心运行] Mihomo未运行，尝试重启");
+                    log_err!(self.restart_core().await);
+                    return; // 已重启，无需继续检查
+                }
+                
+                // 检查服务是否运行
+                match is_service_running().await {
+                    Ok(false) => {
+                        println!("[确保核心运行] 服务未运行，尝试重启");
+                        log_err!(self.restart_core().await);
+                    },
+                    Ok(true) => {
+                        // 服务运行中，再次确认Mihomo状态
+                        if MihomoManager::global().is_mihomo_running().await.is_err() {
+                            println!("[确保核心运行] 服务运行但Mihomo未响应，尝试重启");
+                            log_err!(self.restart_core().await);
+                        } else {
+                            println!("[确保核心运行] 服务和Mihomo都正常运行");
+                        }
+                    },
+                    Err(err) => {
+                        println!("[确保核心运行] 检查服务状态失败: {:?}", err);
+                    }
+                }
+            },
+            RunningMode::Sidecar => {
+                println!("[确保核心运行] Sidecar模式下仅检查Mihomo状态");
+                // 在Sidecar模式下，只检查Mihomo是否运行
+                if MihomoManager::global().is_mihomo_running().await.is_err() {
+                    println!("[确保核心运行] Mihomo未运行，尝试重启");
+                    log_err!(self.restart_core().await);
+                }
+            },
+            RunningMode::NotRunning => {
+                println!("[确保核心运行] 核心未运行，尝试启动");
+                log_err!(self.start_core().await);
+            }
+        }
+    }
 }

src-tauri/src/core/handle.rs

@@ -4,12 +4,14 @@ use parking_lot::RwLock;
 use std::sync::Arc;
 use tauri::{AppHandle, Emitter, Manager, WebviewWindow};
 use tauri_plugin_shell::process::CommandChild;
+use std::fs::File;
 
 #[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>>>,
+    pub core_lock: Arc<RwLock<Option<File>>>,
 }
 
 impl Handle {
@@ -20,6 +22,7 @@ impl Handle {
             app_handle: Arc::new(RwLock::new(None)),
             is_exiting: Arc::new(RwLock::new(false)),
             core_process: Arc::new(RwLock::new(None)),
+            core_lock: Arc::new(RwLock::new(None)),
         })
     }
 
@@ -89,4 +92,21 @@ impl Handle {
     pub fn is_exiting(&self) -> bool {
         *self.is_exiting.read()
     }
+    
+    /// 设置核心文件锁
+    pub fn set_core_lock(&self, file: File) {
+        let mut core_lock = self.core_lock.write();
+        *core_lock = Some(file);
+    }
+    
+    /// 释放核心文件锁
+    pub fn release_core_lock(&self) -> Option<File> {
+        let mut core_lock = self.core_lock.write();
+        core_lock.take()
+    }
+    
+    /// 检查是否持有核心文件锁
+    pub fn has_core_lock(&self) -> bool {
+        self.core_lock.read().is_some()
+    }
 }

src-tauri/src/core/hotkey.rs

@@ -1,13 +1,13 @@
-use crate::core::handle;
-use crate::{config::Config, feat, log_err};
-use crate::utils::resolve;
+use crate::{
+    config::Config, core::handle, feat, log_err, module::lightweight::entry_lightweight_mode,
+    utils::resolve,
+};
 use anyhow::{bail, Result};
 use once_cell::sync::OnceCell;
 use parking_lot::Mutex;
 use std::{collections::HashMap, sync::Arc};
-use tauri::Manager;
+use tauri::{async_runtime, Manager};
 use tauri_plugin_global_shortcut::{Code, GlobalShortcutExt, ShortcutState};
-use tauri::async_runtime;
 
 pub struct Hotkey {
     current: Arc<Mutex<Vec<String>>>, // 保存当前的热键设置
@@ -26,7 +26,10 @@ impl Hotkey {
         let verge = Config::verge();
         let enable_global_hotkey = verge.latest().enable_global_hotkey.unwrap_or(true);
 
-        println!("Initializing hotkeys, global hotkey enabled: {}", enable_global_hotkey);
+        println!(
+            "Initializing hotkeys, global hotkey enabled: {}",
+            enable_global_hotkey
+        );
         log::info!(target: "app", "Initializing hotkeys, global hotkey enabled: {}", enable_global_hotkey);
 
         // 如果全局热键被禁用，则不注册热键
@@ -85,11 +88,17 @@ impl Hotkey {
         let app_handle = handle::Handle::global().app_handle().unwrap();
         let manager = app_handle.global_shortcut();
 
-        println!("Attempting to register hotkey: {} for function: {}", hotkey, func);
+        println!(
+            "Attempting to register hotkey: {} for function: {}",
+            hotkey, func
+        );
         log::info!(target: "app", "Attempting to register hotkey: {} for function: {}", hotkey, func);
 
         if manager.is_registered(hotkey) {
-            println!("Hotkey {} was already registered, unregistering first", hotkey);
+            println!(
+                "Hotkey {} was already registered, unregistering first",
+                hotkey
+            );
             log::info!(target: "app", "Hotkey {} was already registered, unregistering first", hotkey);
             manager.unregister(hotkey)?;
         }
@@ -101,12 +110,12 @@ impl Hotkey {
                 || {
                     println!("=== Hotkey Dashboard Window Operation Start ===");
                     log::info!(target: "app", "=== Hotkey Dashboard Window Operation Start ===");
-                    
+
                     // 使用 spawn_blocking 来确保在正确的线程上执行
                     async_runtime::spawn_blocking(|| {
                         println!("Toggle dashboard window visibility");
                         log::info!(target: "app", "Toggle dashboard window visibility");
-                        
+
                         // 检查窗口是否存在
                         if let Some(window) = handle::Handle::global().get_window() {
                             // 如果窗口可见，则隐藏它
@@ -131,17 +140,20 @@ impl Hotkey {
                             resolve::create_window();
                         }
                     });
-                    
+
                     println!("=== Hotkey Dashboard Window Operation End ===");
                     log::info!(target: "app", "=== Hotkey Dashboard Window Operation End ===");
                 }
-            },
+            }
             "clash_mode_rule" => || feat::change_clash_mode("rule".into()),
             "clash_mode_global" => || feat::change_clash_mode("global".into()),
             "clash_mode_direct" => || feat::change_clash_mode("direct".into()),
             "toggle_system_proxy" => || feat::toggle_system_proxy(),
             "toggle_tun_mode" => || feat::toggle_tun_mode(None),
+            "entry_lightweight_mode" => || entry_lightweight_mode(),
             "quit" => || feat::quit(Some(0)),
+            #[cfg(target_os = "macos")]
+            "hide" => || feat::hide(),
 
             _ => {
                 println!("Invalid function: {}", func);
@@ -169,19 +181,20 @@ impl Hotkey {
                     // 直接执行函数，不做任何状态检查
                     println!("Executing function directly");
                     log::info!(target: "app", "Executing function directly");
-                    
-                    // 获取轻量模式状态和全局热键状态
-                    let is_lite_mode = Config::verge().latest().enable_lite_mode.unwrap_or(false);
-                    let is_enable_global_hotkey = Config::verge().latest().enable_global_hotkey.unwrap_or(true);
-                    
-                    // 在轻量模式下或配置了全局热键时，始终执行热键功能
-                    if is_lite_mode || is_enable_global_hotkey {
+
+                    // 获取全局热键状态
+                    let is_enable_global_hotkey = Config::verge()
+                        .latest()
+                        .enable_global_hotkey
+                        .unwrap_or(true);
+
+                    if is_enable_global_hotkey {
                         f();
                     } else if let Some(window) = app_handle.get_webview_window("main") {
                         // 非轻量模式且未启用全局热键时，只在窗口可见且有焦点的情况下响应热键
                         let is_visible = window.is_visible().unwrap_or(false);
                         let is_focused = window.is_focused().unwrap_or(false);
-                        
+
                         if is_focused && is_visible {
                             f();
                         }

src-tauri/src/core/service.rs

@@ -1,16 +1,82 @@
-use crate::config::Config;
-use crate::utils::dirs;
+use crate::{config::Config, utils::dirs};
 use anyhow::{bail, Context, Result};
 use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-use std::path::PathBuf;
-use std::{env::current_exe, 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.1"; // 定义所需的服务版本号
+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>,   // 上次错误信息
+}
+
+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 {
@@ -44,6 +110,15 @@ pub struct VersionJsonResponse {
 pub async fn reinstall_service() -> Result<()> {
     log::info!(target:"app", "reinstall service");
 
+    // 获取当前服务状态
+    let mut service_state = ServiceState::get();
+    
+    // 检查是否允许重装
+    if !service_state.can_reinstall() {
+        log::warn!(target:"app", "service reinstall rejected: cooldown period or max attempts reached");
+        bail!("Service reinstallation is rate limited. Please try again later.");
+    }
+
     use deelevate::{PrivilegeLevel, Token};
     use runas::Command as RunasCommand;
     use std::os::windows::process::CommandExt;
@@ -77,12 +152,20 @@ pub async fn reinstall_service() -> Result<()> {
     };
 
     if !status.success() {
-        bail!(
+        let error = format!(
             "failed to install service with status {}",
             status.code().unwrap()
         );
+        service_state.last_error = Some(error.clone());
+        service_state.save()?;
+        bail!(error);
     }
 
+    // 记录安装信息并保存
+    service_state.record_install();
+    service_state.last_error = None;
+    service_state.save()?;
+
     Ok(())
 }
 
@@ -133,6 +216,12 @@ pub async fn reinstall_service() -> Result<()> {
         );
     }
 
+    // 记录安装信息并保存
+    let mut service_state = ServiceState::get();
+    service_state.record_install();
+    service_state.last_error = None;
+    service_state.save()?;
+
     Ok(())
 }
 
@@ -154,11 +243,13 @@ pub async fn reinstall_service() -> Result<()> {
 
     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() {
+        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"
@@ -166,7 +257,7 @@ pub async fn reinstall_service() -> Result<()> {
     } else {
         &prompt
     };
-    
+
     let command = format!(
         r#"do shell script "sudo '{uninstall_shell}' && sudo '{install_shell}'" with administrator privileges with prompt "{prompt}""#
     );
@@ -183,6 +274,13 @@ pub async fn reinstall_service() -> Result<()> {
             status.code().unwrap()
         );
     }
+
+    // 记录安装信息并保存
+    let mut service_state = ServiceState::get();
+    service_state.record_install();
+    service_state.last_error = None;
+    service_state.save()?;
+    
     Ok(())
 }
 
@@ -227,19 +325,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());
@@ -251,6 +384,8 @@ pub(super) async fn run_core_by_service(config_file: &PathBuf) -> Result<()> {
 
     let config_dir = dirs::app_home_dir()?;
     let config_dir = dirs::path_to_str(&config_dir)?;
+    #[cfg(target_os = "linux")]
+    let config_dir = &(config_dir.replace("/verge-mihomo", "") + "/resources");
 
     let log_path = dirs::service_log_file()?;
     let log_path = dirs::path_to_str(&log_path)?;
@@ -279,6 +414,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,9 +533,32 @@ pub async fn is_service_running() -> Result<bool> {
     let resp = check_service().await?;
 
     // 检查服务状态码和消息
-    if resp.code == 200 && resp.msg == "success" && resp.data.is_some() {
+    if resp.code == 0 && resp.msg == "ok" && resp.data.is_some() {
         Ok(true)
     } else {
         Ok(false)
     }
 }
+
+/// 强制重装服务（用于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,6 +1,6 @@
-use crate::core::handle::Handle;
 use crate::{
     config::{Config, IVerge},
+    core::handle::Handle,
     log_err,
 };
 use anyhow::Result;
@@ -126,8 +126,7 @@ impl Sysopt {
             if !sys_enable {
                 return self.reset_sysproxy().await;
             }
-            use crate::core::handle::Handle;
-            use crate::utils::dirs;
+            use crate::{core::handle::Handle, utils::dirs};
             use anyhow::bail;
             use tauri_plugin_shell::ShellExt;
 
@@ -185,8 +184,7 @@ impl Sysopt {
 
         #[cfg(target_os = "windows")]
         {
-            use crate::core::handle::Handle;
-            use crate::utils::dirs;
+            use crate::{core::handle::Handle, utils::dirs};
             use anyhow::bail;
             use tauri_plugin_shell::ShellExt;
 
@@ -222,15 +220,50 @@ impl Sysopt {
         let enable = enable.unwrap_or(false);
         let app_handle = Handle::global().app_handle().unwrap();
         let autostart_manager = app_handle.autolaunch();
-        println!("enable: {}", enable);
+        
+        log::info!(target: "app", "Setting auto launch to: {}", enable);
+        
         match enable {
-            true => log_err!(autostart_manager.enable()),
-            false => log_err!(autostart_manager.disable()),
+            true => {
+                let result = autostart_manager.enable();
+                if let Err(ref e) = result {
+                    log::error!(target: "app", "Failed to enable auto launch: {}", e);
+                } else {
+                    log::info!(target: "app", "Auto launch enabled successfully");
+                }
+                log_err!(result)
+            },
+            false => {
+                let result = autostart_manager.disable();
+                if let Err(ref e) = result {
+                    log::error!(target: "app", "Failed to disable auto launch: {}", e);
+                } else {
+                    log::info!(target: "app", "Auto launch disabled successfully");
+                }
+                log_err!(result)
+            },
         };
 
         Ok(())
     }
 
+    /// 获取当前自启动的实际状态
+    pub fn get_launch_status(&self) -> Result<bool> {
+        let app_handle = Handle::global().app_handle().unwrap();
+        let autostart_manager = app_handle.autolaunch();
+        
+        match autostart_manager.is_enabled() {
+            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))
+            }
+        }
+    }
+
     fn guard_proxy(&self) {
         let _lock = self.guard_state.lock();
 
@@ -305,8 +338,7 @@ impl Sysopt {
 
                 #[cfg(target_os = "windows")]
                 {
-                    use crate::core::handle::Handle;
-                    use crate::utils::dirs;
+                    use crate::{core::handle::Handle, utils::dirs};
                     use tauri_plugin_shell::ShellExt;
 
                     let app_handle = Handle::global().app_handle().unwrap();

src-tauri/src/core/timer.rs

@@ -1,24 +1,32 @@
-use crate::config::Config;
-use crate::feat;
-use crate::core::CoreManager;
+use crate::{config::Config, core::CoreManager, feat};
 use anyhow::{Context, Result};
 use delay_timer::prelude::{DelayTimer, DelayTimerBuilder, TaskBuilder};
 use once_cell::sync::OnceCell;
-use parking_lot::Mutex;
-use std::collections::HashMap;
-use std::sync::Arc;
+use parking_lot::{Mutex, RwLock};
+use std::{collections::HashMap, sync::Arc};
 
 type TaskID = u64;
 
+#[derive(Debug, Clone)]
+pub struct TimerTask {
+    pub task_id: TaskID,
+    pub interval_minutes: u64,
+    #[allow(unused)]
+    pub last_run: i64, // Timestamp of last execution
+}
+
 pub struct Timer {
     /// cron manager
-    delay_timer: Arc<Mutex<DelayTimer>>,
+    pub delay_timer: Arc<RwLock<DelayTimer>>,
 
-    /// save the current state
-    timer_map: Arc<Mutex<HashMap<String, (TaskID, u64)>>>,
+    /// save the current state - using RwLock for better read concurrency
+    pub timer_map: Arc<RwLock<HashMap<String, TimerTask>>>,
 
-    /// increment id
-    timer_count: Arc<Mutex<TaskID>>,
+    /// increment id - kept as mutex since it's just a counter
+    pub timer_count: Arc<Mutex<TaskID>>,
+
+    /// Flag to mark if timer is initialized - atomic for better performance
+    pub initialized: Arc<std::sync::atomic::AtomicBool>,
 }
 
 impl Timer {
@@ -26,68 +34,145 @@ impl Timer {
         static TIMER: OnceCell<Timer> = OnceCell::new();
 
         TIMER.get_or_init(|| Timer {
-            delay_timer: Arc::new(Mutex::new(DelayTimerBuilder::default().build())),
-            timer_map: Arc::new(Mutex::new(HashMap::new())),
+            delay_timer: Arc::new(RwLock::new(DelayTimerBuilder::default().build())),
+            timer_map: Arc::new(RwLock::new(HashMap::new())),
             timer_count: Arc::new(Mutex::new(1)),
+            initialized: Arc::new(std::sync::atomic::AtomicBool::new(false)),
         })
     }
 
-    /// restore timer
+    /// Initialize timer with better error handling and atomic operations
     pub fn init(&self) -> Result<()> {
-        self.refresh()?;
+        // Use compare_exchange for thread-safe initialization check
+        if self
+            .initialized
+            .compare_exchange(
+                false,
+                true,
+                std::sync::atomic::Ordering::SeqCst,
+                std::sync::atomic::Ordering::SeqCst,
+            )
+            .is_err()
+        {
+            log::debug!(target: "app", "Timer already initialized, skipping...");
+            return Ok(());
+        }
+
+        log::info!(target: "app", "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);
+            return Err(e);
+        }
 
         let cur_timestamp = chrono::Local::now().timestamp();
 
-        let timer_map = self.timer_map.lock();
-        let delay_timer = self.delay_timer.lock();
-
-        if let Some(items) = Config::profiles().latest().get_items() {
+        // Collect profiles that need immediate update
+        let profiles_to_update = if let Some(items) = Config::profiles().latest().get_items() {
             items
                 .iter()
                 .filter_map(|item| {
-                    // mins to seconds
-                    let interval = ((item.option.as_ref()?.update_interval?) as i64) * 60;
+                    let interval = item.option.as_ref()?.update_interval? as i64;
                     let updated = item.updated? as i64;
+                    let uid = item.uid.as_ref()?;
 
-                    if interval > 0 && cur_timestamp - updated >= interval {
-                        Some(item)
+                    if interval > 0 && cur_timestamp - updated >= interval * 60 {
+                        Some(uid.clone())
                     } else {
                         None
                     }
                 })
-                .for_each(|item| {
-                    if let Some(uid) = item.uid.as_ref() {
-                        if let Some((task_id, _)) = timer_map.get(uid) {
-                            crate::log_err!(delay_timer.advance_task(*task_id));
-                        }
+                .collect::<Vec<String>>()
+        } else {
+            Vec::new()
+        };
+
+        // Advance tasks outside of locks to minimize lock contention
+        if !profiles_to_update.is_empty() {
+            let timer_map = self.timer_map.read();
+            let delay_timer = self.delay_timer.write();
+
+            for uid in profiles_to_update {
+                if let Some(task) = timer_map.get(&uid) {
+                    log::info!(target: "app", "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);
                     }
-                })
+                }
+            }
         }
 
+        log::info!(target: "app", "Timer initialization completed");
         Ok(())
     }
 
-    /// Correctly update all cron tasks
+    /// Refresh timer tasks with better error handling
     pub fn refresh(&self) -> Result<()> {
+        // Generate diff outside of lock to minimize lock contention
         let diff_map = self.gen_diff();
 
-        let mut timer_map = self.timer_map.lock();
-        let mut delay_timer = self.delay_timer.lock();
+        if diff_map.is_empty() {
+            log::debug!(target: "app", "No timer changes needed");
+            return Ok(());
+        }
 
-        for (uid, diff) in diff_map.into_iter() {
+        log::info!(target: "app", "Refreshing {} timer tasks", diff_map.len());
+
+        // Apply changes while holding locks
+        let mut timer_map = self.timer_map.write();
+        let mut delay_timer = self.delay_timer.write();
+
+        for (uid, diff) in diff_map {
             match diff {
                 DiffFlag::Del(tid) => {
-                    let _ = timer_map.remove(&uid);
-                    crate::log_err!(delay_timer.remove_task(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);
+                    } else {
+                        log::debug!(target: "app", "Removed task {} for uid {}", tid, uid);
+                    }
                 }
-                DiffFlag::Add(tid, val) => {
-                    let _ = timer_map.insert(uid.clone(), (tid, val));
-                    crate::log_err!(self.add_task(&mut delay_timer, uid, tid, val));
+                DiffFlag::Add(tid, interval) => {
+                    let task = TimerTask {
+                        task_id: tid,
+                        interval_minutes: interval,
+                        last_run: chrono::Local::now().timestamp(),
+                    };
+
+                    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);
+                        timer_map.remove(&uid); // Rollback on failure
+                    } else {
+                        log::debug!(target: "app", "Added task {} for uid {}", tid, uid);
+                    }
                 }
-                DiffFlag::Mod(tid, val) => {
-                    let _ = timer_map.insert(uid.clone(), (tid, val));
-                    crate::log_err!(delay_timer.remove_task(tid));
-                    crate::log_err!(self.add_task(&mut delay_timer, uid, tid, val));
+                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);
+                    }
+
+                    // Then add the new one
+                    let task = TimerTask {
+                        task_id: tid,
+                        interval_minutes: interval,
+                        last_run: chrono::Local::now().timestamp(),
+                    };
+
+                    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);
+                        timer_map.remove(&uid); // Rollback on failure
+                    } else {
+                        log::debug!(target: "app", "Updated task {} for uid {}", tid, uid);
+                    }
                 }
             }
         }
@@ -95,18 +180,17 @@ impl Timer {
         Ok(())
     }
 
-    /// generate a uid -> update_interval map
+    /// Generate map of profile UIDs to update intervals
     fn gen_map(&self) -> HashMap<String, u64> {
         let mut new_map = HashMap::new();
 
         if let Some(items) = Config::profiles().latest().get_items() {
             for item in items.iter() {
-                if item.option.is_some() {
-                    let option = item.option.as_ref().unwrap();
-                    let interval = option.update_interval.unwrap_or(0);
-
-                    if interval > 0 {
-                        new_map.insert(item.uid.clone().unwrap(), interval);
+                if let Some(option) = item.option.as_ref() {
+                    if let (Some(interval), Some(uid)) = (option.update_interval, &item.uid) {
+                        if interval > 0 {
+                            new_map.insert(uid.clone(), interval);
+                        }
                     }
                 }
             }
@@ -115,39 +199,50 @@ impl Timer {
         new_map
     }
 
-    /// generate the diff map for refresh
+    /// Generate differences between current and new timer configuration
     fn gen_diff(&self) -> HashMap<String, DiffFlag> {
         let mut diff_map = HashMap::new();
-
-        let timer_map = self.timer_map.lock();
-
         let new_map = self.gen_map();
-        let cur_map = &timer_map;
 
-        cur_map.iter().for_each(|(uid, (tid, val))| {
-            let new_val = new_map.get(uid).unwrap_or(&0);
+        // Read lock for comparing current state
+        let timer_map = self.timer_map.read();
 
-            if *new_val == 0 {
-                diff_map.insert(uid.clone(), DiffFlag::Del(*tid));
-            } else if new_val != val {
-                diff_map.insert(uid.clone(), DiffFlag::Mod(*tid, *new_val));
+        // Find tasks to modify or delete
+        for (uid, task) in timer_map.iter() {
+            match new_map.get(uid) {
+                Some(&interval) if interval != task.interval_minutes => {
+                    // Task exists but interval changed
+                    diff_map.insert(uid.clone(), DiffFlag::Mod(task.task_id, interval));
+                }
+                None => {
+                    // Task no longer needed
+                    diff_map.insert(uid.clone(), DiffFlag::Del(task.task_id));
+                }
+                _ => {
+                    // Task exists with same interval, no change needed
+                }
             }
-        });
+        }
 
-        let mut count = self.timer_count.lock();
+        // Find new tasks to add
+        let mut next_id = *self.timer_count.lock();
 
-        new_map.iter().for_each(|(uid, val)| {
-            if cur_map.get(uid).is_none() {
-                diff_map.insert(uid.clone(), DiffFlag::Add(*count, *val));
-
-                *count += 1;
+        for (uid, &interval) in new_map.iter() {
+            if !timer_map.contains_key(uid) {
+                diff_map.insert(uid.clone(), DiffFlag::Add(next_id, interval));
+                next_id += 1;
             }
-        });
+        }
+
+        // Update counter only if we added new tasks
+        if next_id > *self.timer_count.lock() {
+            *self.timer_count.lock() = next_id;
+        }
 
         diff_map
     }
 
-    /// add a cron task
+    /// Add a timer task with better error handling
     fn add_task(
         &self,
         delay_timer: &mut DelayTimer,
@@ -155,12 +250,19 @@ impl Timer {
         tid: TaskID,
         minutes: u64,
     ) -> Result<()> {
+        log::info!(target: "app", "Adding task: uid={}, id={}, interval={}min", uid, tid, minutes);
+
+        // Create a task with reasonable retries and backoff
         let task = TaskBuilder::default()
             .set_task_id(tid)
             .set_maximum_parallel_runnable_num(1)
             .set_frequency_repeated_by_minutes(minutes)
-            // .set_frequency_repeated_by_seconds(minutes) // for test
-            .spawn_async_routine(move || Self::async_task(uid.to_owned()))
+            .spawn_async_routine(move || {
+                let uid = uid.clone();
+                async move {
+                    Self::async_task(uid).await;
+                }
+            })
             .context("failed to create timer task")?;
 
         delay_timer
@@ -170,19 +272,38 @@ impl Timer {
         Ok(())
     }
 
-    /// the task runner
+    /// Async task with better error handling and logging
     async fn async_task(uid: String) {
-        log::info!(target: "app", "running timer task `{uid}`");
-        
-        // 使用更轻量级的更新方式
-        if let Err(e) = feat::update_profile(uid.clone(), None).await {
-            log::error!(target: "app", "timer task update error: {}", e);
-            return;
-        }
+        let task_start = std::time::Instant::now();
+        log::info!(target: "app", "Running timer task for profile: {}", uid);
 
-        // 只有更新成功后才刷新配置
-        if let Err(e) = CoreManager::global().update_config().await {
-            log::error!(target: "app", "timer task refresh error: {}", e);
+        // Update profile
+        let profile_result = feat::update_profile(uid.clone(), None).await;
+
+        match profile_result {
+            Ok(_) => {
+                // Update configuration
+                match CoreManager::global().update_config().await {
+                    Ok(_) => {
+                        let duration = task_start.elapsed().as_millis();
+                        log::info!(
+                            target: "app",
+                            "Timer task completed successfully for uid: {} (took {}ms)",
+                            uid, duration
+                        );
+                    }
+                    Err(e) => {
+                        log::error!(
+                            target: "app",
+                            "Failed to refresh config after profile update for uid {}: {}",
+                            uid, e
+                        );
+                    }
+                }
+            }
+            Err(e) => {
+                log::error!(target: "app", "Failed to update profile uid {}: {}", uid, e);
+            }
         }
     }
 }

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

@@ -1,13 +1,14 @@
 use once_cell::sync::OnceCell;
+use tauri::tray::TrayIconBuilder;
 #[cfg(target_os = "macos")]
 pub mod speed_rate;
-use crate::module::mihomo::Rate;
 use crate::{
     cmd,
     config::Config,
-    feat, resolve,
-    utils::resolve::VERSION,
-    utils::{dirs, i18n::t},
+    feat,
+    module::{lightweight::entry_lightweight_mode, mihomo::Rate},
+    resolve,
+    utils::{dirs, i18n::t, resolve::VERSION},
 };
 
 use anyhow::Result;
@@ -20,13 +21,15 @@ use parking_lot::RwLock;
 #[cfg(target_os = "macos")]
 pub use speed_rate::{SpeedRate, Traffic};
 #[cfg(target_os = "macos")]
+use std::collections::hash_map::DefaultHasher;
+#[cfg(target_os = "macos")]
+use std::hash::{Hash, Hasher};
+#[cfg(target_os = "macos")]
 use std::sync::Arc;
-use tauri::menu::{CheckMenuItem, IsMenuItem};
-use tauri::AppHandle;
 use tauri::{
-    menu::{MenuEvent, MenuItem, PredefinedMenuItem, Submenu},
-    tray::{MouseButton, MouseButtonState, TrayIconEvent, TrayIconId},
-    Wry,
+    menu::{CheckMenuItem, IsMenuItem, MenuEvent, MenuItem, PredefinedMenuItem, Submenu},
+    tray::{MouseButton, MouseButtonState, TrayIconEvent},
+    App, AppHandle, Wry,
 };
 #[cfg(target_os = "macos")]
 use tokio::sync::broadcast;
@@ -37,6 +40,9 @@ pub struct Tray {
     pub speed_rate: Arc<Mutex<Option<SpeedRate>>>,
     shutdown_tx: Arc<RwLock<Option<broadcast::Sender<()>>>>,
     is_subscribed: Arc<RwLock<bool>>,
+    pub icon_hash: Arc<Mutex<Option<u64>>>,
+    pub icon_cache: Arc<Mutex<Option<Vec<u8>>>>,
+    pub rate_cache: Arc<Mutex<Option<Rate>>>,
 }
 
 #[cfg(not(target_os = "macos"))]
@@ -51,6 +57,9 @@ impl Tray {
             speed_rate: Arc::new(Mutex::new(None)),
             shutdown_tx: Arc::new(RwLock::new(None)),
             is_subscribed: Arc::new(RwLock::new(false)),
+            icon_hash: Arc::new(Mutex::new(None)),
+            icon_cache: Arc::new(Mutex::new(None)),
+            rate_cache: Arc::new(Mutex::new(None)),
         });
 
         #[cfg(not(target_os = "macos"))]
@@ -66,34 +75,27 @@ impl Tray {
         Ok(())
     }
 
-    pub fn create_systray(&self) -> Result<()> {
-        let app_handle = handle::Handle::global().app_handle().unwrap();
-        let tray_incon_id = TrayIconId::new("main");
-        let tray = app_handle.tray_by_id(&tray_incon_id).unwrap();
+    pub fn create_systray(&self, app: &App) -> Result<()> {
+        let mut builder = TrayIconBuilder::with_id("main")
+            .icon(app.default_window_icon().unwrap().clone())
+            .icon_as_template(false);
 
-        #[cfg(target_os = "macos")]
-        tray.set_show_menu_on_left_click(false)?;
+        #[cfg(any(target_os = "macos", target_os = "windows"))]
+        {
+            let tray_event = { Config::verge().latest().tray_event.clone() };
+            let tray_event: String = tray_event.unwrap_or("main_window".into());
+            if tray_event.as_str() != "tray_menu" {
+                builder = builder.show_menu_on_left_click(false);
+            }
+        }
+
+        let tray = builder.build(app)?;
 
         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);
 
-            #[cfg(target_os = "macos")]
-            if let TrayIconEvent::Click {
-                button: MouseButton::Left,
-                button_state: MouseButtonState::Down,
-                ..
-            } = event
-            {
-                match tray_event.as_str() {
-                    "system_proxy" => feat::toggle_system_proxy(),
-                    "tun_mode" => feat::toggle_tun_mode(None),
-                    "main_window" => resolve::create_window(),
-                    _ => {}
-                }
-            }
-
-            #[cfg(not(target_os = "macos"))]
             if let TrayIconEvent::Click {
                 button: MouseButton::Left,
                 button_state: MouseButtonState::Down,
@@ -112,6 +114,19 @@ impl Tray {
         Ok(())
     }
 
+    /// 更新托盘点击行为
+    pub fn update_click_behavior(&self) -> Result<()> {
+        let app_handle = handle::Handle::global().app_handle().unwrap();
+        let tray_event = { Config::verge().latest().tray_event.clone() };
+        let tray_event: String = tray_event.unwrap_or("main_window".into());
+        let tray = app_handle.tray_by_id("main").unwrap();
+        match tray_event.as_str() {
+            "tray_menu" => tray.set_show_menu_on_left_click(true)?,
+            _ => tray.set_show_menu_on_left_click(false)?,
+        }
+        Ok(())
+    }
+
     /// 更新托盘菜单
     pub fn update_menu(&self) -> Result<()> {
         let app_handle = handle::Handle::global().app_handle().unwrap();
@@ -130,7 +145,7 @@ impl Tray {
         let profile_uid_and_name = Config::profiles()
             .data()
             .all_profile_uid_and_name()
-            .unwrap_or(Vec::new());
+            .unwrap_or_default();
 
         let tray = app_handle.tray_by_id("main").unwrap();
         let _ = tray.set_menu(Some(create_tray_menu(
@@ -224,34 +239,66 @@ impl Tray {
 
         #[cfg(target_os = "macos")]
         {
-            let enable_tray_speed = Config::verge().latest().enable_tray_speed.unwrap_or(true);
+            let enable_tray_speed = verge.enable_tray_speed.unwrap_or(true);
+            let enable_tray_icon = verge.enable_tray_icon.unwrap_or(true);
             let is_colorful = tray_icon == "colorful";
-            
-            // 处理图标和速率
-            let final_icon_bytes = if enable_tray_speed {
-                let rate = rate.or_else(|| {
-                    self.speed_rate
-                        .lock()
-                        .as_ref()
-                        .and_then(|speed_rate| speed_rate.get_curent_rate())
-                });
-                
-                // 使用新的方法渲染图标和速率
-                SpeedRate::add_speed_text(icon_bytes, rate)?
-            } else {
-                icon_bytes
+
+            let icon_hash = {
+                let mut hasher = DefaultHasher::new();
+                icon_bytes.clone().hash(&mut hasher);
+                hasher.finish()
             };
 
-            // 设置系统托盘图标
-            let _ = tray.set_icon(Some(tauri::image::Image::from_bytes(&final_icon_bytes)?));
-            // 只对单色图标使用 template 模式
-            let _ = tray.set_icon_as_template(!is_colorful);
+            let mut icon_hash_guard = self.icon_hash.lock();
+            let mut icon_bytes_guard = self.icon_cache.lock();
+            if *icon_hash_guard != Some(icon_hash) {
+                *icon_hash_guard = Some(icon_hash);
+                *icon_bytes_guard = Some(icon_bytes.clone());
+            }
+
+            if !enable_tray_speed || (!enable_tray_speed && !enable_tray_icon) {
+                let _ = tray.set_icon(Some(tauri::image::Image::from_bytes(
+                    &(*icon_bytes_guard).clone().unwrap(),
+                )?));
+                let _ = tray.set_icon_as_template(!is_colorful);
+                return Ok(());
+            }
+
+            let rate = if let Some(rate) = rate {
+                Some(rate)
+            } else {
+                let guard = self.speed_rate.lock();
+                if let Some(rate) = guard.as_ref().unwrap().get_curent_rate() {
+                    Some(rate)
+                } else {
+                    Some(Rate::default())
+                }
+            };
+
+            let mut rate_guard = self.rate_cache.lock();
+            if *rate_guard != rate {
+                *rate_guard = rate;
+
+                let bytes = if enable_tray_icon {
+                    Some(icon_bytes_guard.as_ref().unwrap())
+                } else {
+                    None
+                };
+
+                let rate = rate_guard.as_ref();
+                let rate_bytes = SpeedRate::add_speed_text(bytes, rate).unwrap();
+
+                let _ = tray.set_icon(Some(tauri::image::Image::from_bytes(&rate_bytes)?));
+                let _ = tray.set_icon_as_template(!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(())
+        }
     }
 
     /// 更新托盘提示
@@ -395,21 +442,24 @@ fn create_tray_menu(
                 .collect::<std::collections::HashMap<String, String>>()
         })
         .unwrap_or_default();
-    
+
     let profile_menu_items: Vec<CheckMenuItem<Wry>> = profile_uid_and_name
         .iter()
         .map(|(profile_uid, profile_name)| {
-        let is_current_profile = Config::profiles().data().is_current_profile_index(profile_uid.to_string());
-        CheckMenuItem::with_id(
-            app_handle,
-            &format!("profiles_{}", profile_uid),
-            t(&profile_name),
-            true,
-            is_current_profile,
-            None::<&str>,
-        )
-        .unwrap()
-    }).collect();
+            let is_current_profile = Config::profiles()
+                .data()
+                .is_current_profile_index(profile_uid.to_string());
+            CheckMenuItem::with_id(
+                app_handle,
+                format!("profiles_{}", profile_uid),
+                t(profile_name),
+                true,
+                is_current_profile,
+                None::<&str>,
+            )
+            .unwrap()
+        })
+        .collect();
     let profile_menu_items: Vec<&dyn IsMenuItem<Wry>> = profile_menu_items
         .iter()
         .map(|item| item as &dyn IsMenuItem<Wry>)
@@ -455,12 +505,13 @@ fn create_tray_menu(
     .unwrap();
 
     let profiles = &Submenu::with_id_and_items(
-        app_handle, 
-        "profiles", 
+        app_handle,
+        "profiles",
         t("Profiles"),
-        true, 
+        true,
         &profile_menu_items,
-    ).unwrap();
+    )
+    .unwrap();
 
     let system_proxy = &CheckMenuItem::with_id(
         app_handle,
@@ -482,6 +533,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();
 
@@ -574,6 +634,8 @@ fn create_tray_menu(
             separator,
             system_proxy,
             tun_mode,
+            separator,
+            lighteweight_mode,
             copy_env,
             open_dir,
             more,
@@ -601,10 +663,11 @@ fn on_menu_event(_: &AppHandle, event: MenuEvent) {
         "open_logs_dir" => crate::log_err!(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_") => {
             let profile_index = &id["profiles_".len()..];
             feat::toggle_proxy_profile(profile_index.into());

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

@@ -1,22 +1,20 @@
-use crate::module::mihomo::Rate;
-use crate::module::mihomo::MihomoManager;
-use crate::utils::help::format_bytes_speed;
+use crate::{
+    module::mihomo::{MihomoManager, Rate},
+    utils::help::format_bytes_speed,
+};
 use ab_glyph::FontArc;
 use anyhow::Result;
 use futures::Stream;
 use image::{GenericImageView, Rgba, RgbaImage};
 use imageproc::drawing::draw_text_mut;
 use parking_lot::Mutex;
-use std::io::Cursor;
-use std::sync::Arc;
-use tokio_tungstenite::tungstenite::http;
-use tokio_tungstenite::tungstenite::Message;
+use std::{io::Cursor, sync::Arc};
+use tokio_tungstenite::tungstenite::{http, Message};
 use tungstenite::client::IntoClientRequest;
 #[derive(Debug, Clone)]
 pub struct SpeedRate {
     rate: Arc<Mutex<(Rate, Rate)>>,
     last_update: Arc<Mutex<std::time::Instant>>,
-    // 移除 base_image，不再缓存原始图像
 }
 
 impl SpeedRate {
@@ -39,12 +37,20 @@ impl SpeedRate {
 
         let (current, previous) = &mut *rates;
 
-        // 如果速率变化不大（小于10%），则不更新
-        let should_update = {
-            let up_change = (current.up as f64 - up as f64).abs() / (current.up as f64 + 1.0);
-            let down_change =
-                (current.down as f64 - down as f64).abs() / (current.down as f64 + 1.0);
-            up_change > 0.1 || down_change > 0.1
+        // Avoid unnecessary float conversions for small value checks
+        let should_update = if current.up < 1000 && down < 1000 {
+            // For small values, always update to ensure accuracy
+            current.up != up || current.down != down
+        } else {
+            // For larger values, use integer math to check for >5% change
+            // Multiply by 20 instead of dividing by 0.05 to avoid floating point
+            let up_threshold = current.up / 20;
+            let down_threshold = current.down / 20;
+
+            (up > current.up && up - current.up > up_threshold)
+                || (up < current.up && current.up - up > up_threshold)
+                || (down > current.down && down - current.down > down_threshold)
+                || (down < current.down && current.down - down > down_threshold)
         };
 
         if !should_update {
@@ -70,29 +76,51 @@ 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<'a>(
+        icon_bytes: Option<&'a Vec<u8>>,
+        rate: Option<&'a 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 {
+            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 is_colorful = if let Some(bytes) = icon_bytes {
+            !crate::utils::help::is_monochrome_image_from_bytes(bytes).unwrap_or(false)
+        } else {
+            false
+        };
 
         // 增加文本宽度和间距
-        let text_width = 580; // 文本区域宽度
-        let total_width = icon_width + text_width;
+        let total_width = if icon_bytes.is_some() {
+            if icon_width < 580 {
+                icon_width + 580
+            } else {
+                icon_width
+            }
+        } else {
+            580
+        };
 
         // 创建新的透明画布
         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);
+                }
             }
         }
 

src-tauri/src/enhance/mod.rs

@@ -5,17 +5,10 @@ mod script;
 pub mod seq;
 mod tun;
 
-use self::chain::*;
-use self::field::*;
-use self::merge::*;
-use self::script::*;
-use self::seq::*;
-use self::tun::*;
-use crate::config::Config;
-use crate::utils::tmpl;
+use self::{chain::*, field::*, merge::*, script::*, seq::*, tun::*};
+use crate::{config::Config, utils::tmpl};
 use serde_yaml::Mapping;
-use std::collections::HashMap;
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
 
 type ResultLog = Vec<(String, String)>;
 
@@ -267,11 +260,11 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
     if enable_dns_settings {
         use crate::utils::dirs;
         use std::fs;
-        
+
         // 尝试读取dns_config.yaml
         if let Ok(app_dir) = dirs::app_home_dir() {
             let dns_path = app_dir.join("dns_config.yaml");
-            
+
             if dns_path.exists() {
                 if let Ok(dns_yaml) = fs::read_to_string(&dns_path) {
                     if let Ok(dns_config) = serde_yaml::from_str::<serde_yaml::Mapping>(&dns_yaml) {

src-tauri/src/enhance/seq.rs

@@ -108,7 +108,7 @@ proxy-groups:
     - "proxy1"
 "#;
         let mut config: Mapping = serde_yaml::from_str(config_str).unwrap();
-        
+
         let seq = SeqMap {
             prepend: Sequence::new(),
             append: Sequence::new(),
@@ -121,16 +121,32 @@ proxy-groups:
         let proxies = config.get("proxies").unwrap().as_sequence().unwrap();
         assert_eq!(proxies.len(), 1);
         assert_eq!(
-            proxies[0].as_mapping().unwrap().get("name").unwrap().as_str().unwrap(),
+            proxies[0]
+                .as_mapping()
+                .unwrap()
+                .get("name")
+                .unwrap()
+                .as_str()
+                .unwrap(),
             "proxy2"
         );
 
         // Check if proxy1 is removed from all groups
         let groups = config.get("proxy-groups").unwrap().as_sequence().unwrap();
-        let group1_proxies = groups[0].as_mapping().unwrap()
-            .get("proxies").unwrap().as_sequence().unwrap();
-        let group2_proxies = groups[1].as_mapping().unwrap()
-            .get("proxies").unwrap().as_sequence().unwrap();
+        let group1_proxies = groups[0]
+            .as_mapping()
+            .unwrap()
+            .get("proxies")
+            .unwrap()
+            .as_sequence()
+            .unwrap();
+        let group2_proxies = groups[1]
+            .as_mapping()
+            .unwrap()
+            .get("proxies")
+            .unwrap()
+            .as_sequence()
+            .unwrap();
 
         assert_eq!(group1_proxies.len(), 1);
         assert_eq!(group1_proxies[0].as_str().unwrap(), "proxy2");

src-tauri/src/enhance/tun.rs

@@ -24,7 +24,7 @@ pub async fn use_tun(mut config: Mapping, enable: bool) -> Mapping {
     let mut tun_val = tun_val.map_or(Mapping::new(), |val| {
         val.as_mapping().cloned().unwrap_or(Mapping::new())
     });
-    
+
     if enable {
         // 读取DNS配置
         let dns_key = Value::from("dns");
@@ -40,20 +40,20 @@ pub async fn use_tun(mut config: Mapping, enable: bool) -> Mapping {
 
         // 检查现有的 enhanced-mode 设置
         let current_mode = dns_val
-            .get(&Value::from("enhanced-mode"))
+            .get(Value::from("enhanced-mode"))
             .and_then(|v| v.as_str())
             .unwrap_or("fake-ip");
 
         // 只有当 enhanced-mode 是 fake-ip 或未设置时才修改 DNS 配置
-        if current_mode == "fake-ip" || !dns_val.contains_key(&Value::from("enhanced-mode")) {
+        if current_mode == "fake-ip" || !dns_val.contains_key(Value::from("enhanced-mode")) {
             revise!(dns_val, "enable", true);
             revise!(dns_val, "ipv6", ipv6_val);
-            
-            if !dns_val.contains_key(&Value::from("enhanced-mode")) {
+
+            if !dns_val.contains_key(Value::from("enhanced-mode")) {
                 revise!(dns_val, "enhanced-mode", "fake-ip");
             }
-            
-            if !dns_val.contains_key(&Value::from("fake-ip-range")) {
+
+            if !dns_val.contains_key(Value::from("fake-ip-range")) {
                 revise!(dns_val, "fake-ip-range", "198.18.0.1/16");
             }
 
@@ -63,7 +63,7 @@ pub async fn use_tun(mut config: Mapping, enable: bool) -> Mapping {
                 crate::utils::resolve::set_public_dns("223.6.6.6".to_string()).await;
             }
         }
-        
+
         // 当TUN启用时，将修改后的DNS配置写回
         revise!(config, "dns", dns_val);
     } else {
@@ -75,6 +75,6 @@ pub async fn use_tun(mut config: Mapping, enable: bool) -> Mapping {
     // 更新TUN配置
     revise!(tun_val, "enable", enable);
     revise!(config, "tun", tun_val);
-    
+
     config
 }

src-tauri/src/feat/backup.rs

@@ -1,7 +1,9 @@
-use crate::config::{Config, IVerge};
-use crate::core::backup;
-use crate::log_err;
-use crate::utils::dirs::app_home_dir;
+use crate::{
+    config::{Config, IVerge},
+    core::backup,
+    log_err,
+    utils::dirs::app_home_dir,
+};
 use anyhow::Result;
 use reqwest_dav::list_cmd::ListFile;
 use std::fs;

src-tauri/src/feat/clash.rs

@@ -1,8 +1,10 @@
-use crate::config::Config;
-use crate::core::{handle, tray, CoreManager};
-use crate::log_err;
-use crate::module::mihomo::MihomoManager;
-use crate::utils::resolve;
+use crate::{
+    config::Config,
+    core::{handle, tray, CoreManager},
+    log_err,
+    module::mihomo::MihomoManager,
+    utils::resolve,
+};
 use serde_yaml::{Mapping, Value};
 use tauri::Manager;
 
@@ -45,6 +47,7 @@ pub fn change_clash_mode(mode: String) {
     });
     tauri::async_runtime::spawn(async move {
         log::debug!(target: "app", "change clash mode to {mode}");
+        CoreManager::global().ensure_running_core().await;
 
         match MihomoManager::global().patch_configs(json_value).await {
             Ok(_) => {
@@ -57,13 +60,14 @@ pub fn change_clash_mode(mode: String) {
                     log_err!(tray::Tray::global().update_icon(None));
                 }
             }
-            Err(err) => log::error!(target: "app", "{err}"),
+            Err(err) => println!("{err}"),
         }
     });
 }
 
 /// Test connection delay to a URL
 pub async fn test_delay(url: String) -> anyhow::Result<u32> {
+    CoreManager::global().ensure_running_core().await;
     use tokio::time::{Duration, Instant};
     let mut builder = reqwest::ClientBuilder::new().use_rustls_tls().no_proxy();
 

src-tauri/src/feat/config.rs

@@ -1,10 +1,11 @@
-use crate::config::{Config, IVerge};
-use crate::core::{handle, hotkey, sysopt, tray, CoreManager};
-use crate::log_err;
-use crate::utils::resolve;
+use crate::{
+    config::{Config, IVerge},
+    core::{handle, hotkey, sysopt, tray, CoreManager},
+    log_err,
+    module::lightweight,
+};
 use anyhow::Result;
 use serde_yaml::Mapping;
-use tauri::Manager;
 
 /// Patch Clash configuration
 pub async fn patch_clash(patch: Mapping) -> Result<()> {
@@ -39,6 +40,23 @@ pub async fn patch_clash(patch: Mapping) -> Result<()> {
     }
 }
 
+// Define update flags as bitflags for better performance
+#[derive(Clone, Copy)]
+enum UpdateFlags {
+    None = 0,
+    RestartCore = 1 << 0,
+    ClashConfig = 1 << 1,
+    VergeConfig = 1 << 2,
+    Launch = 1 << 3,
+    SysProxy = 1 << 4,
+    SystrayIcon = 1 << 5,
+    Hotkey = 1 << 6,
+    SystrayMenu = 1 << 7,
+    SystrayTooltip = 1 << 8,
+    SystrayClickBehavior = 1 << 9,
+    LighteWeight = 1 << 10,
+}
+
 /// Patch Verge configuration
 pub async fn patch_verge(patch: IVerge, not_save_file: bool) -> Result<()> {
     Config::verge().draft().patch_config(patch.clone());
@@ -51,7 +69,6 @@ pub async fn patch_verge(patch: IVerge, not_save_file: bool) -> Result<()> {
     let proxy_bypass = patch.system_proxy_bypass;
     let language = patch.language;
     let mixed_port = patch.verge_mixed_port;
-    let lite_mode = patch.enable_lite_mode;
     #[cfg(target_os = "macos")]
     let tray_icon = patch.tray_icon;
     #[cfg(not(target_os = "macos"))]
@@ -72,35 +89,31 @@ 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();
+    let enable_auto_light_weight = patch.enable_auto_light_weight_mode;
     let res: std::result::Result<(), anyhow::Error> = {
-        let mut should_restart_core = false;
-        let mut should_update_clash_config = false;
-        let mut should_update_verge_config = false;
-        let mut should_update_launch = false;
-        let mut should_update_sysproxy = false;
-        let mut should_update_systray_icon = false;
-        let mut should_update_hotkey = false;
-        let mut should_update_systray_menu = false;
-        let mut should_update_systray_tooltip = false;
+        // Initialize with no flags set
+        let mut update_flags: i32 = UpdateFlags::None as i32;
 
         if tun_mode.is_some() {
-            should_update_clash_config = true;
-            should_update_systray_menu = true;
-            should_update_systray_tooltip = true;
-            should_update_systray_icon = true;
+            update_flags |= UpdateFlags::ClashConfig as i32;
+            update_flags |= UpdateFlags::SystrayMenu as i32;
+            update_flags |= UpdateFlags::SystrayTooltip as i32;
+            update_flags |= UpdateFlags::SystrayIcon as i32;
         }
-        if enable_global_hotkey.is_some() {
-            should_update_verge_config = true;
+        if enable_global_hotkey.is_some() || home_cards.is_some() {
+            update_flags |= UpdateFlags::VergeConfig as i32;
         }
         #[cfg(not(target_os = "windows"))]
         if redir_enabled.is_some() || redir_port.is_some() {
-            should_restart_core = true;
+            update_flags |= UpdateFlags::RestartCore as i32;
         }
         #[cfg(target_os = "linux")]
         if tproxy_enabled.is_some() || tproxy_port.is_some() {
-            should_restart_core = true;
+            update_flags |= UpdateFlags::RestartCore as i32;
         }
         if socks_enabled.is_some()
             || http_enabled.is_some()
@@ -108,91 +121,88 @@ pub async fn patch_verge(patch: IVerge, not_save_file: bool) -> Result<()> {
             || http_port.is_some()
             || mixed_port.is_some()
         {
-            should_restart_core = true;
+            update_flags |= UpdateFlags::RestartCore as i32;
         }
         if auto_launch.is_some() {
-            should_update_launch = true;
+            update_flags |= UpdateFlags::Launch as i32;
         }
 
         if system_proxy.is_some() {
-            should_update_sysproxy = true;
-            should_update_systray_menu = true;
-            should_update_systray_tooltip = true;
-            should_update_systray_icon = true;
+            update_flags |= UpdateFlags::SysProxy as i32;
+            update_flags |= UpdateFlags::SystrayMenu as i32;
+            update_flags |= UpdateFlags::SystrayTooltip as i32;
+            update_flags |= UpdateFlags::SystrayIcon as i32;
         }
 
         if proxy_bypass.is_some() || pac_content.is_some() || pac.is_some() {
-            should_update_sysproxy = true;
+            update_flags |= UpdateFlags::SysProxy as i32;
         }
 
         if language.is_some() {
-            should_update_systray_menu = true;
+            update_flags |= UpdateFlags::SystrayMenu as i32;
         }
         if common_tray_icon.is_some()
             || sysproxy_tray_icon.is_some()
             || tun_tray_icon.is_some()
             || tray_icon.is_some()
+            || enable_tray_speed.is_some()
+            || enable_tray_icon.is_some()
         {
-            should_update_systray_icon = true;
+            update_flags |= UpdateFlags::SystrayIcon as i32;
         }
 
         if patch.hotkeys.is_some() {
-            should_update_hotkey = true;
-            should_update_systray_menu = true;
+            update_flags |= UpdateFlags::Hotkey as i32;
+            update_flags |= UpdateFlags::SystrayMenu as i32;
         }
 
-        if enable_tray_speed.is_some() {
-            should_update_systray_icon = true;
+        if tray_event.is_some() {
+            update_flags |= UpdateFlags::SystrayClickBehavior as i32;
         }
 
-        if should_restart_core {
+        if enable_auto_light_weight.is_some() {
+            update_flags |= UpdateFlags::LighteWeight as i32;
+        }
+
+        // Process updates based on flags
+        if (update_flags & (UpdateFlags::RestartCore as i32)) != 0 {
+            Config::generate().await?;
             CoreManager::global().restart_core().await?;
         }
-        if should_update_clash_config {
+        if (update_flags & (UpdateFlags::ClashConfig as i32)) != 0 {
             CoreManager::global().update_config().await?;
             handle::Handle::refresh_clash();
         }
-        if should_update_verge_config {
+        if (update_flags & (UpdateFlags::VergeConfig as i32)) != 0 {
             Config::verge().draft().enable_global_hotkey = enable_global_hotkey;
             handle::Handle::refresh_verge();
         }
-        if should_update_launch {
+        if (update_flags & (UpdateFlags::Launch as i32)) != 0 {
             sysopt::Sysopt::global().update_launch()?;
         }
-
-        if should_update_sysproxy {
+        if (update_flags & (UpdateFlags::SysProxy as i32)) != 0 {
             sysopt::Sysopt::global().update_sysproxy().await?;
         }
-
-        if should_update_hotkey {
+        if (update_flags & (UpdateFlags::Hotkey as i32)) != 0 {
             hotkey::Hotkey::global().update(patch.hotkeys.unwrap())?;
         }
-
-        if should_update_systray_menu {
+        if (update_flags & (UpdateFlags::SystrayMenu as i32)) != 0 {
             tray::Tray::global().update_menu()?;
         }
-
-        if should_update_systray_icon {
+        if (update_flags & (UpdateFlags::SystrayIcon as i32)) != 0 {
             tray::Tray::global().update_icon(None)?;
         }
-
-        if should_update_systray_tooltip {
+        if (update_flags & (UpdateFlags::SystrayTooltip as i32)) != 0 {
             tray::Tray::global().update_tooltip()?;
         }
-
-        // 处理轻量模式切换
-        if lite_mode.is_some() {
-            if let Some(window) = handle::Handle::global().get_window() {
-                if lite_mode.unwrap() {
-                    // 完全退出 webview 进程
-                    window.close()?; // 先关闭窗口
-                    let app_handle = handle::Handle::global().app_handle().unwrap();
-                    if let Some(webview) = app_handle.get_webview_window("main") {
-                        webview.destroy()?; // 销毁 webview 进程
-                    }
-                } else {
-                    resolve::create_window(); // 重新创建窗口
-                }
+        if (update_flags & (UpdateFlags::SystrayClickBehavior as i32)) != 0 {
+            tray::Tray::global().update_click_behavior()?;
+        }
+        if (update_flags & (UpdateFlags::LighteWeight as i32)) != 0 {
+            if enable_auto_light_weight.unwrap() {
+                lightweight::enable_auto_light_weight_mode();
+            } else {
+                lightweight::disable_auto_light_weight_mode();
             }
         }
 

src-tauri/src/feat/profile.rs

@@ -1,8 +1,8 @@
-use crate::cmd;
-use crate::config::{Config, PrfItem, PrfOption};
-use crate::core::handle;
-use crate::core::CoreManager;
-use crate::core::*;
+use crate::{
+    cmd,
+    config::{Config, PrfItem, PrfOption},
+    core::{handle, CoreManager, *},
+};
 use anyhow::{bail, Result};
 
 /// Toggle proxy profile
@@ -29,7 +29,7 @@ pub async fn update_profile(uid: String, option: Option<PrfOption>) -> Result<()
         let profiles = Config::profiles();
         let profiles = profiles.latest();
         let item = profiles.get_item(&uid)?;
-        let is_remote = item.itype.as_ref().map_or(false, |s| s == "remote");
+        let is_remote = item.itype.as_ref().is_some_and(|s| s == "remote");
 
         if !is_remote {
             println!("[订阅更新] {} 不是远程订阅，跳过更新", uid);

src-tauri/src/feat/proxy.rs

@@ -1,6 +1,7 @@
-use crate::config::Config;
-use crate::config::IVerge;
-use crate::core::handle;
+use crate::{
+    config::{Config, IVerge},
+    core::handle,
+};
 use std::env;
 use tauri_plugin_clipboard_manager::ClipboardExt;
 
@@ -72,10 +73,16 @@ pub fn copy_clash_env() {
     };
 
     let export_text = match env_type.as_str() {
-        "bash" => format!("export https_proxy={http_proxy} http_proxy={http_proxy} all_proxy={socks5_proxy}"),
+        "bash" => format!(
+            "export https_proxy={http_proxy} http_proxy={http_proxy} all_proxy={socks5_proxy}"
+        ),
         "cmd" => format!("set http_proxy={http_proxy}\r\nset https_proxy={http_proxy}"),
-        "powershell" => format!("$env:HTTP_PROXY=\"{http_proxy}\"; $env:HTTPS_PROXY=\"{http_proxy}\""),
-        "nushell" => format!("load-env {{ http_proxy: \"{http_proxy}\", https_proxy: \"{http_proxy}\" }}"),
+        "powershell" => {
+            format!("$env:HTTP_PROXY=\"{http_proxy}\"; $env:HTTPS_PROXY=\"{http_proxy}\"")
+        }
+        "nushell" => {
+            format!("load-env {{ http_proxy: \"{http_proxy}\", https_proxy: \"{http_proxy}\" }}")
+        }
         "fish" => format!("set -x http_proxy {http_proxy}; set -x https_proxy {http_proxy}"),
         _ => {
             log::error!(target: "app", "copy_clash_env: Invalid env type! {env_type}");
@@ -83,7 +90,7 @@ pub fn copy_clash_env() {
         }
     };
 
-    if let Err(_) = cliboard.write_text(export_text) {
+    if cliboard.write_text(export_text).is_err() {
         log::error!(target: "app", "Failed to write to clipboard");
     }
 }

src-tauri/src/feat/window.rs

@@ -1,9 +1,11 @@
-use crate::config::Config;
-use crate::core::handle;
-use crate::core::{sysopt, CoreManager};
-use crate::module::mihomo::MihomoManager;
-use crate::utils::resolve;
-use futures;
+#[cfg(target_os = "macos")]
+use crate::AppHandleManager;
+use crate::{
+    config::Config,
+    core::{handle, sysopt, CoreManager},
+    module::mihomo::MihomoManager,
+    utils::resolve,
+};
 use tauri::Manager;
 use tauri_plugin_window_state::{AppHandleExt, StateFlags};
 
@@ -137,3 +139,13 @@ pub fn quit(code: Option<i32>) {
         app_handle.exit(code.unwrap_or(0));
     });
 }
+
+#[cfg(target_os = "macos")]
+pub fn hide() {
+    if let Some(window) = handle::Handle::global().get_window() {
+        if window.is_visible().unwrap_or(false) {
+            AppHandleManager::global().set_activation_policy_accessory();
+            let _ = window.hide();
+        }
+    }
+}

src-tauri/src/lib.rs

@@ -3,17 +3,19 @@ mod config;
 mod core;
 mod enhance;
 mod feat;
-mod utils;
 mod module;
-use crate::core::hotkey;
-use crate::utils::{resolve, resolve::resolve_scheme, server};
+mod utils;
+use crate::{
+    core::hotkey,
+    utils::{resolve, resolve::resolve_scheme, server},
+};
 use config::Config;
-use tauri_plugin_autostart::MacosLauncher;
-use tauri_plugin_deep_link::DeepLinkExt;
 use std::sync::{Mutex, Once};
 use tauri::AppHandle;
 #[cfg(target_os = "macos")]
 use tauri::Manager;
+use tauri_plugin_autostart::MacosLauncher;
+use tauri_plugin_deep_link::DeepLinkExt;
 
 /// A global singleton handle to the application.
 pub struct AppHandleManager {
@@ -57,7 +59,7 @@ impl AppHandleManager {
             let _ = app_handle.set_activation_policy(tauri::ActivationPolicy::Regular);
         }
     }
-    
+
     pub fn set_activation_policy_accessory(&self) {
         #[cfg(target_os = "macos")]
         {
@@ -66,7 +68,7 @@ impl AppHandleManager {
             let _ = app_handle.set_activation_policy(tauri::ActivationPolicy::Accessory);
         }
     }
-    
+
     pub fn set_activation_policy_prohibited(&self) {
         #[cfg(target_os = "macos")]
         {
@@ -77,6 +79,7 @@ impl AppHandleManager {
     }
 }
 
+#[allow(clippy::panic)]
 pub fn run() {
     // 单例检测
     let app_exists: bool = tauri::async_runtime::block_on(async move {
@@ -96,7 +99,6 @@ pub fn run() {
 
     #[cfg(debug_assertions)]
     let devtools = tauri_plugin_devtools::init();
-
     #[allow(unused_mut)]
     let mut builder = tauri::Builder::default()
         .plugin(tauri_plugin_autostart::init(
@@ -150,6 +152,9 @@ pub fn run() {
             // 添加新的命令
             cmd::get_running_mode,
             cmd::install_service,
+            cmd::repair_service,
+            cmd::get_app_uptime,
+            cmd::get_auto_launch_status,
             // clash
             cmd::get_clash_info,
             cmd::patch_clash_config,
@@ -203,6 +208,13 @@ pub fn run() {
             cmd::restore_webdav_backup,
             // export diagnostic info for issue reporting
             cmd::export_diagnostic_info,
+            // get system info for display
+            cmd::get_system_info,
+            // media unlock checker
+            cmd::get_unlock_items,
+            cmd::check_media_unlock,
+            // light-weight model
+            cmd::entry_lightweight_mode,
         ]);
 
     #[cfg(debug_assertions)]
@@ -210,6 +222,12 @@ pub fn run() {
         builder = builder.plugin(devtools);
     }
 
+    // Macos Application Menu
+    #[cfg(target_os = "macos")]
+    {
+        // Temporary Achived due to cannot CMD+C/V/A
+    }
+
     let app = builder
         .build(tauri::generate_context!())
         .expect("error while running tauri application");
@@ -219,12 +237,19 @@ pub fn run() {
             AppHandleManager::global().init(app_handle.clone());
             #[cfg(target_os = "macos")]
             {
-                let main_window = AppHandleManager::global().get_handle().get_webview_window("main").unwrap();
-                let _ = main_window.set_title("Clash Verge");
+                if let Some(window) = AppHandleManager::global()
+                    .get_handle()
+                    .get_webview_window("main")
+                {
+                    let _ = window.set_title("Clash Verge");
+                }
             }
         }
         #[cfg(target_os = "macos")]
-        tauri::RunEvent::Reopen { has_visible_windows, .. } => {
+        tauri::RunEvent::Reopen {
+            has_visible_windows,
+            ..
+        } => {
             if !has_visible_windows {
                 AppHandleManager::global().set_activation_policy_regular();
             }
@@ -253,14 +278,18 @@ pub fn run() {
                         #[cfg(target_os = "macos")]
                         {
                             log_err!(hotkey::Hotkey::global().register("CMD+Q", "quit"));
+                            log_err!(hotkey::Hotkey::global().register("CMD+W", "hide"));
                         }
 
                         #[cfg(not(target_os = "macos"))]
                         {
                             log_err!(hotkey::Hotkey::global().register("Control+Q", "quit"));
                         };
-                        {   
-                            let is_enable_global_hotkey = Config::verge().latest().enable_global_hotkey.unwrap_or(true);
+                        {
+                            let is_enable_global_hotkey = Config::verge()
+                                .latest()
+                                .enable_global_hotkey
+                                .unwrap_or(true);
                             if !is_enable_global_hotkey {
                                 log_err!(hotkey::Hotkey::global().init())
                             }
@@ -270,13 +299,17 @@ pub fn run() {
                         #[cfg(target_os = "macos")]
                         {
                             log_err!(hotkey::Hotkey::global().unregister("CMD+Q"));
+                            log_err!(hotkey::Hotkey::global().unregister("CMD+W"));
                         }
                         #[cfg(not(target_os = "macos"))]
                         {
                             log_err!(hotkey::Hotkey::global().unregister("Control+Q"));
                         };
-                        {   
-                            let is_enable_global_hotkey = Config::verge().latest().enable_global_hotkey.unwrap_or(true);
+                        {
+                            let is_enable_global_hotkey = Config::verge()
+                                .latest()
+                                .enable_global_hotkey
+                                .unwrap_or(true);
                             if !is_enable_global_hotkey {
                                 log_err!(hotkey::Hotkey::global().reset())
                             }
@@ -286,6 +319,7 @@ pub fn run() {
                         #[cfg(target_os = "macos")]
                         {
                             log_err!(hotkey::Hotkey::global().unregister("CMD+Q"));
+                            log_err!(hotkey::Hotkey::global().unregister("CMD+W"));
                         }
 
                         #[cfg(not(target_os = "macos"))]

src-tauri/src/module/lightweight.rs

@@ -0,0 +1,141 @@
+use anyhow::{Context, Result};
+use delay_timer::prelude::TaskBuilder;
+use tauri::{Listener, Manager};
+
+use crate::{
+    config::Config,
+    core::{handle, timer::Timer},
+    log_err, 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] 开启自动轻量模式");
+    setup_window_close_listener();
+    setup_webview_focus_listener();
+}
+
+pub fn disable_auto_light_weight_mode() {
+    println!("[lightweight_mode] 关闭自动轻量模式");
+    log::info!(target: "app", "[lightweight_mode] 关闭自动轻量模式");
+    let _ = cancel_light_weight_timer();
+    cancel_window_close_listener();
+}
+
+pub fn entry_lightweight_mode() {
+    if let Some(window) = handle::Handle::global().get_window() {
+        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();
+        println!("[lightweight_mode] 轻量模式已开启");
+        log::info!(target: "app", "[lightweight_mode] 轻量模式已开启");
+    }
+    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] 监听到关闭请求，开始轻量模式计时");
+        });
+        return handler;
+    }
+    0
+}
+
+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] 监听到窗口获得焦点，取消轻量模式计时");
+        });
+        return handler;
+    }
+    0
+}
+
+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] 取消了窗口关闭监听");
+    }
+}
+
+fn setup_light_weight_timer() -> Result<()> {
+    Timer::global().init()?;
+
+    let mut timer_map = Timer::global().timer_map.write();
+    let delay_timer = Timer::global().delay_timer.write();
+    let mut timer_count = Timer::global().timer_count.lock();
+
+    let task_id = *timer_count;
+    *timer_count += 1;
+
+    let once_by_minutes = Config::verge()
+        .latest()
+        .auto_light_weight_minutes
+        .clone()
+        .unwrap_or(10);
+
+    let task = TaskBuilder::default()
+        .set_task_id(task_id)
+        .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] 计时器到期，开始进入轻量模式"
+            );
+            entry_lightweight_mode();
+        })
+        .context("failed to create light weight timer task")?;
+
+    delay_timer
+        .add_task(task)
+        .context("failed to add light weight timer task")?;
+
+    let timer_task = crate::core::timer::TimerTask {
+        task_id,
+        interval_minutes: once_by_minutes,
+        last_run: chrono::Local::now().timestamp(),
+    };
+
+    timer_map.insert(LIGHT_WEIGHT_TASK_UID.to_string(), timer_task);
+
+    println!(
+        "[lightweight_mode] 轻量模式计时器已设置，{} 分钟后将自动进入轻量模式",
+        once_by_minutes
+    );
+    log::info!(target: "app",
+        "[lightweight_mode] 轻量模式计时器已设置，{} 分钟后将自动进入轻量模式",
+        once_by_minutes
+    );
+
+    Ok(())
+}
+
+fn cancel_light_weight_timer() -> Result<()> {
+    let mut timer_map = Timer::global().timer_map.write();
+    let delay_timer = Timer::global().delay_timer.write();
+
+    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")?;
+        println!("[lightweight_mode] 轻量模式计时器已取消");
+        log::info!(target: "app", "[lightweight_mode] 轻量模式计时器已取消");
+    }
+
+    Ok(())
+}

src-tauri/src/module/mihomo.rs

@@ -65,6 +65,6 @@ impl MihomoManager {
             .unwrap()
             .to_string();
         let token = http::header::HeaderValue::from_str(&auth).unwrap();
-        return (ws_url, token);
+        (ws_url, token)
     }
 }

src-tauri/src/module/mod.rs

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

src-tauri/src/module/sysinfo.rs

@@ -26,7 +26,7 @@ impl PlatformSpecification {
         let system_name = System::name().unwrap_or("Null".into());
         let system_version = System::long_os_version().unwrap_or("Null".into());
         let system_kernel_version = System::kernel_version().unwrap_or("Null".into());
-        let system_arch = std::env::consts::ARCH.to_string();
+        let system_arch = System::cpu_arch();
 
         let handler = handle::Handle::global().app_handle().unwrap();
         let config = handler.config();
@@ -43,7 +43,6 @@ impl PlatformSpecification {
             })
         });
 
-
         Self {
             system_name,
             system_version,

src-tauri/src/utils/dirs.rs

@@ -1,8 +1,7 @@
 use crate::core::handle;
 use anyhow::Result;
 use once_cell::sync::OnceCell;
-use std::fs;
-use std::path::PathBuf;
+use std::{fs, path::PathBuf};
 use tauri::Manager;
 
 #[cfg(not(feature = "verge-dev"))]

src-tauri/src/utils/help.rs

@@ -207,7 +207,7 @@ macro_rules! t {
 /// # Examples
 /// ```not_run
 /// format_bytes_speed(1000) // returns "1000B/s"
-/// format_bytes_speed(1024) // returns "1.0KB/s" 
+/// format_bytes_speed(1024) // returns "1.0KB/s"
 /// format_bytes_speed(1024 * 1024) // returns "1.0MB/s"
 /// ```
 /// ```

src-tauri/src/utils/i18n.rs

@@ -1,5 +1,4 @@
-use crate::config::Config;
-use crate::utils::dirs;
+use crate::{config::Config, utils::dirs};
 use once_cell::sync::Lazy;
 use serde_json::Value;
 use std::{collections::HashMap, fs, path::PathBuf};

src-tauri/src/utils/init.rs

@@ -1,16 +1,21 @@
-use crate::config::*;
-use crate::core::handle;
-use crate::utils::{dirs, help};
+use crate::{
+    config::*,
+    core::handle,
+    utils::{dirs, help},
+};
 use anyhow::Result;
 use chrono::{Local, TimeZone};
 use log::LevelFilter;
-use log4rs::append::console::ConsoleAppender;
-use log4rs::append::file::FileAppender;
-use log4rs::config::{Appender, Logger, Root};
-use log4rs::encode::pattern::PatternEncoder;
-use std::fs::{self, DirEntry};
-use std::path::PathBuf;
-use std::str::FromStr;
+use log4rs::{
+    append::{console::ConsoleAppender, file::FileAppender},
+    config::{Appender, Logger, Root},
+    encode::pattern::PatternEncoder,
+};
+use std::{
+    fs::{self, DirEntry},
+    path::PathBuf,
+    str::FromStr,
+};
 use tauri_plugin_shell::ShellExt;
 
 /// initialize this instance's log file
@@ -142,69 +147,106 @@ fn init_dns_config() -> Result<()> {
         ("enable".into(), Value::Bool(true)),
         ("listen".into(), Value::String(":53".into())),
         ("enhanced-mode".into(), Value::String("fake-ip".into())),
-        ("fake-ip-range".into(), Value::String("198.18.0.1/16".into())),
-        ("fake-ip-filter-mode".into(), Value::String("blacklist".into())),
+        (
+            "fake-ip-range".into(),
+            Value::String("198.18.0.1/16".into()),
+        ),
+        (
+            "fake-ip-filter-mode".into(),
+            Value::String("blacklist".into()),
+        ),
         ("prefer-h3".into(), Value::Bool(false)),
         ("respect-rules".into(), Value::Bool(false)),
         ("use-hosts".into(), Value::Bool(false)),
         ("use-system-hosts".into(), Value::Bool(false)),
-        ("fake-ip-filter".into(), Value::Sequence(vec![
-            Value::String("*.lan".into()),
-            Value::String("*.local".into()),
-            Value::String("*.arpa".into()),
-            Value::String("time.*.com".into()),
-            Value::String("ntp.*.com".into()),
-            Value::String("time.*.com".into()),
-            Value::String("+.market.xiaomi.com".into()),
-            Value::String("localhost.ptlogin2.qq.com".into()),
-            Value::String("*.msftncsi.com".into()),
-            Value::String("www.msftconnecttest.com".into()),
-        ])),
-        ("default-nameserver".into(), Value::Sequence(vec![
-            Value::String("223.6.6.6".into()),
-            Value::String("8.8.8.8".into()),
-        ])),
-        ("nameserver".into(), Value::Sequence(vec![
-            Value::String("8.8.8.8".into()),
-            Value::String("https://doh.pub/dns-query".into()),
-            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()),
-        ])),
-        ("nameserver-policy".into(), Value::Mapping(serde_yaml::Mapping::new())),
-        ("proxy-server-nameserver".into(), Value::Sequence(vec![
-            Value::String("https://doh.pub/dns-query".into()),
-            Value::String("https://dns.alidns.com/dns-query".into()),
-        ])),
+        (
+            "fake-ip-filter".into(),
+            Value::Sequence(vec![
+                Value::String("*.lan".into()),
+                Value::String("*.local".into()),
+                Value::String("*.arpa".into()),
+                Value::String("time.*.com".into()),
+                Value::String("ntp.*.com".into()),
+                Value::String("time.*.com".into()),
+                Value::String("+.market.xiaomi.com".into()),
+                Value::String("localhost.ptlogin2.qq.com".into()),
+                Value::String("*.msftncsi.com".into()),
+                Value::String("www.msftconnecttest.com".into()),
+            ]),
+        ),
+        (
+            "default-nameserver".into(),
+            Value::Sequence(vec![
+                Value::String("223.6.6.6".into()),
+                Value::String("8.8.8.8".into()),
+            ]),
+        ),
+        (
+            "nameserver".into(),
+            Value::Sequence(vec![
+                Value::String("8.8.8.8".into()),
+                Value::String("https://doh.pub/dns-query".into()),
+                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()),
+            ]),
+        ),
+        (
+            "nameserver-policy".into(),
+            Value::Mapping(serde_yaml::Mapping::new()),
+        ),
+        (
+            "proxy-server-nameserver".into(),
+            Value::Sequence(vec![
+                Value::String("https://doh.pub/dns-query".into()),
+                Value::String("https://dns.alidns.com/dns-query".into()),
+            ]),
+        ),
         ("direct-nameserver".into(), Value::Sequence(vec![])),
         ("direct-nameserver-follow-policy".into(), Value::Bool(false)),
-        ("fallback-filter".into(), Value::Mapping(serde_yaml::Mapping::from_iter([
-            ("geoip".into(), Value::Bool(true)),
-            ("geoip-code".into(), Value::String("CN".into())),
-            ("ipcidr".into(), Value::Sequence(vec![
-                Value::String("240.0.0.0/4".into()),
-                Value::String("0.0.0.0/32".into()),
+        (
+            "fallback-filter".into(),
+            Value::Mapping(serde_yaml::Mapping::from_iter([
+                ("geoip".into(), Value::Bool(true)),
+                ("geoip-code".into(), Value::String("CN".into())),
+                (
+                    "ipcidr".into(),
+                    Value::Sequence(vec![
+                        Value::String("240.0.0.0/4".into()),
+                        Value::String("0.0.0.0/32".into()),
+                    ]),
+                ),
+                (
+                    "domain".into(),
+                    Value::Sequence(vec![
+                        Value::String("+.google.com".into()),
+                        Value::String("+.facebook.com".into()),
+                        Value::String("+.youtube.com".into()),
+                    ]),
+                ),
             ])),
-            ("domain".into(), Value::Sequence(vec![
-                Value::String("+.google.com".into()),
-                Value::String("+.facebook.com".into()),
-                Value::String("+.youtube.com".into()),
-            ])),
-        ]))),
+        ),
     ]);
 
     // 检查DNS配置文件是否存在
     let app_dir = dirs::app_home_dir()?;
     let dns_path = app_dir.join("dns_config.yaml");
-    
+
     if !dns_path.exists() {
         log::info!(target: "app", "Creating default DNS config file");
-        help::save_yaml(&dns_path, &default_dns_config, Some("# Clash Verge DNS Config"))?;
+        help::save_yaml(
+            &dns_path,
+            &default_dns_config,
+            Some("# Clash Verge DNS Config"),
+        )?;
     }
-    
+
     Ok(())
 }
 
@@ -323,8 +365,7 @@ pub fn init_resources() -> Result<()> {
 #[cfg(target_os = "windows")]
 pub fn init_scheme() -> Result<()> {
     use tauri::utils::platform::current_exe;
-    use winreg::enums::*;
-    use winreg::RegKey;
+    use winreg::{enums::*, RegKey};
 
     let app_exe = current_exe()?;
     let app_exe = dunce::canonicalize(app_exe)?;

src-tauri/src/utils/mod.rs

@@ -1,8 +1,8 @@
 pub mod dirs;
 pub mod error;
 pub mod help;
+pub mod i18n;
 pub mod init;
 pub mod resolve;
 pub mod server;
 pub mod tmpl;
-pub mod i18n;

src-tauri/src/utils/resolve.rs

@@ -1,9 +1,8 @@
-use crate::config::IVerge;
-use crate::utils::error;
-use crate::{config::Config, config::PrfItem, core::*, utils::init, utils::server};
-use crate::{log_err, wrap_err};
 #[cfg(target_os = "macos")]
 use crate::AppHandleManager;
+use crate::{
+    config::{Config, IVerge, PrfItem}, core::*, log_err, module::lightweight, utils::{error, init, server}, wrap_err
+};
 use anyhow::{bail, Result};
 use once_cell::sync::OnceCell;
 use percent_encoding::percent_decode_str;
@@ -96,7 +95,7 @@ pub async fn resolve_setup(app: &mut App) {
 
     log::trace!(target: "app", "init system tray");
     log_err!(tray::Tray::global().init());
-    log_err!(tray::Tray::global().create_systray());
+    log_err!(tray::Tray::global().create_systray(app));
 
     log_err!(sysopt::Sysopt::global().update_sysproxy().await);
     log_err!(sysopt::Sysopt::global().init_guard_sysproxy());
@@ -112,6 +111,11 @@ pub async fn resolve_setup(app: &mut App) {
 
     log_err!(tray::Tray::global().update_part());
     log_err!(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();
+    }
 }
 
 /// reset system proxy
@@ -201,7 +205,7 @@ pub fn create_window() {
             log::info!(target: "app", "Window created successfully, attempting to show");
             let _ = window.show();
             let _ = window.set_focus();
-            
+
             // 设置窗口状态监控，实时保存窗口位置和大小
             crate::feat::setup_window_state_monitor(&app_handle);
         }
@@ -315,8 +319,7 @@ fn resolve_random_port_config() -> Result<()> {
 
 #[cfg(target_os = "macos")]
 pub async fn set_public_dns(dns_server: String) {
-    use crate::core::handle;
-    use crate::utils::dirs;
+    use crate::{core::handle, utils::dirs};
     use tauri_plugin_shell::ShellExt;
     let app_handle = handle::Handle::global().app_handle().unwrap();
 
@@ -352,8 +355,7 @@ pub async fn set_public_dns(dns_server: String) {
 
 #[cfg(target_os = "macos")]
 pub async fn restore_public_dns() {
-    use crate::core::handle;
-    use crate::utils::dirs;
+    use crate::{core::handle, utils::dirs};
     use tauri_plugin_shell::ShellExt;
     let app_handle = handle::Handle::global().app_handle().unwrap();
     log::info!(target: "app", "try to unset system dns");

src-tauri/src/utils/server.rs

@@ -1,8 +1,10 @@
 extern crate warp;
 
 use super::resolve;
-use crate::config::{Config, IVerge, DEFAULT_PAC};
-use crate::log_err;
+use crate::{
+    config::{Config, IVerge, DEFAULT_PAC},
+    log_err,
+};
 use anyhow::{bail, Result};
 use port_scanner::local_port_available;
 use std::convert::Infallible;

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

@@ -1,4 +1,4 @@
-use reqwest::header::HeaderMap;
+use reqwest::{Method, header::HeaderMap};
 use serde_json::json;
 use std::{
     sync::{Arc, Mutex},
@@ -15,7 +15,7 @@ impl MihomoManager {
                 proxies: serde_json::Value::Null,
                 providers_proxies: serde_json::Value::Null,
             })),
-            headers: headers,
+            headers,
         }
     }
 
@@ -45,68 +45,77 @@ impl MihomoManager {
 
     async fn send_request(
         &self,
-        method: &str,
+        method: Method,
         url: String,
         data: Option<serde_json::Value>,
     ) -> Result<serde_json::Value, String> {
         let client_response = reqwest::ClientBuilder::new()
             .default_headers(self.headers.clone())
             .no_proxy()
-            .timeout(Duration::from_secs(2))
+            .timeout(Duration::from_secs(60))
             .build()
             .map_err(|e| e.to_string())?
-            .request(
-                match method {
-                    "GET" => reqwest::Method::GET,
-                    "PUT" => reqwest::Method::PUT,
-                    "POST" => reqwest::Method::POST,
-                    "PATCH" => reqwest::Method::PATCH,
-                    _ => reqwest::Method::GET,
-                },
-                &url,
-            )
+            .request(method.clone(), &url)
             .json(&data.unwrap_or(json!({})))
             .send()
             .await
             .map_err(|e| e.to_string())?;
 
-        let response = if method != "PUT" {
-            client_response.json::<serde_json::Value>().await
-        } else {
-            client_response.text().await.map(|text| json!(text))
-        }
-        .map_err(|e| e.to_string())?;
-        return Ok(response);
+        let response = match method {
+            Method::PATCH => {
+                let status = client_response.status();
+                if status.as_u16() == 204 {
+                    json!({"code": 204})
+                } else {
+                    client_response
+                        .json::<serde_json::Value>()
+                        .await
+                        .map_err(|e| e.to_string())?
+                }
+            }
+            Method::PUT => json!(client_response.text().await.map_err(|e| e.to_string())?),
+            _ => client_response
+                .json::<serde_json::Value>()
+                .await
+                .map_err(|e| e.to_string())?,
+        };
+        Ok(response)
     }
 
     pub async fn refresh_proxies(&self) -> Result<&Self, String> {
         let url = format!("{}/proxies", self.mihomo_server);
-        let proxies = self.send_request("GET", url, None).await?;
+        let proxies = self.send_request(Method::GET, url, None).await?;
         self.update_proxies(proxies);
         Ok(self)
     }
 
     pub async fn refresh_providers_proxies(&self) -> Result<&Self, String> {
         let url = format!("{}/providers/proxies", self.mihomo_server);
-        let providers_proxies = self.send_request("GET", url, None).await?;
+        let providers_proxies = self.send_request(Method::GET, url, None).await?;
         self.update_providers_proxies(providers_proxies);
         Ok(self)
     }
 }
 
 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!({
             "path": clash_config_path,
         });
-        let _response = self.send_request("PUT", url, Some(payload)).await?;
+        let _response = self.send_request(Method::PUT, url, Some(payload)).await?;
         Ok(())
     }
 
     pub async fn patch_configs(&self, config: serde_json::Value) -> Result<(), String> {
         let url = format!("{}/configs", self.mihomo_server);
-        let response = self.send_request("PATCH", url, Some(config)).await?;
+        let response = self.send_request(Method::PATCH, url, Some(config)).await?;
         if response["code"] == 204 {
             Ok(())
         } else {
@@ -128,7 +137,7 @@ impl MihomoManager {
             "{}/proxies/{}/delay?url={}&timeout={}",
             self.mihomo_server, name, test_url, timeout
         );
-        let response = self.send_request("GET", url, None).await?;
-        return Ok(response);
+        let response = self.send_request(Method::GET, url, None).await?;
+        Ok(response)
     }
 }

src-tauri/tauri.conf.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.1.3-alpha",
+  "version": "2.2.2",
   "$schema": "../node_modules/@tauri-apps/cli/config.schema.json",
   "bundle": {
     "active": true,
@@ -32,7 +32,11 @@
       "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IEQyOEMyRjBCQkVGOUJEREYKUldUZnZmbStDeStNMHU5Mmo1N24xQXZwSVRYbXA2NUpzZE5oVzlqeS9Bc0t6RVV4MmtwVjBZaHgK",
       "endpoints": [
         "https://download.clashverge.dev/https://github.com/clash-verge-rev/clash-verge-rev/releases/download/updater/update-proxy.json",
-        "https://github.com/clash-verge-rev/clash-verge-rev/releases/download/updater/update.json"
+        "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": {
         "installMode": "basicUi"

src-tauri/tauri.linux.conf.json

@@ -30,10 +30,5 @@
       "./sidecar/verge-mihomo",
       "./sidecar/verge-mihomo-alpha"
     ]
-  },
-  "app": {
-    "trayIcon": {
-      "iconPath": "icons/tray-icon.ico"
-    }
   }
 }

src-tauri/tauri.macos.conf.json

@@ -30,11 +30,5 @@
         }
       }
     }
-  },
-  "app": {
-    "trayIcon": {
-      "iconPath": "icons/tray-icon-mono.ico",
-      "iconAsTemplate": true
-    }
   }
 }

src-tauri/tauri.windows.conf.json

@@ -21,11 +21,6 @@
     }
   },
   "app": {
-    "trayIcon": {
-      "iconPath": "icons/tray-icon.ico",
-      "iconAsTemplate": true,
-      "showMenuOnLeftClick": false
-    },
     "windows": []
   }
 }

src-tauri/webview2.arm64.json

@@ -30,11 +30,5 @@
       ],
       "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IEQyOEMyRjBCQkVGOUJEREYKUldUZnZmbStDeStNMHU5Mmo1N24xQXZwSVRYbXA2NUpzZE5oVzlqeS9Bc0t6RVV4MmtwVjBZaHgK"
     }
-  },
-  "app": {
-    "trayIcon": {
-      "iconPath": "icons/tray-icon.ico",
-      "iconAsTemplate": true
-    }
   }
 }

src-tauri/webview2.x64.json

@@ -30,11 +30,5 @@
       ],
       "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IEQyOEMyRjBCQkVGOUJEREYKUldUZnZmbStDeStNMHU5Mmo1N24xQXZwSVRYbXA2NUpzZE5oVzlqeS9Bc0t6RVV4MmtwVjBZaHgK"
     }
-  },
-  "app": {
-    "trayIcon": {
-      "iconPath": "icons/tray-icon.ico",
-      "iconAsTemplate": true
-    }
   }
 }

src-tauri/webview2.x86.json

@@ -30,11 +30,5 @@
       ],
       "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IEQyOEMyRjBCQkVGOUJEREYKUldUZnZmbStDeStNMHU5Mmo1N24xQXZwSVRYbXA2NUpzZE5oVzlqeS9Bc0t6RVV4MmtwVjBZaHgK"
     }
-  },
-  "app": {
-    "trayIcon": {
-      "iconPath": "icons/tray-icon.ico",
-      "iconAsTemplate": true
-    }
   }
 }

src/assets/image/itemicon/unlock.svg

@@ -0,0 +1,10 @@
+<svg width="36" height="36" viewBox="0 0 36 36" fill="none" xmlns="http://www.w3.org/2000/svg">
+<rect width="36" height="36" rx="18" fill="url(#paint0_linear_3004_316)"/>
+<path d="M23 14.6666H22.1667V13C22.1667 10.7 20.3 8.83331 18 8.83331C15.7 8.83331 13.8334 10.7 13.8334 13H15.5C15.5 11.6166 16.6167 10.5 18 10.5C19.3834 10.5 20.5 11.6166 20.5 13V14.6666H13C12.0834 14.6666 11.3334 15.4166 11.3334 16.3333V24.6666C11.3334 25.5833 12.0834 26.3333 13 26.3333H23C23.9167 26.3333 24.6667 25.5833 24.6667 24.6666V16.3333C24.6667 15.4166 23.9167 14.6666 23 14.6666ZM23 24.6666H13V16.3333H23V24.6666ZM18 22.1666C18.9167 22.1666 19.6667 21.4166 19.6667 20.5C19.6667 19.5833 18.9167 18.8333 18 18.8333C17.0834 18.8333 16.3334 19.5833 16.3334 20.5C16.3334 21.4166 17.0834 22.1666 18 22.1666Z" fill="white"/>
+<defs>
+<linearGradient id="paint0_linear_3004_316" x1="31" y1="27.5" x2="6.5" y2="7" gradientUnits="userSpaceOnUse">
+<stop stop-color="#FFA800"/>
+<stop offset="1" stop-color="#FFAC4B"/>
+</linearGradient>
+</defs>
+</svg>

src/components/center.tsx

@@ -0,0 +1,21 @@
+import { Box, BoxProps } from "@mui/material";
+import React from "react";
+
+interface CenterProps extends BoxProps {
+  children: React.ReactNode;
+}
+
+export const Center: React.FC<CenterProps> = ({ children, ...props }) => {
+  return (
+    <Box
+      display="flex"
+      justifyContent="center"
+      alignItems="center"
+      width="100%"
+      height="100%"
+      {...props}
+    >
+      {children}
+    </Box>
+  );
+};

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

@@ -0,0 +1,114 @@
+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, getSystemProxy } from "@/services/cmds";
+import { useMemo, useState, useEffect } from "react";
+
+// 将毫秒转换为时:分:秒格式的函数
+const formatUptime = (uptimeMs: number) => {
+  const hours = Math.floor(uptimeMs / 3600000);
+  const minutes = Math.floor((uptimeMs % 3600000) / 60000);
+  const seconds = Math.floor((uptimeMs % 60000) / 1000);
+  return `${hours}:${minutes.toString().padStart(2, "0")}:${seconds.toString().padStart(2, "0")}`;
+};
+
+export const ClashInfoCard = () => {
+  const { t } = useTranslation();
+  const { clashInfo } = useClashInfo();
+  const { version: clashVersion } = useClash();
+  const [sysproxy, setSysproxy] = useState<{ server: string; enable: boolean; bypass: string } | null>(null);
+  const [rules, setRules] = useState<any[]>([]);
+
+  // 使用SWR获取应用运行时间，降低更新频率
+  const { data: uptimeMs = 0 } = useSWR(
+    "appUptime",
+    getAppUptime,
+    {
+      refreshInterval: 1000,
+      revalidateOnFocus: false,
+      dedupingInterval: 1000,
+    },
+  );
+
+  // 在组件加载时获取系统代理信息和规则数据
+  useEffect(() => {
+    // 获取系统代理信息
+    getSystemProxy().then(setSysproxy);
+    
+    // 获取规则数据
+    getRules().then(setRules).catch(() => setRules([]));
+  }, []);
+
+  // 使用useMemo缓存格式化后的uptime，避免频繁计算
+  const uptime = useMemo(() => formatUptime(uptimeMs), [uptimeMs]);
+
+  // 使用备忘录组件内容，减少重新渲染
+  const cardContent = useMemo(() => {
+    if (!clashInfo) return null;
+    
+    return (
+      <Stack spacing={1.5}>
+        <Stack direction="row" justifyContent="space-between">
+          <Typography variant="body2" color="text.secondary">
+            {t("Core Version")}
+          </Typography>
+          <Typography variant="body2" fontWeight="medium">
+            {clashVersion || "-"}
+          </Typography>
+        </Stack>
+        <Divider />
+        <Stack direction="row" justifyContent="space-between">
+          <Typography variant="body2" color="text.secondary">
+            {t("System Proxy Address")}
+          </Typography>
+          <Typography variant="body2" fontWeight="medium">
+            {sysproxy?.server || "-"}
+          </Typography>
+        </Stack>
+        <Divider />
+        <Stack direction="row" justifyContent="space-between">
+          <Typography variant="body2" color="text.secondary">
+            {t("Mixed Port")}
+          </Typography>
+          <Typography variant="body2" fontWeight="medium">
+            {clashInfo.mixed_port || "-"}
+          </Typography>
+        </Stack>
+        <Divider />
+        <Stack direction="row" justifyContent="space-between">
+          <Typography variant="body2" color="text.secondary">
+            {t("Uptime")}
+          </Typography>
+          <Typography variant="body2" fontWeight="medium">
+            {uptime}
+          </Typography>
+        </Stack>
+        <Divider />
+        <Stack direction="row" justifyContent="space-between">
+          <Typography variant="body2" color="text.secondary">
+            {t("Rules Count")}
+          </Typography>
+          <Typography variant="body2" fontWeight="medium">
+            {rules.length}
+          </Typography>
+        </Stack>
+      </Stack>
+    );
+  }, [clashInfo, clashVersion, t, uptime, rules.length, sysproxy]);
+
+  return (
+    <EnhancedCard
+      title={t("Clash Info")}
+      icon={<DeveloperBoardOutlined />}
+      iconColor="warning"
+      action={null}
+    >
+      {cardContent}
+    </EnhancedCard>
+  );
+};

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

@@ -0,0 +1,166 @@
+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 { patchClashMode } from "@/services/cmds";
+import { useVerge } from "@/hooks/use-verge";
+import {
+  LanguageRounded,
+  MultipleStopRounded,
+  DirectionsRounded,
+} from "@mui/icons-material";
+import { useMemo } from "react";
+
+export const ClashModeCard = () => {
+  const { t } = useTranslation();
+  const { verge } = useVerge();
+
+  // 获取当前Clash配置
+  const { data: clashConfig, mutate: mutateClash } = useSWR(
+    "getClashConfig",
+    getClashConfig,
+    {
+      revalidateOnFocus: false,
+      revalidateIfStale: true,
+      dedupingInterval: 1000,
+      errorRetryInterval: 5000
+    }
+  );
+
+  // 支持的模式列表
+  const modeList = useMemo(() => ["rule", "global", "direct"] as const, []);
+
+  // 直接使用API返回的模式，不维护本地状态
+  const currentMode = clashConfig?.mode?.toLowerCase();
+
+  // 模式图标映射
+  const modeIcons = useMemo(() => ({
+    rule: <MultipleStopRounded fontSize="small" />,
+    global: <LanguageRounded fontSize="small" />,
+    direct: <DirectionsRounded fontSize="small" />
+  }), []);
+
+  // 切换模式的处理函数
+  const onChangeMode = useLockFn(async (mode: string) => {
+    if (mode === currentMode) return;
+    if (verge?.auto_close_connection) {
+      closeAllConnections();
+    }
+
+    try {
+      await patchClashMode(mode);
+      mutateClash();
+    } catch (error) {
+      console.error("Failed to change mode:", error);
+    }
+  });
+
+  // 按钮样式
+  const buttonStyles = (mode: string) => ({
+    cursor: "pointer",
+    px: 2,
+    py: 1.2,
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center",
+    gap: 1,
+    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",
+    overflow: "visible",
+    "&:hover": {
+      transform: "translateY(-1px)",
+      boxShadow: 1,
+    },
+    "&:active": {
+      transform: "translateY(1px)",
+    },
+    "&::after": mode === currentMode
+      ? {
+          content: '""',
+          position: "absolute",
+          bottom: -16,
+          left: "50%",
+          width: 2,
+          height: 16,
+          bgcolor: "primary.main",
+          transform: "translateX(-50%)",
+        }
+      : {},
+  });
+
+  // 描述样式
+  const descriptionStyles = {
+    width: "95%",
+    textAlign: "center",
+    color: "text.secondary",
+    p: 0.8,
+    borderRadius: 1,
+    borderColor: "primary.main",
+    borderWidth: 1,
+    borderStyle: "solid",
+    backgroundColor: "background.paper",
+    wordBreak: "break-word",
+    hyphens: "auto",
+  };
+
+  return (
+    <Box sx={{ display: "flex", flexDirection: "column", width: "100%" }}>
+      {/* 模式选择按钮组 */}
+      <Stack
+        direction="row"
+        spacing={1}
+        sx={{
+          display: "flex",
+          justifyContent: "center",
+          py: 1,
+          position: "relative",
+          zIndex: 2,
+        }}
+      >
+        {modeList.map((mode) => (
+          <Paper
+            key={mode}
+            elevation={mode === currentMode ? 2 : 0}
+            onClick={() => onChangeMode(mode)}
+            sx={buttonStyles(mode)}
+          >
+            {modeIcons[mode]}
+            <Typography
+              variant="body2"
+              sx={{
+                textTransform: "capitalize",
+                fontWeight: mode === currentMode ? 600 : 400,
+              }}
+            >
+              {t(mode)}
+            </Typography>
+          </Paper>
+        ))}
+      </Stack>
+
+      {/* 说明文本区域 */}
+      <Box
+        sx={{
+          width: "100%",
+          my: 1,
+          position: "relative",
+          display: "flex",
+          justifyContent: "center",
+          overflow: "visible",
+        }}
+      >
+        <Typography
+          variant="caption"
+          component="div"
+          sx={descriptionStyles}
+        >
+          {t(`${currentMode} Mode Description`)}
+        </Typography>
+      </Box>
+    </Box>
+  );
+};

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

@@ -0,0 +1,645 @@
+import { useTranslation } from "react-i18next";
+import {
+  Box,
+  Typography,
+  Chip,
+  Button,
+  alpha,
+  useTheme,
+  Select,
+  MenuItem,
+  FormControl,
+  InputLabel,
+  SelectChangeEvent,
+  Tooltip,
+} from "@mui/material";
+import { useEffect, useState, useMemo, useCallback, useRef } from "react";
+import {
+  SignalWifi4Bar as SignalStrong,
+  SignalWifi3Bar as SignalGood,
+  SignalWifi2Bar as SignalMedium,
+  SignalWifi1Bar as SignalWeak,
+  SignalWifi0Bar as SignalNone,
+  WifiOff as SignalError,
+  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 delayManager from "@/services/delay";
+import { useVerge } from "@/hooks/use-verge";
+
+// 本地存储的键名
+const STORAGE_KEY_GROUP = "clash-verge-selected-proxy-group";
+const STORAGE_KEY_PROXY = "clash-verge-selected-proxy";
+
+// 代理节点信息接口
+interface ProxyOption {
+  name: string;
+}
+
+// 将delayManager返回的颜色格式转换为MUI Chip组件需要的格式
+function convertDelayColor(delayValue: number) {
+  const colorStr = delayManager.formatDelayColor(delayValue);
+  if (!colorStr) return "default";
+
+  // 从"error.main"这样的格式转为"error"
+  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";
+  }
+}
+
+// 根据延迟值获取合适的WiFi信号图标
+function getSignalIcon(delay: number) {
+  if (delay < 0)
+    return { icon: <SignalNone />, text: "未测试", color: "text.secondary" };
+  if (delay >= 10000)
+    return { icon: <SignalError />, text: "超时", color: "error.main" };
+  if (delay >= 500)
+    return { icon: <SignalWeak />, text: "延迟较高", color: "error.main" };
+  if (delay >= 300)
+    return { icon: <SignalMedium />, text: "延迟中等", color: "warning.main" };
+  if (delay >= 200)
+    return { icon: <SignalGood />, text: "延迟良好", color: "info.main" };
+  return { icon: <SignalStrong />, text: "延迟极佳", color: "success.main" };
+}
+
+// 简单的防抖函数
+function debounce(fn: Function, ms = 100) {
+  let timeoutId: ReturnType<typeof setTimeout>;
+  return function (this: any, ...args: any[]) {
+    clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => fn.apply(this, args), ms);
+  };
+}
+
+export const CurrentProxyCard = () => {
+  const { t } = useTranslation();
+  const { currentProxy, primaryGroupName, mode, refreshProxy } =
+    useCurrentProxy();
+  const navigate = useNavigate();
+  const theme = useTheme();
+  const { verge } = useVerge();
+
+  // 判断模式
+  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: {
+      groups: { name: string; now: string; all: string[] }[];
+      records: Record<string, any>;
+      globalProxy: string;
+      directProxy: any;
+    };
+    selection: {
+      group: string;
+      proxy: string;
+    };
+    displayProxy: any;
+  };
+
+  // 合并状态，减少状态更新次数
+  const [state, setState] = useState<ProxyState>({
+    proxyData: {
+      groups: [],
+      records: {},
+      globalProxy: "",
+      directProxy: null,
+    },
+    selection: {
+      group: "",
+      proxy: "",
+    },
+    displayProxy: null,
+  });
+
+  // 初始化选择的组
+  useEffect(() => {
+    // 根据模式确定初始组
+    if (isGlobalMode) {
+      setState((prev) => ({
+        ...prev,
+        selection: {
+          ...prev.selection,
+          group: "GLOBAL",
+        },
+      }));
+    } else if (isDirectMode) {
+      setState((prev) => ({
+        ...prev,
+        selection: {
+          ...prev.selection,
+          group: "DIRECT",
+        },
+      }));
+    } else {
+      const savedGroup = localStorage.getItem(STORAGE_KEY_GROUP);
+      setState((prev) => ({
+        ...prev,
+        selection: {
+          ...prev.selection,
+          group: savedGroup || primaryGroupName || "",
+        },
+      }));
+    }
+  }, [isGlobalMode, isDirectMode, primaryGroupName]);
+
+  // 带锁的代理数据获取函数，防止并发请求
+  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();
+
+        // 过滤和格式化组
+        const filteredGroups = data.groups
+          .filter((g) => g.name !== "DIRECT" && g.name !== "REJECT")
+          .map((g) => ({
+            name: g.name,
+            now: g.now || "",
+            all: g.all.map((p) => p.name),
+          }));
+
+        // 使用函数式更新确保状态更新的原子性
+        setState((prev) => {
+          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 (!currentGroup && filteredGroups.length > 0) {
+              newGroup = filteredGroups[0].name;
+              const firstGroup = filteredGroups[0];
+              newProxy = firstGroup.now;
+              newDisplayProxy = data.records?.[newProxy] || null;
+
+              // 保存到本地存储
+              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;
+            }
+          }
+
+          // 返回新状态
+          return {
+            proxyData: {
+              groups: filteredGroups,
+              records: data.records || {},
+              globalProxy: data.global?.now || "",
+              directProxy: data.records?.DIRECT || null,
+            },
+            selection: {
+              group: newGroup,
+              proxy: newProxy,
+            },
+            displayProxy: newDisplayProxy,
+          };
+        });
+      } catch (error) {
+        console.error("获取代理信息失败", error);
+      } finally {
+        isRefreshingRef.current = false;
+
+        // 处理待处理的刷新请求
+        if (pendingRefreshRef.current) {
+          pendingRefreshRef.current = false;
+          setTimeout(() => fetchProxyData(), 100);
+        }
+      }
+    },
+    [isGlobalMode, isDirectMode],
+  );
+
+  // 响应 currentProxy 变化
+  useEffect(() => {
+    if (
+      currentProxy &&
+      (!state.displayProxy || currentProxy.name !== state.displayProxy.name)
+    ) {
+      fetchProxyData(true);
+    }
+  }, [currentProxy, fetchProxyData, state.displayProxy]);
+
+  // 监听模式变化，mode变化时刷新
+  useEffect(() => {
+    fetchProxyData(true);
+  }, [mode, fetchProxyData]);
+
+
+  // 计算要显示的代理选项 - 使用 useMemo 优化
+  const proxyOptions = useMemo(() => {
+    if (isDirectMode) {
+      return [{ name: "DIRECT" }];
+    }
+    if (isGlobalMode && state.proxyData.records) {
+      // 全局模式下的选项
+      return Object.keys(state.proxyData.records)
+        .filter((name) => name !== "DIRECT" && name !== "REJECT")
+        .map((name) => ({ name }));
+    }
+
+    // 普通模式
+    const group = state.proxyData.groups.find(
+      (g) => g.name === state.selection.group,
+    );
+    if (group) {
+      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
+              ? `${signalInfo.text}: ${delayManager.formatDelay(currentDelay)}`
+              : "无代理节点"
+          }
+        >
+          <Box sx={{ color: signalInfo.color }}>
+            {proxyToDisplay ? signalInfo.icon : <SignalNone color="disabled" />}
+          </Box>
+        </Tooltip>
+      }
+      iconColor={proxyToDisplay ? "primary" : undefined}
+      action={
+        <Button
+          variant="outlined"
+          size="small"
+          onClick={goToProxies}
+          sx={{ borderRadius: 1.5 }}
+          endIcon={<ChevronRight fontSize="small" />}
+        >
+          {t("Label-Proxies")}
+        </Button>
+      }
+    >
+      {proxyToDisplay ? (
+        <Box>
+          {/* 代理节点信息显示 */}
+          <Box
+            sx={{
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "space-between",
+              p: 1,
+              mb: 2,
+              borderRadius: 1,
+              bgcolor: alpha(theme.palette.primary.main, 0.05),
+              border: `1px solid ${alpha(theme.palette.primary.main, 0.1)}`,
+            }}
+          >
+            <Box>
+              <Typography variant="body1" fontWeight="medium">
+                {proxyToDisplay.name}
+              </Typography>
+
+              <Box
+                sx={{ display: "flex", alignItems: "center", flexWrap: "wrap" }}
+              >
+                <Typography
+                  variant="caption"
+                  color="text.secondary"
+                  sx={{ mr: 1 }}
+                >
+                  {proxyToDisplay.type}
+                </Typography>
+                {isGlobalMode && (
+                  <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 }}
+                  />
+                )}
+                {/* 节点特性 */}
+                {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" />
+                )}
+              </Box>
+            </Box>
+
+            {/* 显示延迟 */}
+            {proxyToDisplay && !isDirectMode && (
+              <Chip
+                size="small"
+                label={delayManager.formatDelay(currentDelay)}
+                color={convertDelayColor(currentDelay)}
+              />
+            )}
+          </Box>
+          {/* 代理组选择器 */}
+          <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"
+              value={state.selection.group}
+              onChange={handleGroupChange}
+              label={t("Group")}
+              disabled={isGlobalMode || isDirectMode}
+            >
+              {state.proxyData.groups.map((group) => (
+                <MenuItem key={group.name} value={group.name}>
+                  {group.name}
+                </MenuItem>
+              ))}
+            </Select>
+          </FormControl>
+
+          {/* 代理节点选择器 */}
+          <FormControl fullWidth variant="outlined" size="small" sx={{ mb: 0 }}>
+            <InputLabel id="proxy-select-label">{t("Proxy")}</InputLabel>
+            <Select
+              labelId="proxy-select-label"
+              value={state.selection.proxy}
+              onChange={handleProxyChange}
+              label={t("Proxy")}
+              disabled={isDirectMode}
+              renderValue={renderProxyValue}
+              MenuProps={{
+                PaperProps: {
+                  style: {
+                    maxHeight: 500,
+                  },
+                },
+              }}
+            >
+              {isDirectMode
+                ? null
+                : 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>
+                    );
+                  })}
+            </Select>
+          </FormControl>
+        </Box>
+      ) : (
+        <Box sx={{ textAlign: "center", py: 4 }}>
+          <Typography variant="body1" color="text.secondary">
+            {t("No active proxy node")}
+          </Typography>
+        </Box>
+      )}
+    </EnhancedCard>
+  );
+};

src/components/home/enhanced-card.tsx

@@ -0,0 +1,121 @@
+import { Box, Typography, alpha, useTheme } from "@mui/material";
+import { ReactNode } from "react";
+
+// 自定义卡片组件接口
+export interface EnhancedCardProps {
+  title: ReactNode;
+  icon: ReactNode;
+  action?: ReactNode;
+  children: ReactNode;
+  iconColor?:
+    | "primary"
+    | "secondary"
+    | "error"
+    | "warning"
+    | "info"
+    | "success";
+  minHeight?: number | string;
+  noContentPadding?: boolean;
+}
+
+// 自定义卡片组件
+export const EnhancedCard = ({
+  title,
+  icon,
+  action,
+  children,
+  iconColor = "primary",
+  minHeight,
+  noContentPadding = false,
+}: EnhancedCardProps) => {
+  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={{
+        height: "100%",
+        display: "flex",
+        flexDirection: "column",
+        borderRadius: 2,
+        backgroundColor: isDark ? "#282a36" : "#ffffff",
+      }}
+    >
+      <Box
+        sx={{
+          px: 2,
+          py: 1,
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "space-between",
+          borderBottom: 1,
+          borderColor: "divider",
+        }}
+      >
+        <Box sx={{ 
+          display: "flex", 
+          alignItems: "center", 
+          minWidth: 0, 
+          flex: 1,
+          overflow: "hidden"
+        }}>
+          <Box
+            sx={{
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "center",
+              borderRadius: 1.5,
+              width: 38,
+              height: 38,
+              mr: 1.5,
+              flexShrink: 0,
+              backgroundColor: alpha(theme.palette[iconColor].main, 0.12),
+              color: theme.palette[iconColor].main,
+            }}
+          >
+            {icon}
+          </Box>
+          <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 && <Box sx={{ ml: 2, flexShrink: 0 }}>{action}</Box>}
+      </Box>
+      <Box
+        sx={{
+          flex: 1,
+          display: "flex",
+          flexDirection: "column",
+          p: noContentPadding ? 0 : 2,
+          ...(minHeight && { minHeight }),
+        }}
+      >
+        {children}
+      </Box>
+    </Box>
+  );
+};

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

@@ -0,0 +1,553 @@
+import {
+  forwardRef,
+  useImperativeHandle,
+  useState,
+  useEffect,
+  useCallback,
+  useMemo,
+  useRef,
+  memo,
+} from "react";
+import { Box, useTheme } from "@mui/material";
+import parseTraffic from "@/utils/parse-traffic";
+import { useTranslation } from "react-i18next";
+import {
+  LineChart,
+  Line,
+  XAxis,
+  YAxis,
+  CartesianGrid,
+  Tooltip,
+  ResponsiveContainer,
+  AreaChart,
+  Area,
+} from "recharts";
+
+// 流量数据项接口
+export interface ITrafficItem {
+  up: number;
+  down: number;
+  timestamp?: number;
+}
+
+// 组件对外暴露的方法
+export interface EnhancedTrafficGraphRef {
+  appendData: (data: ITrafficItem) => void;
+  toggleStyle: () => void;
+}
+
+// 时间范围类型
+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 [displayData, setDisplayData] = useState<DataPoint[]>([]);
+    
+    // 帧率控制
+    const lastUpdateTimeRef = useRef<number>(0);
+    const pendingUpdateRef = useRef<boolean>(false);
+    const rafIdRef = useRef<number | null>(null);
+
+    // 根据时间范围计算保留的数据点数量
+    const getMaxPointsByTimeRange = useCallback(
+      (minutes: TimeRange): number => {
+        // 使用更低的采样率来减少点的数量，每2秒一个点而不是每秒一个点
+        return minutes * 30; // 每分钟30个点(每2秒1个点)
+      },
+      [],
+    );
+
+    // 最大数据点数量 - 基于选择的时间范围
+    const MAX_BUFFER_SIZE = useMemo(
+      () => getMaxPointsByTimeRange(10),
+      [getMaxPointsByTimeRange],
+    );
+
+    // 颜色配置
+    const colors = useMemo(
+      () => ({
+        up: theme.palette.secondary.main,
+        down: theme.palette.primary.main,
+        grid: theme.palette.divider,
+        tooltip: theme.palette.background.paper,
+        text: theme.palette.text.primary,
+      }),
+      [theme],
+    );
+
+    // 切换时间范围
+    const handleTimeRangeClick = useCallback(() => {
+      setTimeRange((prevRange) => {
+        // 在1、5、10分钟之间循环切换
+        const newRange = prevRange === 1 ? 5 : prevRange === 5 ? 10 : 1;
+        window.trafficHistoryTimeRange = newRange; // 保存到全局
+        return newRange;
+      });
+    }, []);
+
+    // 初始化数据缓冲区
+    useEffect(() => {
+      let initialBuffer: DataPoint[] = [];
+      
+      // 如果全局有保存的数据，优先使用
+      if (window.trafficHistoryData && window.trafficHistoryData.length > 0) {
+        initialBuffer = [...window.trafficHistoryData];
+        
+        // 确保数据长度符合要求
+        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];
+        }
+      } 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]);
+
+    // 添加数据点方法
+    const appendData = useCallback((data: ITrafficItem) => {
+      // 安全处理数据
+      const safeData = {
+        up: typeof data.up === "number" && !isNaN(data.up) ? data.up : 0,
+        down: typeof data.down === "number" && !isNaN(data.down) ? data.down : 0,
+      };
+
+      // 使用提供的时间戳或当前时间
+      const timestamp = data.timestamp || Date.now();
+      const date = new Date(timestamp);
+
+      // 带时间标签的新数据点
+      const newPoint: DataPoint = {
+        ...safeData,
+        name: date.toLocaleTimeString("en-US", {
+          hour12: false,
+          hour: "2-digit",
+          minute: "2-digit",
+          second: "2-digit",
+        }),
+        timestamp: timestamp,
+      };
+
+      // 更新ref，但保持原数组大小
+      const newBuffer = [...dataBufferRef.current.slice(1), newPoint];
+      dataBufferRef.current = newBuffer;
+      
+      // 保存到全局变量
+      window.trafficHistoryData = newBuffer;
+      
+      // 使用节流更新显示数据
+      throttledUpdateData();
+    }, [throttledUpdateData]);
+
+    // 切换图表样式
+    const toggleStyle = useCallback(() => {
+      setChartStyle((prev) => {
+        const newStyle = prev === "line" ? "area" : "line";
+        window.trafficHistoryStyle = newStyle; // 保存到全局
+        return newStyle;
+      });
+    }, []);
+
+    // 暴露方法给父组件
+    useImperativeHandle(
+      ref,
+      () => ({
+        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]);
+
+    // Y轴刻度格式化
+    const formatYAxis = useCallback((value: number) => {
+      const [num, unit] = parseTraffic(value);
+      return `${num}${unit}`;
+    }, []);
+
+    // 格式化X轴标签
+    const formatXLabel = useCallback((value: string) => {
+      if (!value) return "";
+      // 只显示小时和分钟
+      const parts = value.split(":");
+      return `${parts[0]}:${parts[1]}`;
+    }, []);
+
+    // 获取当前时间范围文本
+    const getTimeRangeText = useCallback(() => {
+      return t("{{time}} Minutes", { time: timeRange });
+    }, [timeRange, t]);
+
+    // 共享图表配置
+    const chartConfig = useMemo(() => ({
+      data: displayData,
+      margin: { top: 10, right: 20, left: 0, bottom: 0 },
+    }), [displayData]);
+
+    // 共享的线条/区域配置
+    const commonLineProps = useMemo(() => ({
+      dot: false,
+      strokeWidth: 2,
+      connectNulls: false,
+      activeDot: { r: 4, strokeWidth: 1 },
+      isAnimationActive: false, // 禁用动画以减少CPU使用
+    }), []);
+
+    // 曲线类型 - 使用线性曲线避免错位
+    const curveType = "monotone";
+
+    return (
+      <Box
+        sx={{
+          width: "100%",
+          height: "100%",
+          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}
+              />
+              
+              {/* 可点击的时间范围标签 */}
+              <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>
+            </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="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>
+          )}
+        </ResponsiveContainer>
+      </Box>
+    );
+  },
+));
+
+// 添加显示名称以便调试
+EnhancedTrafficGraph.displayName = "EnhancedTrafficGraph";

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

@@ -0,0 +1,443 @@
+import { useState, useEffect, useRef, useCallback, memo, useMemo } from "react";
+import { useTranslation } from "react-i18next";
+import {
+  Typography,
+  Paper,
+  alpha,
+  useTheme,
+  PaletteColor,
+} from "@mui/material";
+import Grid from "@mui/material/Grid2";
+import {
+  ArrowUpwardRounded,
+  ArrowDownwardRounded,
+  MemoryRounded,
+  LinkRounded,
+  CloudUploadRounded,
+  CloudDownloadRounded,
+} from "@mui/icons-material";
+import {
+  EnhancedTrafficGraph,
+  EnhancedTrafficGraphRef,
+  ITrafficItem,
+} from "./enhanced-traffic-graph";
+import { useVisibility } from "@/hooks/use-visibility";
+import { useClashInfo } from "@/hooks/use-clash";
+import { useVerge } from "@/hooks/use-verge";
+import { createAuthSockette } from "@/utils/websocket";
+import parseTraffic from "@/utils/parse-traffic";
+import { getConnections, isDebugEnabled, gc } from "@/services/api";
+import { ReactNode } from "react";
+
+interface MemoryUsage {
+  inuse: number;
+  oslimit?: number;
+}
+
+interface TrafficStatData {
+  uploadTotal: number;
+  downloadTotal: number;
+  activeConnections: number;
+}
+
+interface StatCardProps {
+  icon: ReactNode;
+  title: string;
+  value: string | number;
+  unit: string;
+  color: "primary" | "secondary" | "error" | "warning" | "info" | "success";
+  onClick?: () => void;
+}
+
+// 全局变量类型定义
+declare global {
+  interface Window {
+    animationFrameId?: number;
+    lastTrafficData?: {
+      up: number;
+      down: number;
+    };
+  }
+}
+
+// 控制更新频率
+const CONNECTIONS_UPDATE_INTERVAL = 5000; // 5秒更新一次连接数据
+const THROTTLE_TRAFFIC_UPDATE = 500; // 500ms节流流量数据更新
+
+// 统计卡片组件 - 使用memo优化
+const CompactStatCard = memo(({
+  icon,
+  title,
+  value,
+  unit,
+  color,
+  onClick,
+}: StatCardProps) => {
+  const theme = useTheme();
+  
+  // 获取调色板颜色 - 使用useMemo避免重复计算
+  const colorValue = useMemo(() => {
+    const palette = theme.palette;
+    if (
+      color in palette &&
+      palette[color as keyof typeof palette] &&
+      "main" in (palette[color as keyof typeof palette] as PaletteColor)
+    ) {
+      return (palette[color as keyof typeof palette] as PaletteColor).main;
+    }
+    return palette.primary.main;
+  }, [theme.palette, color]);
+  
+  return (
+    <Paper
+      elevation={0}
+      sx={{
+        display: "flex",
+        alignItems: "center",
+        borderRadius: 2,
+        bgcolor: alpha(colorValue, 0.05),
+        border: `1px solid ${alpha(colorValue, 0.15)}`,
+        padding: "8px",
+        transition: "all 0.2s ease-in-out",
+        cursor: onClick ? "pointer" : "default",
+        "&:hover": onClick ? {
+          bgcolor: alpha(colorValue, 0.1),
+          border: `1px solid ${alpha(colorValue, 0.3)}`,
+          boxShadow: `0 4px 8px rgba(0,0,0,0.05)`,
+        } : {},
+      }}
+      onClick={onClick}
+    >
+      {/* 图标容器 */}
+      <Grid
+        component="div"
+        sx={{
+          mr: 1,
+          ml: "2px",
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          width: 32,
+          height: 32,
+          borderRadius: "50%",
+          bgcolor: alpha(colorValue, 0.1),
+          color: colorValue,
+        }}
+      >
+        {icon}
+      </Grid>
+
+      {/* 文本内容 */}
+      <Grid component="div" sx={{ flexGrow: 1, minWidth: 0 }}>
+        <Typography variant="caption" color="text.secondary" noWrap>
+          {title}
+        </Typography>
+        <Grid component="div" sx={{ display: "flex", alignItems: "baseline" }}>
+          <Typography variant="body1" fontWeight="bold" noWrap sx={{ mr: 0.5 }}>
+            {value}
+          </Typography>
+          <Typography variant="caption" color="text.secondary">
+            {unit}
+          </Typography>
+        </Grid>
+      </Grid>
+    </Paper>
+  );
+});
+
+// 添加显示名称
+CompactStatCard.displayName = "CompactStatCard";
+
+export const EnhancedTrafficStats = () => {
+  const { t } = useTranslation();
+  const theme = useTheme();
+  const { clashInfo } = useClashInfo();
+  const { verge } = useVerge();
+  const trafficRef = useRef<EnhancedTrafficGraphRef>(null);
+  const pageVisible = useVisibility();
+  const [isDebug, setIsDebug] = useState(false);
+  
+  // 使用单一状态对象减少状态更新次数
+  const [stats, setStats] = useState({
+    traffic: { up: 0, down: 0 },
+    memory: { inuse: 0, oslimit: undefined as number | undefined },
+    connections: { uploadTotal: 0, downloadTotal: 0, activeConnections: 0 },
+  });
+
+  // 创建一个标记来追踪最后更新时间，用于节流
+  const lastUpdateRef = useRef({ traffic: 0 });
+  
+  // 是否显示流量图表
+  const trafficGraph = verge?.traffic_graph ?? true;
+
+  // WebSocket引用
+  const socketRefs = useRef({
+    traffic: null as ReturnType<typeof createAuthSockette> | null,
+    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));
+  }, []);
+
+  // 处理流量数据更新 - 使用节流控制更新频率
+  const handleTrafficUpdate = useCallback((event: MessageEvent) => {
+    try {
+      const data = JSON.parse(event.data) as ITrafficItem;
+      if (
+        data &&
+        typeof data.up === "number" &&
+        typeof data.down === "number"
+      ) {
+        // 使用节流控制更新频率
+        const now = Date.now();
+        if (now - lastUpdateRef.current.traffic < THROTTLE_TRAFFIC_UPDATE) {
+          // 如果距离上次更新时间小于阈值，只更新图表不更新状态
+          if (trafficRef.current) {
+            trafficRef.current.appendData({
+              up: data.up,
+              down: data.down,
+              timestamp: now,
+            });
+          }
+          return;
+        }
+        
+        // 更新最后更新时间
+        lastUpdateRef.current.traffic = now;
+        
+        // 验证数据有效性，防止NaN
+        const safeUp = isNaN(data.up) ? 0 : data.up;
+        const safeDown = isNaN(data.down) ? 0 : data.down;
+        
+        // 批量更新状态
+        setStats(prev => ({
+          ...prev,
+          traffic: { up: safeUp, down: safeDown }
+        }));
+
+        // 更新图表数据
+        if (trafficRef.current) {
+          trafficRef.current.appendData({
+            up: safeUp,
+            down: safeDown,
+            timestamp: now,
+          });
+        }
+      }
+    } catch (err) {
+      console.error("[Traffic] 解析数据错误:", err);
+    }
+  }, []);
+
+  // 处理内存数据更新
+  const handleMemoryUpdate = useCallback((event: MessageEvent) => {
+    try {
+      const data = JSON.parse(event.data) as MemoryUsage;
+      if (data && typeof data.inuse === "number") {
+        setStats(prev => ({
+          ...prev,
+          memory: {
+            inuse: isNaN(data.inuse) ? 0 : data.inuse,
+            oslimit: data.oslimit,
+          }
+        }));
+      }
+    } catch (err) {
+      console.error("[Memory] 解析数据错误:", err);
+    }
+  }, []);
+
+  // 使用 WebSocket 连接获取数据 - 合并流量和内存连接逻辑
+  useEffect(() => {
+    if (!clashInfo || !pageVisible) return;
+
+    const { server, secret = "" } = clashInfo;
+    if (!server) return;
+
+    // 清理现有连接的函数
+    const cleanupSockets = () => {
+      Object.values(socketRefs.current).forEach(socket => {
+        if (socket) {
+          socket.close();
+        }
+      });
+      socketRefs.current = { traffic: null, memory: null };
+    };
+
+    // 关闭现有连接
+    cleanupSockets();
+
+    // 创建新连接
+    socketRefs.current.traffic = createAuthSockette(`${server}/traffic`, secret, {
+      onmessage: handleTrafficUpdate,
+    });
+    
+    socketRefs.current.memory = createAuthSockette(`${server}/memory`, secret, {
+      onmessage: handleMemoryUpdate,
+    });
+
+    return cleanupSockets;
+  }, [clashInfo, pageVisible, handleTrafficUpdate, handleMemoryUpdate]);
+
+  // 执行垃圾回收
+  const handleGarbageCollection = useCallback(async () => {
+    if (isDebug) {
+      try {
+        await gc();
+        console.log("[Debug] 垃圾回收已执行");
+      } catch (err) {
+        console.error("[Debug] 垃圾回收失败:", err);
+      }
+    }
+  }, [isDebug]);
+
+  // 使用useMemo计算解析后的流量数据
+  const parsedData = useMemo(() => {
+    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);
+    
+    return {
+      up, upUnit, down, downUnit, inuse, inuseUnit,
+      uploadTotal, uploadTotalUnit, downloadTotal, downloadTotalUnit
+    };
+  }, [stats]);
+
+  // 渲染流量图表 - 使用useMemo缓存渲染结果
+  const trafficGraphComponent = useMemo(() => {
+    if (!trafficGraph || !pageVisible) return null;
+
+    return (
+      <Paper
+        elevation={0}
+        sx={{
+          height: 130,
+          cursor: "pointer",
+          border: `1px solid ${alpha(theme.palette.divider, 0.2)}`,
+          borderRadius: 2,
+          overflow: "hidden",
+        }}
+        onClick={() => trafficRef.current?.toggleStyle()}
+      >
+        <div style={{ height: "100%", position: "relative" }}>
+          <EnhancedTrafficGraph ref={trafficRef} />
+          {isDebug && (
+            <div
+              style={{
+                position: "absolute",
+                top: "2px",
+                left: "2px",
+                zIndex: 10,
+                backgroundColor: "rgba(0,0,0,0.5)",
+                color: "white",
+                fontSize: "8px",
+                padding: "2px 4px",
+                borderRadius: "4px",
+              }}
+            >
+              DEBUG: {!!trafficRef.current ? "图表已初始化" : "图表未初始化"}
+              <br />
+              {new Date().toISOString().slice(11, 19)}
+            </div>
+          )}
+        </div>
+      </Paper>
+    );
+  }, [trafficGraph, pageVisible, theme.palette.divider, isDebug]);
+
+  // 使用useMemo计算统计卡片配置
+  const statCards = useMemo(() => [
+    {
+      icon: <ArrowUpwardRounded fontSize="small" />,
+      title: t("Upload Speed"),
+      value: parsedData.up,
+      unit: `${parsedData.upUnit}/s`,
+      color: "secondary" as const,
+    },
+    {
+      icon: <ArrowDownwardRounded fontSize="small" />,
+      title: t("Download Speed"),
+      value: parsedData.down,
+      unit: `${parsedData.downUnit}/s`,
+      color: "primary" as const,
+    },
+    {
+      icon: <LinkRounded fontSize="small" />,
+      title: t("Active Connections"),
+      value: stats.connections.activeConnections,
+      unit: "",
+      color: "success" as const,
+    },
+    {
+      icon: <CloudUploadRounded fontSize="small" />,
+      title: t("Uploaded"),
+      value: parsedData.uploadTotal,
+      unit: parsedData.uploadTotalUnit,
+      color: "secondary" as const,
+    },
+    {
+      icon: <CloudDownloadRounded fontSize="small" />,
+      title: t("Downloaded"),
+      value: parsedData.downloadTotal,
+      unit: parsedData.downloadTotalUnit,
+      color: "primary" as const,
+    },
+    {
+      icon: <MemoryRounded fontSize="small" />,
+      title: t("Memory Usage"),
+      value: parsedData.inuse,
+      unit: parsedData.inuseUnit,
+      color: "error" as const,
+      onClick: isDebug ? handleGarbageCollection : undefined,
+    },
+  ], [t, parsedData, stats.connections.activeConnections, isDebug, handleGarbageCollection]);
+
+  return (
+    <Grid container spacing={1} columns={{ xs: 8, sm: 8, md: 12 }}>
+      <Grid size={12}>
+        {/* 流量图表区域 */}
+        {trafficGraphComponent}
+      </Grid>
+      {/* 统计卡片区域 */}
+      {statCards.map((card, index) => (
+        <Grid key={index} size={4}>
+          <CompactStatCard {...card} />
+        </Grid>
+      ))}
+    </Grid>
+  );
+};

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

@@ -0,0 +1,375 @@
+import { useTranslation } from "react-i18next";
+import {
+  Box,
+  Typography,
+  Button,
+  Stack,
+  LinearProgress,
+  alpha,
+  useTheme,
+  Link,
+  keyframes,
+} from "@mui/material";
+import { useNavigate } from "react-router-dom";
+import {
+  CloudUploadOutlined,
+  StorageOutlined,
+  UpdateOutlined,
+  DnsOutlined,
+  SpeedOutlined,
+  EventOutlined,
+  LaunchOutlined,
+} from "@mui/icons-material";
+import dayjs from "dayjs";
+import parseTraffic from "@/utils/parse-traffic";
+import { useMemo, useCallback, useState } from "react";
+import { openWebUrl, updateProfile } from "@/services/cmds";
+import { useLockFn } from "ahooks";
+import { Notice } from "@/components/base";
+import { EnhancedCard } from "./enhanced-card";
+
+// 定义旋转动画
+const round = keyframes`
+  from { transform: rotate(0deg); }
+  to { transform: rotate(360deg); }
+`;
+
+// 辅助函数解析URL和过期时间
+const parseUrl = (url?: string) => {
+  if (!url) return "-";
+  if (url.startsWith("http")) return new URL(url).host;
+  return "local";
+};
+
+const parseExpire = (expire?: number) => {
+  if (!expire) return "-";
+  return dayjs(expire * 1000).format("YYYY-MM-DD");
+};
+
+// 使用类型定义，而不是导入
+interface ProfileExtra {
+  upload: number;
+  download: number;
+  total: number;
+  expire: number;
+}
+
+export interface ProfileItem {
+  uid: string;
+  type?: "local" | "remote" | "merge" | "script";
+  name?: string;
+  desc?: string;
+  file?: string;
+  url?: string;
+  updated?: number;
+  extra?: ProfileExtra;
+  home?: string;
+  option?: any;
+}
+
+export interface HomeProfileCardProps {
+  current: ProfileItem | null | undefined;
+  onProfileUpdated?: () => void;
+}
+
+// 添加一个通用的截断样式
+const truncateStyle = {
+  maxWidth: "calc(100% - 28px)",
+  overflow: "hidden",
+  textOverflow: "ellipsis",
+  whiteSpace: "nowrap"
+};
+
+// 提取独立组件减少主组件复杂度
+const ProfileDetails = ({ current, onUpdateProfile, updating }: { 
+  current: ProfileItem; 
+  onUpdateProfile: () => void;
+  updating: boolean;
+}) => {
+  const { t } = useTranslation();
+  const theme = useTheme();
+
+  const usedTraffic = useMemo(() => {
+    if (!current.extra) return 0;
+    return current.extra.upload + current.extra.download;
+  }, [current.extra]);
+
+  const trafficPercentage = useMemo(() => {
+    if (!current.extra || !current.extra.total) return 1;
+    return Math.min(
+      Math.round((usedTraffic * 100) / (current.extra.total + 0.01)) + 1,
+      100
+    );
+  }, [current.extra, usedTraffic]);
+
+  return (
+    <Box>
+      <Stack spacing={2}>
+        {current.url && (
+          <Stack direction="row" alignItems="center" spacing={1}>
+            <DnsOutlined fontSize="small" color="action" />
+            <Typography variant="body2" color="text.secondary" noWrap sx={{ display: "flex", alignItems: "center" }}>
+              <span style={{ flexShrink: 0 }}>{t("From")}: </span>
+              {current.home ? (
+                <Link
+                  component="button"
+                  fontWeight="medium"
+                  onClick={() => current.home && openWebUrl(current.home)}
+                  sx={{ 
+                    display: "inline-flex",
+                    alignItems: "center",
+                    minWidth: 0,
+                    maxWidth: "calc(100% - 40px)",
+                    ml: 0.5
+                  }}
+                  title={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>
+              ) : (
+                <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)}
+                </Typography>
+              )}
+            </Typography>
+          </Stack>
+        )}
+
+        {current.updated && (
+          <Stack direction="row" alignItems="center" spacing={1}>
+            <UpdateOutlined
+              fontSize="small"
+              color="action"
+              sx={{
+                cursor: "pointer",
+                animation: updating ? `${round} 1.5s linear infinite` : "none",
+              }}
+              onClick={onUpdateProfile}
+            />
+            <Typography
+              variant="body2"
+              color="text.secondary"
+              sx={{ cursor: "pointer" }}
+              onClick={onUpdateProfile}
+            >
+              {t("Update Time")}:{" "}
+              <Box component="span" fontWeight="medium">
+                {dayjs(current.updated * 1000).format("YYYY-MM-DD HH:mm")}
+              </Box>
+            </Typography>
+          </Stack>
+        )}
+
+        {current.extra && (
+          <>
+            <Stack direction="row" alignItems="center" spacing={1}>
+              <SpeedOutlined fontSize="small" color="action" />
+              <Typography variant="body2" color="text.secondary">
+                {t("Used / Total")}:{" "}
+                <Box component="span" fontWeight="medium">
+                  {parseTraffic(usedTraffic)} / {parseTraffic(current.extra.total)}
+                </Box>
+              </Typography>
+            </Stack>
+
+            {current.extra.expire > 0 && (
+              <Stack direction="row" alignItems="center" spacing={1}>
+                <EventOutlined fontSize="small" color="action" />
+                <Typography variant="body2" color="text.secondary">
+                  {t("Expire Time")}:{" "}
+                  <Box component="span" fontWeight="medium">
+                    {parseExpire(current.extra.expire)}
+                  </Box>
+                </Typography>
+              </Stack>
+            )}
+
+            <Box sx={{ mt: 1 }}>
+              <Typography
+                variant="caption"
+                color="text.secondary"
+                sx={{ mb: 0.5, display: "block" }}
+              >
+                {trafficPercentage}%
+              </Typography>
+              <LinearProgress
+                variant="determinate"
+                value={trafficPercentage}
+                sx={{
+                  height: 8,
+                  borderRadius: 4,
+                  backgroundColor: alpha(theme.palette.primary.main, 0.12),
+                }}
+              />
+            </Box>
+          </>
+        )}
+      </Stack>
+    </Box>
+  );
+};
+
+// 提取空配置组件
+const EmptyProfile = ({ onClick }: { onClick: () => void }) => {
+  const { t } = useTranslation();
+  
+  return (
+    <Box
+      sx={{
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "center",
+        justifyContent: "center",
+        py: 2.4,
+        cursor: "pointer",
+        "&:hover": { bgcolor: "action.hover" },
+        borderRadius: 2,
+      }}
+      onClick={onClick}
+    >
+      <CloudUploadOutlined
+        sx={{ fontSize: 60, color: "primary.main", mb: 2 }}
+      />
+      <Typography variant="h6" gutterBottom>
+        {t("Import")} {t("Profiles")}
+      </Typography>
+      <Typography variant="body2" color="text.secondary">
+        {t("Click to import subscription")}
+      </Typography>
+    </Box>
+  );
+};
+
+export const HomeProfileCard = ({ current, onProfileUpdated }: HomeProfileCardProps) => {
+  const { t } = useTranslation();
+  const navigate = useNavigate();
+  
+  // 更新当前订阅
+  const [updating, setUpdating] = useState(false);
+  
+  const onUpdateProfile = useLockFn(async () => {
+    if (!current?.uid) return;
+
+    setUpdating(true);
+    try {
+      await updateProfile(current.uid);
+      Notice.success(t("Update subscription successfully"));
+      onProfileUpdated?.();
+    } catch (err: any) {
+      Notice.error(err?.message || err.toString());
+    } finally {
+      setUpdating(false);
+    }
+  });
+
+  // 导航到订阅页面
+  const goToProfiles = useCallback(() => {
+    navigate("/profile");
+  }, [navigate]);
+
+  // 卡片标题
+  const cardTitle = useMemo(() => {
+    if (!current) return t("Profiles");
+    
+    if (!current.home) return current.name;
+    
+    return (
+      <Link
+        component="button"
+        variant="h6"
+        fontWeight="medium"
+        fontSize={18}
+        onClick={() => current.home && openWebUrl(current.home)}
+        sx={{
+          color: "inherit",
+          textDecoration: "none",
+          display: "flex",
+          alignItems: "center",
+          minWidth: 0,
+          maxWidth: "100%",
+          "& > span": {
+            overflow: "hidden",
+            textOverflow: "ellipsis",
+            whiteSpace: "nowrap",
+            flex: 1
+          }
+        }}
+        title={current.name}
+      >
+        <span>{current.name}</span>
+        <LaunchOutlined
+          fontSize="inherit"
+          sx={{ 
+            ml: 0.5, 
+            fontSize: "0.8rem", 
+            opacity: 0.7,
+            flexShrink: 0 
+          }}
+        />
+      </Link>
+    );
+  }, [current, t]);
+
+  // 卡片操作按钮
+  const cardAction = useMemo(() => {
+    if (!current) return null;
+    
+    return (
+      <Button
+        variant="outlined"
+        size="small"
+        onClick={goToProfiles}
+        endIcon={<StorageOutlined fontSize="small" />}
+        sx={{ borderRadius: 1.5 }}
+      >
+        {t("Label-Profiles")}
+      </Button>
+    );
+  }, [current, goToProfiles, t]);
+
+  return (
+    <EnhancedCard
+      title={cardTitle}
+      icon={<CloudUploadOutlined />}
+      iconColor="info"
+      action={cardAction}
+    >
+      {current ? (
+        <ProfileDetails 
+          current={current} 
+          onUpdateProfile={onUpdateProfile} 
+          updating={updating} 
+        />
+      ) : (
+        <EmptyProfile onClick={goToProfiles} />
+      )}
+    </EnhancedCard>
+  );
+};

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

@@ -0,0 +1,324 @@
+import { useTranslation } from "react-i18next";
+import {
+  Box,
+  Typography,
+  Button,
+  Skeleton,
+  IconButton,
+  useTheme,
+} from "@mui/material";
+import {
+  LocationOnOutlined,
+  RefreshOutlined,
+  VisibilityOutlined,
+  VisibilityOffOutlined,
+} from "@mui/icons-material";
+import { EnhancedCard } from "./enhanced-card";
+import { getIpInfo } from "@/services/api";
+import { useState, useEffect, useCallback, memo } from "react";
+
+// 定义刷新时间（秒）
+const IP_REFRESH_SECONDS = 300;
+
+// 提取InfoItem子组件并使用memo优化
+const InfoItem = memo(({ label, value }: { label: string; value: string }) => (
+  <Box sx={{ mb: 0.7, display: "flex", alignItems: "flex-start" }}>
+    <Typography
+      variant="body2"
+      color="text.secondary"
+      sx={{ minwidth: 60, mr: 0.5, flexShrink: 0, textAlign: "right" }}
+    >
+      {label}:
+    </Typography>
+    <Typography
+      variant="body2"
+      sx={{
+        ml: 0.5,
+        overflow: "hidden",
+        textOverflow: "ellipsis",
+        wordBreak: "break-word",
+        whiteSpace: "normal",
+        flexGrow: 1,
+      }}
+    >
+      {value || "Unknown"}
+    </Typography>
+  </Box>
+));
+
+// 获取国旗表情
+const getCountryFlag = (countryCode: string) => {
+  if (!countryCode) return "";
+  const codePoints = countryCode
+    .toUpperCase()
+    .split("")
+    .map((char) => 127397 + char.charCodeAt(0));
+  return String.fromCodePoint(...codePoints);
+};
+
+// IP信息卡片组件
+export const IpInfoCard = () => {
+  const { t } = useTranslation();
+  const [ipInfo, setIpInfo] = useState<any>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState("");
+  const [showIp, setShowIp] = useState(false);
+  const [countdown, setCountdown] = useState(IP_REFRESH_SECONDS);
+
+  // 获取IP信息
+  const fetchIpInfo = useCallback(async () => {
+    try {
+      setLoading(true);
+      setError("");
+      const data = await getIpInfo();
+      setIpInfo(data);
+      setCountdown(IP_REFRESH_SECONDS);
+    } catch (err: any) {
+      setError(err.message || t("Failed to get IP info"));
+    } finally {
+      setLoading(false);
+    }
+  }, [t]);
+
+  // 组件加载时获取IP信息
+  useEffect(() => {
+    fetchIpInfo();
+    
+    // 倒计时实现优化，减少不必要的重渲染
+    let timer: number | null = null;
+    let currentCount = IP_REFRESH_SECONDS;
+    
+    // 只在必要时更新状态，减少重渲染次数
+    const startCountdown = () => {
+      timer = window.setInterval(() => {
+        currentCount -= 1;
+        
+        if (currentCount <= 0) {
+          fetchIpInfo();
+          currentCount = IP_REFRESH_SECONDS;
+        }
+        
+        // 每5秒或倒计时结束时才更新UI
+        if (currentCount % 5 === 0 || currentCount <= 0) {
+          setCountdown(currentCount);
+        }
+      }, 1000);
+    };
+    
+    startCountdown();
+    return () => {
+      if (timer) clearInterval(timer);
+    };
+  }, [fetchIpInfo]);
+
+  const toggleShowIp = useCallback(() => {
+    setShowIp(prev => !prev);
+  }, []);
+
+  // 渲染加载状态
+  if (loading) {
+    return (
+      <EnhancedCard
+        title={t("IP Information")}
+        icon={<LocationOnOutlined />}
+        iconColor="info"
+        action={
+          <IconButton size="small" onClick={fetchIpInfo} disabled={true}>
+            <RefreshOutlined />
+          </IconButton>
+        }
+      >
+        <Box sx={{ display: "flex", flexDirection: "column", gap: 1 }}>
+          <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} />
+        </Box>
+      </EnhancedCard>
+    );
+  }
+
+  // 渲染错误状态
+  if (error) {
+    return (
+      <EnhancedCard
+        title={t("IP Information")}
+        icon={<LocationOnOutlined />}
+        iconColor="info"
+        action={
+          <IconButton size="small" onClick={fetchIpInfo}>
+            <RefreshOutlined />
+          </IconButton>
+        }
+      >
+        <Box
+          sx={{
+            display: "flex",
+            flexDirection: "column",
+            alignItems: "center",
+            justifyContent: "center",
+            height: "100%",
+            color: "error.main",
+          }}
+        >
+          <Typography variant="body1" color="error">
+            {error}
+          </Typography>
+          <Button onClick={fetchIpInfo} sx={{ mt: 2 }}>
+            {t("Retry")}
+          </Button>
+        </Box>
+      </EnhancedCard>
+    );
+  }
+
+  // 渲染正常数据
+  return (
+    <EnhancedCard
+      title={t("IP Information")}
+      icon={<LocationOnOutlined />}
+      iconColor="info"
+      action={
+        <IconButton size="small" onClick={fetchIpInfo}>
+          <RefreshOutlined />
+        </IconButton>
+      }
+    >
+      <Box sx={{ height: "100%", display: "flex", flexDirection: "column" }}>
+        <Box
+          sx={{
+            display: "flex",
+            flexDirection: "row",
+            flex: 1,
+            overflow: "hidden",
+          }}
+        >
+          {/* 左侧：国家和IP地址 */}
+          <Box sx={{ width: "40%", overflow: "hidden" }}>
+            <Box
+              sx={{
+                display: "flex",
+                alignItems: "center",
+                mb: 1,
+                overflow: "hidden",
+              }}
+            >
+              <Box
+                component="span"
+                sx={{
+                  fontSize: "1.5rem",
+                  mr: 1,
+                  display: "inline-block",
+                  width: 28,
+                  textAlign: "center",
+                  flexShrink: 0,
+                  fontFamily: '"twemoji mozilla", sans-serif',
+                }}
+              >
+                {getCountryFlag(ipInfo?.country_code)}
+              </Box>
+              <Typography
+                variant="subtitle1"
+                sx={{
+                  fontWeight: "medium",
+                  overflow: "hidden",
+                  textOverflow: "ellipsis",
+                  whiteSpace: "nowrap",
+                  maxWidth: "100%",
+                }}
+              >
+                {ipInfo?.country || t("Unknown")}
+              </Typography>
+            </Box>
+
+            <Box sx={{ display: "flex", alignItems: "center", mb: 1 }}>
+              <Typography
+                variant="body2"
+                color="text.secondary"
+                sx={{ flexShrink: 0 }}
+              >
+                {t("IP")}:
+              </Typography>
+              <Box
+                sx={{
+                  display: "flex",
+                  alignItems: "center",
+                  ml: 1,
+                  overflow: "hidden",
+                  maxWidth: "calc(100% - 30px)",
+                }}
+              >
+                <Typography
+                  variant="body2"
+                  sx={{
+                    fontFamily: "monospace",
+                    fontSize: "0.75rem",
+                    overflow: "hidden",
+                    textOverflow: "ellipsis",
+                    wordBreak: "break-all",
+                  }}
+                >
+                  {showIp ? ipInfo?.ip : "••••••••••"}
+                </Typography>
+                <IconButton size="small" onClick={toggleShowIp}>
+                  {showIp ? (
+                    <VisibilityOffOutlined fontSize="small" />
+                  ) : (
+                    <VisibilityOutlined fontSize="small" />
+                  )}
+                </IconButton>
+              </Box>
+            </Box>
+
+            <InfoItem
+              label={t("ASN")}
+              value={ipInfo?.asn ? `AS${ipInfo.asn}` : "N/A"}
+            />
+          </Box>
+
+          {/* 右侧：组织、ISP和位置信息 */}
+          <Box sx={{ width: "60%", overflow: "auto" }}>
+            <InfoItem label={t("ISP")} value={ipInfo?.isp} />
+            <InfoItem label={t("ORG")} value={ipInfo?.asn_organization} />
+            <InfoItem
+              label={t("Location")}
+              value={[ipInfo?.city, ipInfo?.region]
+                .filter(Boolean)
+                .join(", ")}
+            />
+            <InfoItem label={t("Timezone")} value={ipInfo?.timezone} />
+          </Box>
+        </Box>
+
+        <Box
+          sx={{
+            mt: "auto",
+            pt: 0.5,
+            borderTop: 1,
+            borderColor: "divider",
+            display: "flex",
+            justifyContent: "space-between",
+            alignItems: "center",
+            opacity: 0.7,
+            fontSize: "0.7rem",
+          }}
+        >
+          <Typography variant="caption">
+            {t("Auto refresh")}: {countdown}s
+          </Typography>
+          <Typography
+            variant="caption"
+            sx={{
+              textOverflow: "ellipsis",
+              overflow: "hidden",
+              whiteSpace: "nowrap",
+            }}
+          >
+            {ipInfo?.country_code}, {ipInfo?.longitude?.toFixed(2)},{" "}
+            {ipInfo?.latitude?.toFixed(2)}
+          </Typography>
+        </Box>
+      </Box>
+    </EnhancedCard>
+  );
+};

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

@@ -0,0 +1,257 @@
+import { useTranslation } from "react-i18next";
+import {
+  Box,
+  Typography,
+  Stack,
+  Paper,
+  Tooltip,
+  alpha,
+  useTheme,
+  Fade,
+} from "@mui/material";
+import { useState, useMemo, memo, FC } from "react";
+import ProxyControlSwitches from "@/components/shared/ProxyControlSwitches";
+import { Notice } from "@/components/base";
+import {
+  ComputerRounded,
+  TroubleshootRounded,
+  HelpOutlineRounded,
+  SvgIconComponent,
+} from "@mui/icons-material";
+import useSWR from "swr";
+import {
+  getSystemProxy,
+  getAutotemProxy,
+  getRunningMode,
+} from "@/services/cmds";
+import { useVerge } from "@/hooks/use-verge";
+
+const LOCAL_STORAGE_TAB_KEY = "clash-verge-proxy-active-tab";
+
+interface TabButtonProps {
+  isActive: boolean;
+  onClick: () => void;
+  icon: SvgIconComponent;
+  label: string;
+  hasIndicator?: boolean;
+}
+
+// 抽取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 }}
+    >
+      {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;
+  tooltipTitle: string;
+}
+
+// 抽取描述文本组件
+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 { data: sysproxy } = useSWR("getSystemProxy", getSystemProxy);
+  const { data: runningMode } = useSWR("getRunningMode", getRunningMode);
+  const { verge } = useVerge();
+
+  // 从verge配置中获取开关状态
+  const { enable_system_proxy, enable_tun_mode } = verge ?? {};
+
+  // 是否以sidecar模式运行
+  const isSidecarMode = runningMode === "sidecar";
+
+  // 处理错误
+  const handleError = (err: Error) => {
+    Notice.error(err.message || err.toString(), 3000);
+  };
+
+  // 处理标签切换并保存到localStorage
+  const handleTabChange = (tab: string) => {
+    setActiveTab(tab);
+    localStorage.setItem(LOCAL_STORAGE_TAB_KEY, tab);
+  };
+
+  // 用户提示文本 - 使用useMemo避免重复计算
+  const tabDescription = useMemo(() => {
+    if (activeTab === "system") {
+      return {
+        text: enable_system_proxy
+          ? t("System Proxy Enabled")
+          : t("System Proxy Disabled"),
+        tooltip: t("System Proxy Info")
+      };
+    } else {
+      return {
+        text: isSidecarMode
+          ? t("TUN Mode Service Required")
+          : enable_tun_mode
+            ? t("TUN Mode Enabled")
+            : t("TUN Mode Disabled"),
+        tooltip: t("TUN Mode Intercept Info")
+      };
+    }
+  }, [activeTab, enable_system_proxy, enable_tun_mode, isSidecarMode, t]);
+
+  return (
+    <Box sx={{ display: "flex", flexDirection: "column", width: "100%" }}>
+      {/* 选项卡 */}
+      <Stack
+        direction="row"
+        spacing={1}
+        sx={{
+          display: "flex",
+          justifyContent: "center",
+          position: "relative",
+          zIndex: 2,
+        }}
+      >
+        <TabButton
+          isActive={activeTab === "system"}
+          onClick={() => handleTabChange("system")}
+          icon={ComputerRounded}
+          label={t("System Proxy")}
+          hasIndicator={enable_system_proxy}
+        />
+        <TabButton
+          isActive={activeTab === "tun"}
+          onClick={() => handleTabChange("tun")}
+          icon={TroubleshootRounded}
+          label={t("Tun Mode")}
+          hasIndicator={enable_tun_mode && !isSidecarMode}
+        />
+      </Stack>
+
+      {/* 说明文本区域 */}
+      <Box
+        sx={{
+          width: "100%",
+          my: 1,
+          position: "relative",
+          display: "flex",
+          justifyContent: "center",
+          overflow: "visible",
+        }}
+      >
+        <TabDescription
+          description={tabDescription.text}
+          tooltipTitle={tabDescription.tooltip}
+        />
+      </Box>
+
+      {/* 控制开关部分 */}
+      <Box
+        sx={{
+          mt: 0,
+          p: 1,
+          bgcolor: alpha(theme.palette.primary.main, 0.04),
+          borderRadius: 2,
+        }}
+      >
+        <ProxyControlSwitches
+          onError={handleError}
+          label={activeTab === "system" ? t("System Proxy") : t("Tun Mode")}
+        />
+      </Box>
+    </Box>
+  );
+};

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

@@ -0,0 +1,242 @@
+import { useTranslation } from "react-i18next";
+import { Typography, Stack, Divider, Chip, IconButton } from "@mui/material";
+import { InfoOutlined, SettingsOutlined } 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 { 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";
+
+export const SystemInfoCard = () => {
+  const { t } = useTranslation();
+  const { verge, patchVerge } = useVerge();
+  const navigate = useNavigate();
+
+  // 系统信息状态
+  const [systemState, setSystemState] = useState({
+    osInfo: "",
+    lastCheckUpdate: "-",
+  });
+
+  // 获取运行模式
+  const { data: runningMode = "sidecar", mutate: mutateRunningMode } = useSWR(
+    "getRunningMode",
+    getRunningMode,
+    { suspense: false, revalidateOnFocus: false }
+  );
+
+  // 是否以sidecar模式运行
+  const isSidecarMode = runningMode === "sidecar";
+
+  // 初始化系统信息
+  useEffect(() => {
+    // 获取系统信息
+    getSystemInfo()
+      .then((info) => {
+        const lines = info.split("\n");
+        if (lines.length > 0) {
+          const sysName = lines[0].split(": ")[1] || "";
+          const sysVersion = lines[1].split(": ")[1] || "";
+          setSystemState(prev => ({ ...prev, osInfo: `${sysName} ${sysVersion}` }));
+        }
+      })
+      .catch(console.error);
+
+    // 获取最后检查更新时间
+    const lastCheck = localStorage.getItem("last_check_update");
+    if (lastCheck) {
+      try {
+        const timestamp = parseInt(lastCheck, 10);
+        if (!isNaN(timestamp)) {
+          setSystemState(prev => ({ 
+            ...prev, 
+            lastCheckUpdate: new Date(timestamp).toLocaleString() 
+          }));
+        }
+      } catch (e) {
+        console.error("Error parsing last check update time", e);
+      }
+    } else if (verge?.auto_check_update) {
+      // 如果启用了自动检查更新但没有记录，设置当前时间并延迟检查
+      const now = Date.now();
+      localStorage.setItem("last_check_update", now.toString());
+      setSystemState(prev => ({ 
+        ...prev, 
+        lastCheckUpdate: new Date(now).toLocaleString() 
+      }));
+      
+      setTimeout(() => {
+        if (verge?.auto_check_update) {
+          checkUpdate().catch(console.error);
+        }
+      }, 5000);
+    }
+  }, [verge?.auto_check_update]);
+
+  // 自动检查更新逻辑
+  useSWR(
+    verge?.auto_check_update ? "checkUpdate" : null,
+    async () => {
+      const now = Date.now();
+      localStorage.setItem("last_check_update", now.toString());
+      setSystemState(prev => ({ 
+        ...prev, 
+        lastCheckUpdate: new Date(now).toLocaleString() 
+      }));
+      return await checkUpdate();
+    },
+    {
+      revalidateOnFocus: false,
+      refreshInterval: 24 * 60 * 60 * 1000, // 每天检查一次
+      dedupingInterval: 60 * 60 * 1000, // 1小时内不重复检查
+    }
+  );
+
+  // 导航到设置页面
+  const goToSettings = useCallback(() => {
+    navigate("/settings");
+  }, [navigate]);
+
+  // 切换自启动状态
+  const toggleAutoLaunch = useCallback(async () => {
+    if (!verge) return;
+    try {
+      await patchVerge({ enable_auto_launch: !verge.enable_auto_launch });
+    } catch (err) {
+      console.error("切换开机自启动状态失败:", err);
+    }
+  }, [verge, patchVerge]);
+
+  // 安装系统服务
+  const onInstallService = useLockFn(async () => {
+    try {
+      Notice.info(t("Installing Service..."), 1000);
+      await installService();
+      Notice.success(t("Service Installed Successfully"), 2000);
+      await mutateRunningMode();
+    } catch (err: any) {
+      Notice.error(err.message || err.toString(), 3000);
+    }
+  });
+
+  // 点击运行模式处理
+  const handleRunningModeClick = useCallback(() => {
+    if (isSidecarMode) {
+      onInstallService();
+    }
+  }, [isSidecarMode, onInstallService]);
+
+  // 检查更新
+  const onCheckUpdate = useLockFn(async () => {
+    try {
+      const info = await checkUpdate();
+      if (!info?.available) {
+        Notice.success(t("Currently on the Latest Version"));
+      } else {
+        Notice.info(t("Update Available"), 2000);
+        goToSettings();
+      }
+    } catch (err: any) {
+      Notice.error(err.message || err.toString());
+    }
+  });
+
+  // 是否启用自启动
+  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]);
+
+  // 只有当verge存在时才渲染内容
+  if (!verge) return null;
+
+  return (
+    <EnhancedCard
+      title={t("System Info")}
+      icon={<InfoOutlined />}
+      iconColor="error"
+      action={
+        <IconButton size="small" onClick={goToSettings} title={t("Settings")}>
+          <SettingsOutlined fontSize="small" />
+        </IconButton>
+      }
+    >
+      <Stack spacing={1.5}>
+        <Stack direction="row" justifyContent="space-between">
+          <Typography variant="body2" color="text.secondary">
+            {t("OS Info")}
+          </Typography>
+          <Typography variant="body2" fontWeight="medium">
+            {systemState.osInfo}
+          </Typography>
+        </Stack>
+        <Divider />
+        <Stack direction="row" justifyContent="space-between">
+          <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>
+        <Divider />
+        <Stack direction="row" justifyContent="space-between">
+          <Typography variant="body2" color="text.secondary">
+            {t("Running Mode")}
+          </Typography>
+          <Typography
+            variant="body2"
+            fontWeight="medium"
+            onClick={handleRunningModeClick}
+            sx={runningModeStyle}
+          >
+            {isSidecarMode ? t("Sidecar Mode") : t("Service Mode")}
+          </Typography>
+        </Stack>
+        <Divider />
+        <Stack direction="row" justifyContent="space-between">
+          <Typography variant="body2" color="text.secondary">
+            {t("Last Check Update")}
+          </Typography>
+          <Typography
+            variant="body2"
+            fontWeight="medium"
+            onClick={onCheckUpdate}
+            sx={{
+              cursor: "pointer",
+              textDecoration: "underline",
+              "&:hover": { opacity: 0.7 },
+            }}
+          >
+            {systemState.lastCheckUpdate}
+          </Typography>
+        </Stack>
+        <Divider />
+        <Stack direction="row" justifyContent="space-between">
+          <Typography variant="body2" color="text.secondary">
+            {t("Verge Version")}
+          </Typography>
+          <Typography variant="body2" fontWeight="medium">
+            v{appVersion}
+          </Typography>
+        </Stack>
+      </Stack>
+    </EnhancedCard>
+  );
+};

src/components/home/test-card.tsx

@@ -0,0 +1,193 @@
+import { useEffect, useRef, useMemo, useCallback } from "react";
+import { useVerge } from "@/hooks/use-verge";
+import { Box, IconButton, Tooltip, alpha, styled } from "@mui/material";
+import Grid from "@mui/material/Grid2";
+import {
+  DndContext,
+  closestCenter,
+  PointerSensor,
+  useSensor,
+  useSensors,
+  DragEndEvent,
+} from "@dnd-kit/core";
+import { SortableContext } from "@dnd-kit/sortable";
+
+import { useTranslation } from "react-i18next";
+import { TestViewer, TestViewerRef } from "@/components/test/test-viewer";
+import { TestItem } from "@/components/test/test-item";
+import { emit } from "@tauri-apps/api/event";
+import { nanoid } from "nanoid";
+import { Add, NetworkCheck } from "@mui/icons-material";
+import { EnhancedCard } from "./enhanced-card";
+
+// test icons
+import apple from "@/assets/image/test/apple.svg?raw";
+import github from "@/assets/image/test/github.svg?raw";
+import google from "@/assets/image/test/google.svg?raw";
+import youtube from "@/assets/image/test/youtube.svg?raw";
+
+// 自定义滚动条样式
+const ScrollBox = styled(Box)(({ theme }) => ({
+  maxHeight: "180px",
+  overflowY: "auto",
+  overflowX: "hidden",
+  "&::-webkit-scrollbar": {
+    width: "6px",
+  },
+  "&::-webkit-scrollbar-thumb": {
+    backgroundColor: alpha(theme.palette.text.primary, 0.2),
+    borderRadius: "3px",
+  },
+}));
+
+// 默认测试列表，移到组件外部避免重复创建
+const DEFAULT_TEST_LIST = [
+  {
+    uid: nanoid(),
+    name: "Apple",
+    url: "https://www.apple.com",
+    icon: apple,
+  },
+  {
+    uid: nanoid(),
+    name: "GitHub",
+    url: "https://www.github.com",
+    icon: github,
+  },
+  {
+    uid: nanoid(),
+    name: "Google",
+    url: "https://www.google.com",
+    icon: google,
+  },
+  {
+    uid: nanoid(),
+    name: "Youtube",
+    url: "https://www.youtube.com",
+    icon: youtube,
+  },
+];
+
+export const TestCard = () => {
+  const { t } = useTranslation();
+  const sensors = useSensors(useSensor(PointerSensor));
+  const { verge, mutateVerge, patchVerge } = useVerge();
+  const viewerRef = useRef<TestViewerRef>(null);
+
+  // 使用useMemo优化测试列表，避免每次渲染重新计算
+  const testList = useMemo(() => {
+    return verge?.test_list ?? DEFAULT_TEST_LIST;
+  }, [verge?.test_list]);
+
+  // 使用useCallback优化函数引用，避免不必要的重新渲染
+  const onTestListItemChange = useCallback(
+    (uid: string, patch?: Partial<IVergeTestItem>) => {
+      if (!patch) {
+        mutateVerge();
+        return;
+      }
+      
+      const newList = testList.map((x) => 
+        x.uid === uid ? { ...x, ...patch } : x
+      );
+      
+      mutateVerge({ ...verge, test_list: newList }, false);
+    },
+    [testList, verge, mutateVerge]
+  );
+
+  const onDeleteTestListItem = useCallback(
+    (uid: string) => {
+      const newList = testList.filter((x) => x.uid !== uid);
+      patchVerge({ test_list: newList });
+      mutateVerge({ ...verge, test_list: newList }, false);
+    },
+    [testList, verge, patchVerge, mutateVerge]
+  );
+
+  const onDragEnd = useCallback(
+    async (event: DragEndEvent) => {
+      const { active, over } = event;
+      if (!over || active.id === over.id) return;
+      
+      const old_index = testList.findIndex((x) => x.uid === active.id);
+      const new_index = testList.findIndex((x) => x.uid === over.id);
+      
+      if (old_index >= 0 && new_index >= 0) {
+        const newList = [...testList];
+        const [removed] = newList.splice(old_index, 1);
+        newList.splice(new_index, 0, removed);
+
+        await mutateVerge({ ...verge, test_list: newList }, false);
+        await patchVerge({ test_list: newList });
+      }
+    },
+    [testList, verge, mutateVerge, patchVerge]
+  );
+
+  // 仅在verge首次加载时初始化测试列表
+  useEffect(() => {
+    if (verge && !verge.test_list) {
+      patchVerge({ test_list: DEFAULT_TEST_LIST });
+    }
+  }, [verge, patchVerge]);
+
+  // 使用useMemo优化UI内容，减少渲染计算
+  const renderTestItems = useMemo(() => (
+    <Grid container spacing={1} columns={12}>
+      <SortableContext items={testList.map((x) => x.uid)}>
+        {testList.map((item) => (
+          <Grid key={item.uid} size={3}>
+            <TestItem
+              id={item.uid}
+              itemData={item}
+              onEdit={() => viewerRef.current?.edit(item)}
+              onDelete={onDeleteTestListItem}
+            />
+          </Grid>
+        ))}
+      </SortableContext>
+    </Grid>
+  ), [testList, onDeleteTestListItem]);
+
+  const handleTestAll = useCallback(() => {
+    emit("verge://test-all");
+  }, []);
+
+  const handleCreateTest = useCallback(() => {
+    viewerRef.current?.create();
+  }, []);
+
+  return (
+    <EnhancedCard
+      title={t("Website Tests")}
+      icon={<NetworkCheck />}
+      action={
+        <Box sx={{ display: "flex", gap: 1 }}>
+          <Tooltip title={t("Test All")} arrow>
+            <IconButton size="small" onClick={handleTestAll}>
+              <NetworkCheck fontSize="small" />
+            </IconButton>
+          </Tooltip>
+          <Tooltip title={t("Create Test")} arrow>
+            <IconButton size="small" onClick={handleCreateTest}>
+              <Add fontSize="small" />
+            </IconButton>
+          </Tooltip>
+        </Box>
+      }
+    >
+      <ScrollBox>
+        <DndContext
+          sensors={sensors}
+          collisionDetection={closestCenter}
+          onDragEnd={onDragEnd}
+        >
+          {renderTestItems}
+        </DndContext>
+      </ScrollBox>
+
+      <TestViewer ref={viewerRef} onChange={onTestListItemChange} />
+    </EnhancedCard>
+  );
+};

src/components/profile/profile-item.tsx

@@ -81,7 +81,7 @@ export const ProfileItem = (props: Props) => {
   const expire = parseExpire(extra?.expire);
   const progress = Math.min(
     Math.round(((download + upload) * 100) / (total + 0.01)) + 1,
-    100
+    100,
   );
 
   const loading = loadingCache[itemData.uid] ?? false;
@@ -202,11 +202,12 @@ 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+?): /, "")
+        errmsg.replace(/error sending request for url (\S+?): /, ""),
       );
     } finally {
       setLoadingCache((cache) => ({ ...cache, [itemData.uid]: false }));

src/components/proxy/proxy-head.tsx

@@ -57,7 +57,7 @@ export const ProxyHead = (props: Props) => {
       <IconButton
         size="small"
         color="inherit"
-        title={t("Location")}
+        title={t("locate")}
         onClick={props.onLocation}
       >
         <MyLocationRounded />

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

@@ -0,0 +1,144 @@
+import { forwardRef, useImperativeHandle, useState } from "react";
+import { useLockFn } from "ahooks";
+import { useTranslation } from "react-i18next";
+import {
+  List,
+  ListItem,
+  ListItemText,
+  TextField,
+  Typography,
+  InputAdornment,
+} from "@mui/material";
+import { useVerge } from "@/hooks/use-verge";
+import { BaseDialog, DialogRef, Notice, Switch } from "@/components/base";
+import { TooltipIcon } from "@/components/base/base-tooltip-icon";
+import { entry_lightweight_mode } from "@/services/cmds";
+
+export const LiteModeViewer = forwardRef<DialogRef>((props, ref) => {
+  const { t } = useTranslation();
+  const { verge, patchVerge } = useVerge();
+
+  const [open, setOpen] = useState(false);
+  const [values, setValues] = useState({
+    autoEnterLiteMode: false,
+    autoEnterLiteModeDelay: 10, // 默认10分钟
+  });
+
+  useImperativeHandle(ref, () => ({
+    open: () => {
+      setOpen(true);
+      setValues({
+        autoEnterLiteMode: verge?.enable_auto_light_weight_mode ?? false,
+        autoEnterLiteModeDelay: verge?.auto_light_weight_minutes ?? 10,
+      });
+    },
+    close: () => setOpen(false),
+  }));
+
+  const onSave = useLockFn(async () => {
+    try {
+      await patchVerge({
+        enable_auto_light_weight_mode: values.autoEnterLiteMode,
+        auto_light_weight_minutes: values.autoEnterLiteModeDelay,
+      });
+      setOpen(false);
+    } catch (err: any) {
+      Notice.error(err.message || err.toString());
+    }
+  });
+
+  return (
+    <BaseDialog
+      open={open}
+      title={t("LightWeight Mode Settings")}
+      contentSx={{ width: 450 }}
+      okBtn={t("Save")}
+      cancelBtn={t("Cancel")}
+      onClose={() => setOpen(false)}
+      onCancel={() => setOpen(false)}
+      onOk={onSave}
+    >
+      <List>
+        <ListItem sx={{ padding: "5px 2px" }}>
+          <ListItemText primary={t("Enter LightWeight Mode Now")} />
+          <Typography
+            variant="button"
+            sx={{
+              cursor: "pointer",
+              color: "primary.main",
+              "&:hover": { textDecoration: "underline" },
+            }}
+            onClick={async () => await entry_lightweight_mode()}
+          >
+            {t("Enable")}
+          </Typography>
+        </ListItem>
+
+        <ListItem sx={{ padding: "5px 2px" }}>
+          <ListItemText
+            primary={t("Auto Enter LightWeight Mode")}
+            sx={{ maxWidth: "fit-content" }}
+          />
+          <TooltipIcon
+            title={t("Auto Enter LightWeight Mode Info")}
+            sx={{ opacity: "0.7" }}
+          />
+          <Switch
+            edge="end"
+            checked={values.autoEnterLiteMode}
+            onChange={(_, c) =>
+              setValues((v) => ({ ...v, autoEnterLiteMode: c }))
+            }
+            sx={{ marginLeft: "auto" }}
+          />
+        </ListItem>
+
+        {values.autoEnterLiteMode && (
+          <>
+            <ListItem sx={{ padding: "5px 2px" }}>
+              <ListItemText primary={t("Auto Enter LightWeight Mode Delay")} />
+              <TextField
+                autoComplete="off"
+                size="small"
+                type="number"
+                autoCorrect="off"
+                autoCapitalize="off"
+                spellCheck="false"
+                sx={{ width: 150 }}
+                value={values.autoEnterLiteModeDelay}
+                onChange={(e) =>
+                  setValues((v) => ({
+                    ...v,
+                    autoEnterLiteModeDelay: parseInt(e.target.value) || 1,
+                  }))
+                }
+                slotProps={{
+                  input: {
+                    endAdornment: (
+                      <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>
+            </ListItem>
+          </>
+        )}
+      </List>
+    </BaseDialog>
+  );
+});