chore(deps): update dependency i18next to ^25.6.1

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

.github/workflows/autobuild.yml

@@ -90,7 +90,7 @@ jobs:
 
           ### Windows (不再支持Win7)
           #### 正常版本(推荐)
-          - [64位(常用)](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_x64-setup_windows.exe) | [ARM64(不常用)](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_arm64-setup.exe)
+          - [64位(常用)](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_x64-setup_windows.exe) | [ARM64(不常用)](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_arm64-setup_windows.exe)
 
           #### 内置Webview2版(体积较大，仅在企业版系统或无法安装webview2时使用)
           - [64位](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_x64_fixed_webview2-setup.exe) | [ARM64](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_arm64_fixed_webview2-setup.exe)
@@ -103,7 +103,7 @@ jobs:
           - [64位](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_amd64_linux.deb) | [ARM64](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_arm64.deb) | [ARMv7](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_armhf.deb)
 
           #### RPM包(Redhat系) 使用 dnf ./路径 安装
-          - [64位](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}-1.x86_64_linux.rpm) | [ARM64](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}-1.aarch64.rpm) | [ARMv7](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}-1.armhfp.rpm)
+          - [64位](${{ env.DOWNLOAD_URL }}/Clash.Verge-${{ env.VERSION }}-1.x86_64_linux.rpm) | [ARM64](${{ env.DOWNLOAD_URL }}/Clash.Verge-${{ env.VERSION }}-1.aarch64.rpm) | [ARMv7](${{ env.DOWNLOAD_URL }}/Clash.Verge-${{ env.VERSION }}-1.armhfp.rpm)
 
           ### FAQ
           - [常见问题](https://clash-verge-rev.github.io/faq/windows.html)
@@ -169,7 +169,8 @@ jobs:
           workspaces: src-tauri
           cache-all-crates: true
           save-if: ${{ github.ref == 'refs/heads/dev' }}
-          shared-key: autobuild-shared
+          shared-key: autobuild-${{ runner.os }}-${{ matrix.target }}
+          key: ${{ runner.os }}-${{ matrix.target }}-${{ hashFiles('src-tauri/Cargo.lock') }}
 
       - name: Install dependencies (ubuntu only)
         if: matrix.os == 'ubuntu-22.04'
@@ -197,6 +198,14 @@ jobs:
           node-version: "22"
           cache: "pnpm"
 
+      - name: Cache pnpm store
+        uses: actions/cache@v4
+        with:
+          path: ~/.pnpm-store
+          key: ${{ runner.os }}-pnpm-${{ hashFiles('pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-
+
       - name: Pnpm install and check
         run: |
           pnpm i
@@ -259,7 +268,8 @@ jobs:
           workspaces: src-tauri
           cache-all-crates: true
           save-if: ${{ github.ref == 'refs/heads/dev' }}
-          shared-key: autobuild-shared
+          shared-key: autobuild-${{ runner.os }}-${{ matrix.target }}
+          key: ${{ runner.os }}-${{ matrix.target }}-${{ hashFiles('src-tauri/Cargo.lock') }}
 
       - name: Install pnpm
         uses: pnpm/action-setup@v4
@@ -272,6 +282,14 @@ jobs:
           node-version: "22"
           cache: "pnpm"
 
+      - name: Cache pnpm store
+        uses: actions/cache@v4
+        with:
+          path: ~/.pnpm-store
+          key: ${{ runner.os }}-pnpm-${{ hashFiles('pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-
+
       - name: Pnpm install and check
         run: |
           pnpm i
@@ -391,7 +409,8 @@ jobs:
           workspaces: src-tauri
           cache-all-crates: true
           save-if: ${{ github.ref == 'refs/heads/dev' }}
-          shared-key: autobuild-shared
+          shared-key: autobuild-${{ runner.os }}-${{ matrix.target }}
+          key: ${{ runner.os }}-${{ matrix.target }}-${{ hashFiles('src-tauri/Cargo.lock') }}
 
       - name: Install pnpm
         uses: pnpm/action-setup@v4
@@ -404,6 +423,14 @@ jobs:
           node-version: "22"
           cache: "pnpm"
 
+      - name: Cache pnpm store
+        uses: actions/cache@v4
+        with:
+          path: ~/.pnpm-store
+          key: ${{ runner.os }}-pnpm-${{ hashFiles('pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-
+
       - name: Pnpm install and check
         run: |
           pnpm i
@@ -538,7 +565,7 @@ jobs:
 
           ### Windows (不再支持Win7)
           #### 正常版本(推荐)
-          - [64位(常用)](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_x64-setup_windows.exe) | [ARM64(不常用)](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_arm64-setup.exe)
+          - [64位(常用)](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_x64-setup_windows.exe) | [ARM64(不常用)](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_arm64-setup_windows.exe)
 
           #### 内置Webview2版(体积较大，仅在企业版系统或无法安装webview2时使用)
           - [64位](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_x64_fixed_webview2-setup.exe) | [ARM64](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_arm64_fixed_webview2-setup.exe)
@@ -551,7 +578,7 @@ jobs:
           - [64位](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_amd64_linux.deb) | [ARM64](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_arm64.deb) | [ARMv7](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_armhf.deb)
 
           #### RPM包(Redhat系) 使用 dnf ./路径 安装
-          - [64位](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}-1.x86_64_linux.rpm) | [ARM64](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}-1.aarch64.rpm) | [ARMv7](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}-1.armhfp.rpm)
+          - [64位](${{ env.DOWNLOAD_URL }}/Clash.Verge-${{ env.VERSION }}-1.x86_64_linux.rpm) | [ARM64](${{ env.DOWNLOAD_URL }}/Clash.Verge-${{ env.VERSION }}-1.aarch64.rpm) | [ARMv7](${{ env.DOWNLOAD_URL }}/Clash.Verge-${{ env.VERSION }}-1.armhfp.rpm)
 
           ### FAQ
           - [常见问题](https://clash-verge-rev.github.io/faq/windows.html)

.github/workflows/lint-clippy.yml

@@ -59,9 +59,10 @@ jobs:
         uses: Swatinem/rust-cache@v2
         with:
           workspaces: src-tauri
+          cache-all-crates: true
           save-if: false
-          cache-all-crates: false
-          shared-key: autobuild-shared
+          shared-key: autobuild-${{ runner.os }}-${{ matrix.target }}
+          key: ${{ runner.os }}-${{ matrix.target }}-${{ hashFiles('src-tauri/Cargo.lock') }}
 
       - name: Install dependencies (ubuntu only)
         if: matrix.os == 'ubuntu-22.04'
@@ -72,3 +73,10 @@ jobs:
       - name: Run Clippy
         working-directory: ./src-tauri
         run: cargo clippy-all
+
+      - name: Run Logging Check
+        working-directory: ./src-tauri
+        shell: bash
+        run: |
+          cargo install --git https://github.com/clash-verge-rev/clash-verge-logging-check.git
+          clash-verge-logging-check

.husky/pre-commit

@@ -27,6 +27,11 @@ if [ -n "$RUST_FILES" ]; then
   (
     cd src-tauri
     cargo clippy-all
+    if ! command -v clash-verge-logging-check >/dev/null 2>&1; then
+      echo "[pre-commit] Installing clash-verge-logging-check..."
+      cargo install --git https://github.com/clash-verge-rev/clash-verge-logging-check.git
+    fi
+    clash-verge-logging-check
   )
 fi
 

CONTRIBUTING.md

@@ -2,6 +2,10 @@
 
 Thank you for your interest in contributing to Clash Verge Rev! This document provides guidelines and instructions to help you set up your development environment and start contributing.
 
+## Internationalization (i18n)
+
+We welcome translations and improvements to existing locales. Please follow the detailed guidelines in [CONTRIBUTING_i18n.md](docs/CONTRIBUTING_i18n.md) for instructions on extracting strings, file naming conventions, testing translations, and submitting translation PRs.
+
 ## Development Setup
 
 Before you start contributing to the project, you need to set up your development environment. Here are the steps you need to follow:

UPDATELOG.md

@@ -1,6 +1,45 @@
 ## v2.4.3
 
-### ✨ 新增功能
+感谢 @Slinetrac, @oomeow, @Lythrilla, @Dragon1573 的出色贡献
+
+### 🐞 修复问题
+
+- 优化服务模式重装逻辑，避免不必要的重复检查
+- 修复轻量模式退出无响应的问题
+- 修复托盘轻量模式支持退出/进入
+- 修复静默启动和自动进入轻量模式时，托盘状态刷新不再依赖窗口创建流程
+- macOS Tun/系统代理 模式下图标大小不统一
+- 托盘节点切换不再显示隐藏组
+- 修复前端 IP 检测无法使用 ipapi, ipsb 提供商
+- 修复MacOS 下 Tun开启后 系统代理无法打开的问题
+- 修复服务模式启动时，修改、生成配置文件或重启内核可能导致页面卡死的问题
+- 修复 Webdav 恢复备份不重启
+- 修复 Linux 开机后无法正常代理需要手动设置
+- 修复增加订阅或导入订阅文件时订阅页面无更新
+- 修复系统代理守卫功能不工作
+- 修复 KDE + Wayland 下多屏显示 UI 异常
+- 修复 Windows 深色模式下首次启动客户端标题栏颜色异常
+- 修复静默启动不加载完整 WebView 的问题
+- 修复 Linux WebKit 网络进程的崩溃
+- 修复无法导入订阅
+- 修复实际导入成功但显示导入失败的问题
+- 修复服务不可用时，自动关闭 Tun 模式导致应用卡死问题
+- 修复删除订阅时未能实际删除相关文件
+- 修复 macOS 连接界面显示异常
+- 修复规则配置项在不同配置文件间全局共享导致切换被重置的问题
+- 修复 Linux Wayland 下部分 GPU 可能出现的 UI 渲染问题
+- 修复自动更新使版本回退的问题
+- 修复首页自定义卡片在切换轻量模式时失效
+- 修复悬浮跳转导航失效
+- 修复小键盘热键映射错误
+- 修复前端无法及时刷新操作状态
+- 修复 macOS 从 Dock 栏退出轻量模式状态不同步
+- 修复 Linux 系统主题切换不生效
+- 修复 `允许自动更新` 字段使手动订阅刷新失效
+- 修复轻量模式托盘状态不同步
+
+<details>
+<summary><strong> ✨ 新增功能 </strong></summary>
 
 - **Mihomo(Meta) 内核升级至 v1.19.15**
 - 支持前端修改日志（最大文件大小、最大保留数量）
@@ -15,8 +54,11 @@
 - 允许独立控制订阅自动更新
 - 托盘 `更多` 中新增 `关闭所有连接` 按钮
 - 新增左侧菜单栏的排序功能（右键点击左侧菜单栏）
+- 托盘 `打开目录` 中新增 `应用日志` 和 `内核日志`
+</details>
 
-### 🚀 优化改进
+<details>
+<summary><strong> 🚀 优化改进 </strong></summary>
 
 - 重构并简化服务模式启动检测流程，消除重复检测
 - 重构并简化窗口创建流程
@@ -43,36 +85,11 @@
 - 允许在 `界面设置` 修改 `悬浮跳转导航延迟`
 - 添加热键绑定错误的提示信息
 - 在 macOS 10.15 及更高版本默认包含 Mihomo-go122，以解决 Intel 架构 Mac 无法运行内核的问题
+- Tun 模式不可用时，禁用系统托盘的 Tun 模式菜单
+- 改进订阅更新方式，仍失败需打开订阅设置 `允许危险证书`
+- 允许设置 Mihomo 端口范围 1000(含) - 65536(含)
 
-### 🐞 修复问题
-
-- 优化服务模式重装逻辑，避免不必要的重复检查
-- 修复轻量模式退出无响应的问题
-- 修复托盘轻量模式支持退出/进入
-- 修复静默启动和自动进入轻量模式时，托盘状态刷新不再依赖窗口创建流程
-- macOS Tun/系统代理 模式下图标大小不统一
-- 托盘节点切换不再显示隐藏组
-- 修复前端 IP 检测无法使用 ipapi, ipsb 提供商
-- 修复MacOS 下 Tun开启后 系统代理无法打开的问题
-- 修复服务模式启动时，修改、生成配置文件或重启内核可能导致页面卡死的问题
-- 修复 Webdav 恢复备份不重启
-- 修复 Linux 开机后无法正常代理需要手动设置
-- 修复增加订阅或导入订阅文件时订阅页面无更新
-- 修复系统代理守卫功能不工作
-- 修复 KDE + Wayland 下多屏显示 UI 异常
-- 修复 Windows 深色模式下首次启动客户端标题栏颜色异常
-- 修复静默启动不加载完整 WebView 的问题
-- 修复 Linux WebKit 网络进程的崩溃
-- 修复无法导入订阅
-- 修复实际导入成功但显示导入失败的问题
-- 修复删除订阅时未能实际删除相关文件
-- 修复 macOS 连接界面显示异常
-- 修复规则配置项在不同配置文件间全局共享导致切换被重置的问题
-- 修复 Linux Wayland 下部分 GPU 可能出现的 UI 渲染问题
-- 修复自动更新使版本回退的问题
-- 修复首页自定义卡片在切换轻量模式时失效
-- 修复悬浮跳转导航失效
-- 修复小键盘热键映射错误
+</details>
 
 ## v2.4.2
 

docs/CONTRIBUTING_i18n.md

@@ -0,0 +1,81 @@
+# CONTRIBUTING — i18n
+
+Thank you for considering contributing to our localization work — your help is appreciated.
+
+Quick overview
+
+- cvr-i18 is a CLI that helps manage simple top-level JSON locale files:
+  - Detect duplicated top-level keys
+  - Find keys missing versus a base file (default: en.json)
+  - Export missing entries for translators
+  - Reorder keys to match the base file for predictable diffs
+  - Operate on a directory or a single file
+
+Get the CLI (No binary provided yet)
+
+```bash
+git clone https://github.com/clash-verge-rev/clash-verge-rev-i18n-cli
+cd clash-verge-rev-i18n-cli
+cargo install --path .
+# or
+cargo install --git https://github.com/clash-verge-rev/clash-verge-rev-i18n-cli
+```
+
+Common commands
+
+- Show help: `cvr-i18`
+- Directory (auto-detects `./locales` or `./src/locales`): `cvr-i18 -d /path/to/locales`
+- Check duplicates: `cvr-i18 -k`
+- Check missing keys: `cvr-i18 -m`
+- Export missing keys: `cvr-i18 -m -e ./exports`
+- Sort keys to base file: `cvr-i18 -s`
+- Use a base file: `cvr-i18 -b base.json`
+- Single file: `cvr-i18 -f locales/zh.json`
+
+Options (short)
+
+- `-d, --directory <DIR>`
+- `-f, --file <FILE>`
+- `-k, --duplicated-key`
+- `-m, --missing-key`
+- `-e, --export <DIR>`
+- `-s, --sort`
+- `-b, --base <FILE>`
+
+Exit codes
+
+- `0` — success (no issues)
+- `1` — issues found (duplicates/missing)
+- `2` — error (IO/parse/runtime)
+
+How to contribute (recommended steps)
+
+- Start small: fix typos, improve phrasing, or refine tone and consistency.
+- Run the CLI against your locale files to detect duplicates or missing keys.
+- Export starter JSONs for translators with `-m -e <DIR>`.
+- Prefer incremental PRs or draft PRs; leave a comment on the issue if you want guidance.
+- Open an issue to report missing strings, UI context, or localization bugs.
+- Add or improve docs and tests to make future contributions easier.
+
+PR checklist
+
+- Keep JSON files UTF-8 encoded.
+- Follow the repo’s locale file structure and naming conventions.
+- Reorder keys to match the base file (`-s`) for minimal diffs.
+- Test translations in a local dev build before opening a PR.
+- Reference related issues and explain any context for translations or changes.
+
+Notes
+
+- The tool expects simple top-level JSON key/value maps.
+- Exported JSONs are starter files for translators (fill in values, keep keys).
+- Sorting keeps diffs consistent and reviewable.
+
+Repository
+https://github.com/clash-verge-rev/clash-verge-rev-i18n-cli
+
+## Feedback & Contributions
+
+- For tool usage issues or feedback: please open an Issue in the [repository](https://github.com/clash-verge-rev/clash-verge-rev-i18n-cli) so it can be tracked and addressed.
+- For localization contributions (translations, fixes, context notes, etc.): submit a PR or Issue in this repository and include examples, context, and testing instructions when possible.
+- If you need help or a review, leave a comment on your submission requesting assistance.

package.json

@@ -26,8 +26,8 @@
     "publish-version": "node scripts/publish-version.mjs",
     "fmt": "cargo fmt --manifest-path ./src-tauri/Cargo.toml",
     "clippy": "cargo clippy --all-features --all-targets --manifest-path ./src-tauri/Cargo.toml",
-    "lint": "eslint -c eslint.config.ts --cache --cache-location .eslintcache src",
-    "lint:fix": "eslint -c eslint.config.ts --cache --cache-location .eslintcache --fix src",
+    "lint": "eslint -c eslint.config.ts --max-warnings=0 --cache --cache-location .eslintcache src",
+    "lint:fix": "eslint -c eslint.config.ts --max-warnings=0 --cache --cache-location .eslintcache --fix src",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
     "typecheck": "tsc --noEmit",
@@ -40,10 +40,10 @@
     "@emotion/react": "^11.14.0",
     "@emotion/styled": "^11.14.1",
     "@juggle/resize-observer": "^3.4.0",
-    "@mui/icons-material": "^7.3.4",
+    "@mui/icons-material": "^7.3.5",
     "@mui/lab": "7.0.0-beta.17",
-    "@mui/material": "^7.3.4",
-    "@mui/x-data-grid": "^8.15.0",
+    "@mui/material": "^7.3.5",
+    "@mui/x-data-grid": "^8.17.0",
     "@tauri-apps/api": "2.9.0",
     "@tauri-apps/plugin-clipboard-manager": "^2.3.2",
     "@tauri-apps/plugin-dialog": "^2.4.2",
@@ -54,10 +54,10 @@
     "@tauri-apps/plugin-updater": "2.9.0",
     "@types/json-schema": "^7.0.15",
     "ahooks": "^3.9.6",
-    "axios": "^1.13.1",
-    "dayjs": "1.11.18",
+    "axios": "^1.13.2",
+    "dayjs": "1.11.19",
     "foxact": "^0.2.49",
-    "i18next": "^25.6.0",
+    "i18next": "^25.6.1",
     "js-yaml": "^4.1.0",
     "json-schema": "^0.4.0",
     "lodash-es": "^4.17.21",
@@ -67,34 +67,33 @@
     "react": "19.2.0",
     "react-dom": "19.2.0",
     "react-error-boundary": "6.0.0",
-    "react-hook-form": "^7.65.0",
-    "react-i18next": "16.2.1",
+    "react-hook-form": "^7.66.0",
+    "react-i18next": "16.2.4",
     "react-markdown": "10.1.0",
     "react-monaco-editor": "0.59.0",
-    "react-router": "^7.9.4",
+    "react-router": "^7.9.5",
     "react-virtuoso": "^4.14.1",
     "swr": "^2.3.6",
     "tauri-plugin-mihomo-api": "git+https://github.com/clash-verge-rev/tauri-plugin-mihomo",
-    "types-pac": "^1.0.3",
-    "zustand": "^5.0.8"
+    "types-pac": "^1.0.3"
   },
   "devDependencies": {
     "@actions/github": "^6.0.1",
-    "@eslint-react/eslint-plugin": "^2.2.4",
-    "@eslint/js": "^9.38.0",
-    "@tauri-apps/cli": "2.9.1",
+    "@eslint-react/eslint-plugin": "^2.3.1",
+    "@eslint/js": "^9.39.1",
+    "@tauri-apps/cli": "2.9.3",
     "@types/js-yaml": "^4.0.9",
     "@types/lodash-es": "^4.17.12",
-    "@types/node": "^24.9.2",
+    "@types/node": "^24.10.0",
     "@types/react": "19.2.2",
     "@types/react-dom": "19.2.2",
     "@vitejs/plugin-legacy": "^7.2.1",
-    "@vitejs/plugin-react": "5.1.0",
+    "@vitejs/plugin-react-swc": "^4.2.1",
     "adm-zip": "^0.5.16",
     "cli-color": "^2.0.4",
     "commander": "^14.0.2",
     "cross-env": "^10.1.0",
-    "eslint": "^9.38.0",
+    "eslint": "^9.39.1",
     "eslint-config-prettier": "^10.1.8",
     "eslint-import-resolver-typescript": "^4.4.4",
     "eslint-plugin-import-x": "^4.16.1",
@@ -103,7 +102,7 @@
     "eslint-plugin-react-refresh": "^0.4.24",
     "eslint-plugin-unused-imports": "^4.3.0",
     "glob": "^11.0.3",
-    "globals": "^16.4.0",
+    "globals": "^16.5.0",
     "https-proxy-agent": "^7.0.6",
     "husky": "^9.1.7",
     "jiti": "^2.6.1",
@@ -111,19 +110,19 @@
     "meta-json-schema": "^1.19.14",
     "node-fetch": "^3.3.2",
     "prettier": "^3.6.2",
-    "sass": "^1.93.2",
-    "tar": "^7.5.1",
-    "terser": "^5.44.0",
+    "sass": "^1.93.3",
+    "tar": "^7.5.2",
+    "terser": "^5.44.1",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.46.2",
-    "vite": "^7.1.12",
-    "vite-plugin-monaco-editor": "^1.1.0",
+    "typescript-eslint": "^8.46.3",
+    "vite": "^7.2.1",
+    "vite-plugin-monaco-editor-esm": "^2.0.2",
     "vite-plugin-svgr": "^4.5.0",
-    "vitest": "^4.0.4"
+    "vitest": "^4.0.7"
   },
   "lint-staged": {
     "*.{ts,tsx,js,jsx}": [
-      "eslint --fix",
+      "eslint --fix --max-warnings=0",
       "prettier --write",
       "git add"
     ],

renovate.json

@@ -42,6 +42,6 @@
       "groupName": "github actions"
     }
   ],
-  "postUpdateOptions": ["pnpmDedupe"],
+  "postUpdateOptions": ["pnpmDedupe", "updateCargoLock"],
   "ignoreDeps": ["criterion"]
 }

scripts/telegram.mjs

@@ -1,6 +1,6 @@
 import axios from "axios";
 import { readFileSync } from "fs";
-import { log_success, log_error, log_info } from "./utils.mjs";
+import { log_error, log_info, log_success } from "./utils.mjs";
 
 const CHAT_ID_RELEASE = "@clash_verge_re"; // 正式发布频道
 const CHAT_ID_TEST = "@vergetest"; // 测试频道
@@ -71,6 +71,19 @@ async function sendTelegramNotification() {
       .join("\n");
   }
 
+  function normalizeDetailsTags(content) {
+    return content
+      .replace(
+        /<summary>\s*<strong>\s*(.*?)\s*<\/strong>\s*<\/summary>/g,
+        "\n<b>$1</b>\n",
+      )
+      .replace(/<summary>\s*(.*?)\s*<\/summary>/g, "\n<b>$1</b>\n")
+      .replace(/<\/?details>/g, "")
+      .replace(/<\/?strong>/g, (m) => (m === "</strong>" ? "</b>" : "<b>"))
+      .replace(/<br\s*\/?>/g, "\n");
+  }
+
+  releaseContent = normalizeDetailsTags(releaseContent);
   const formattedContent = convertMarkdownToTelegramHTML(releaseContent);
 
   const releaseTitle = isAutobuild ? "滚动更新版发布" : "正式发布";

src-tauri/Cargo.toml

@@ -18,7 +18,6 @@ tauri-build = { version = "2.5.1", features = [] }
 [dependencies]
 warp = { version = "0.4.2", features = ["server"] }
 anyhow = "1.0.100"
-dirs = "6.0"
 open = "5.3.2"
 log = "0.4.28"
 dunce = "1.0.5"
@@ -43,7 +42,7 @@ serde = { version = "1.0.228", features = ["derive"] }
 reqwest = { version = "0.12.24", features = ["json", "cookies"] }
 regex = "1.12.2"
 sysproxy = { git = "https://github.com/clash-verge-rev/sysproxy-rs" }
-tauri = { version = "2.9.1", features = [
+tauri = { version = "2.9.2", features = [
   "protocol-asset",
   "devtools",
   "tray-icon",
@@ -67,11 +66,7 @@ futures = "0.3.31"
 sys-locale = "0.3.2"
 libc = "0.2.177"
 gethostname = "1.1.0"
-hmac = "0.12.1"
-sha2 = "0.10.9"
-hex = "0.4.3"
 scopeguard = "1.2.0"
-dashmap = "6.1.0"
 tauri-plugin-notification = "2.3.3"
 tokio-stream = "0.1.17"
 isahc = { version = "1.7.2", default-features = false, features = [
@@ -82,15 +77,16 @@ backoff = { version = "0.4.0", features = ["tokio"] }
 compact_str = { version = "0.9.0", features = ["serde"] }
 tauri-plugin-http = "2.5.4"
 flexi_logger = "0.31.7"
-console-subscriber = { version = "0.4.1", optional = true }
+console-subscriber = { version = "0.5.0", optional = true }
 tauri-plugin-devtools = { version = "2.0.1" }
 tauri-plugin-mihomo = { git = "https://github.com/clash-verge-rev/tauri-plugin-mihomo" }
 clash_verge_logger = { git = "https://github.com/clash-verge-rev/clash-verge-logger" }
 async-trait = "0.1.89"
 smartstring = { version = "1.0.1", features = ["serde"] }
-clash_verge_service_ipc = { version = "2.0.20", features = [
+clash_verge_service_ipc = { version = "2.0.21", features = [
   "client",
 ], git = "https://github.com/clash-verge-rev/clash-verge-service-ipc" }
+arc-swap = "1.7.1"
 
 [target.'cfg(windows)'.dependencies]
 runas = "=1.2.0"
@@ -230,3 +226,23 @@ needless_raw_string_hashes = "deny" # Too many in existing code
 
 or_fun_call = "deny"
 cognitive_complexity = "deny"
+useless_let_if_seq = "deny"
+use_self = "deny"
+tuple_array_conversions = "deny"
+trait_duplication_in_bounds = "deny"
+suspicious_operation_groupings = "deny"
+string_lit_as_bytes = "deny"
+significant_drop_tightening = "deny"
+significant_drop_in_scrutinee = "deny"
+redundant_clone = "deny"
+# option_if_let_else = "deny" // 过于激进，暂时不开启
+needless_pass_by_ref_mut = "deny"
+needless_collect = "deny"
+missing_const_for_fn = "deny"
+iter_with_drain = "deny"
+iter_on_single_items = "deny"
+iter_on_empty_collections = "deny"
+# fallible_impl_from = "deny" // 过于激进，暂时不开启
+equatable_if_let = "deny"
+collection_is_never_read = "deny"
+branches_sharing_code = "deny"

src-tauri/benches/draft_benchmark.rs

@@ -3,122 +3,104 @@ use std::hint::black_box;
 use std::process;
 use tokio::runtime::Runtime;
 
-// 引入业务模型 & Draft 实现
 use app_lib::config::IVerge;
 use app_lib::utils::Draft as DraftNew;
 
 /// 创建测试数据
-fn make_draft() -> DraftNew<Box<IVerge>> {
-    let verge = Box::new(IVerge {
+fn make_draft() -> DraftNew<IVerge> {
+    let verge = IVerge {
         enable_auto_launch: Some(true),
         enable_tun_mode: Some(false),
         ..Default::default()
-    });
-    DraftNew::from(verge)
+    };
+    DraftNew::new(verge)
 }
 
-/// 基准：只读 data_ref（正式数据）
-fn bench_data_ref(c: &mut Criterion) {
-    c.bench_function("draft_data_ref", |b| {
-        b.iter(|| {
-            let draft = make_draft();
-            let data = draft.data_ref();
-            black_box(data.enable_auto_launch);
-        });
-    });
-}
-
-/// 基准：可写 data_mut（正式数据）
-fn bench_data_mut(c: &mut Criterion) {
-    c.bench_function("draft_data_mut", |b| {
-        b.iter(|| {
-            let draft = make_draft();
-            let mut data = draft.data_mut();
-            data.enable_tun_mode = Some(true);
-            black_box(data.enable_tun_mode);
-        });
-    });
-}
-
-/// 基准：首次创建草稿（会触发 clone）
-fn bench_draft_mut_first(c: &mut Criterion) {
-    c.bench_function("draft_draft_mut_first", |b| {
-        b.iter(|| {
-            let draft = make_draft();
-            let mut d = draft.draft_mut();
-            d.enable_auto_launch = Some(false);
-            black_box(d.enable_auto_launch);
-        });
-    });
-}
-
-/// 基准：重复 draft_mut（已存在草稿，不再 clone）
-fn bench_draft_mut_existing(c: &mut Criterion) {
-    c.bench_function("draft_draft_mut_existing", |b| {
-        b.iter(|| {
-            let draft = make_draft();
-            {
-                let mut first = draft.draft_mut();
-                first.enable_tun_mode = Some(true);
-            }
-            let mut second = draft.draft_mut();
-            second.enable_tun_mode = Some(false);
-            black_box(second.enable_tun_mode);
-        });
-    });
-}
-
-/// 基准：零拷贝读取最新视图（latest_ref）
-fn bench_latest_ref(c: &mut Criterion) {
-    c.bench_function("draft_latest_ref", |b| {
-        b.iter(|| {
-            let draft = make_draft();
-            let latest = draft.latest_ref();
-            black_box(latest.enable_auto_launch);
-        });
-    });
-}
-
-/// 基准：apply（提交草稿）
-fn bench_apply(c: &mut Criterion) {
-    c.bench_function("draft_apply", |b| {
-        b.iter(|| {
-            let draft = make_draft();
-            {
-                let mut d = draft.draft_mut();
-                d.enable_auto_launch = Some(false);
-            }
-            let _ = draft.apply();
-        });
-    });
-}
-
-/// 基准：discard（丢弃草稿）
-fn bench_discard(c: &mut Criterion) {
-    c.bench_function("draft_discard", |b| {
-        b.iter(|| {
-            let draft = make_draft();
-            {
-                let mut d = draft.draft_mut();
-                d.enable_auto_launch = Some(false);
-            }
-            let _ = draft.discard();
-        });
-    });
-}
-
-/// 基准：异步 with_data_modify
-fn bench_with_data_modify(c: &mut Criterion) {
-    let rt = Runtime::new().unwrap_or_else(|error| {
-        eprintln!("draft benchmarks require a Tokio runtime: {error}");
+pub fn bench_draft(c: &mut Criterion) {
+    let rt = Runtime::new().unwrap_or_else(|e| {
+        eprintln!("Tokio runtime init failed: {e}");
         process::exit(1);
     });
 
-    c.bench_function("draft_with_data_modify", |b| {
+    let mut group = c.benchmark_group("draft");
+    group.sample_size(100);
+    group.warm_up_time(std::time::Duration::from_millis(300));
+    group.measurement_time(std::time::Duration::from_secs(1));
+
+    group.bench_function("data_mut", |b| {
+        b.iter(|| {
+            let draft = black_box(make_draft());
+            draft.edit_draft(|d| d.enable_tun_mode = Some(true));
+            black_box(&draft.latest_arc().enable_tun_mode);
+        });
+    });
+
+    group.bench_function("draft_mut_first", |b| {
+        b.iter(|| {
+            let draft = black_box(make_draft());
+            draft.edit_draft(|d| d.enable_auto_launch = Some(false));
+            let latest = draft.latest_arc();
+            black_box(&latest.enable_auto_launch);
+        });
+    });
+
+    group.bench_function("draft_mut_existing", |b| {
+        b.iter(|| {
+            let draft = black_box(make_draft());
+            {
+                draft.edit_draft(|d| {
+                    d.enable_tun_mode = Some(true);
+                });
+                let latest1 = draft.latest_arc();
+                black_box(&latest1.enable_tun_mode);
+            }
+            draft.edit_draft(|d| {
+                d.enable_tun_mode = Some(false);
+            });
+            let latest2 = draft.latest_arc();
+            black_box(&latest2.enable_tun_mode);
+        });
+    });
+
+    group.bench_function("latest_arc", |b| {
+        b.iter(|| {
+            let draft = black_box(make_draft());
+            let latest = draft.latest_arc();
+            black_box(&latest.enable_auto_launch);
+        });
+    });
+
+    group.bench_function("apply", |b| {
+        b.iter(|| {
+            let draft = black_box(make_draft());
+            {
+                draft.edit_draft(|d| {
+                    d.enable_auto_launch = Some(false);
+                });
+            }
+            draft.apply();
+            black_box(&draft);
+        });
+    });
+
+    group.bench_function("discard", |b| {
+        b.iter(|| {
+            let draft = black_box(make_draft());
+            {
+                draft.edit_draft(|d| {
+                    d.enable_auto_launch = Some(false);
+                });
+            }
+            draft.discard();
+            black_box(&draft);
+        });
+    });
+
+    group.bench_function("with_data_modify_async", |b| {
         b.to_async(&rt).iter(|| async {
-            let draft = make_draft();
-            let _res: Result<(), anyhow::Error> = draft
-                .with_data_modify(|mut box_data| async move {
+            let draft = black_box(make_draft());
+            let _: Result<(), anyhow::Error> = draft
+                .with_data_modify::<_, _, _>(|mut box_data| async move {
                     box_data.enable_auto_launch =
                         Some(!box_data.enable_auto_launch.unwrap_or(false));
                     Ok((box_data, ()))
@@ -126,17 +108,9 @@ fn bench_with_data_modify(c: &mut Criterion) {
                 .await;
         });
     });
+
+    group.finish();
 }
 
-criterion_group!(
-    benches,
-    bench_data_ref,
-    bench_data_mut,
-    bench_draft_mut_first,
-    bench_draft_mut_existing,
-    bench_latest_ref,
-    bench_apply,
-    bench_discard,
-    bench_with_data_modify
-);
+criterion_group!(benches, bench_draft);
 criterion_main!(benches);

src-tauri/src/cmd/app.rs

@@ -12,6 +12,7 @@ use smartstring::alias::String;
 use std::path::Path;
 use tauri::{AppHandle, Manager};
 use tokio::fs;
+use tokio::io::AsyncWriteExt;
 
 /// 打开应用程序所在目录
 #[tauri::command]
@@ -41,6 +42,20 @@ pub fn open_web_url(url: String) -> CmdResult<()> {
     open::that(url.as_str()).stringify_err()
 }
 
+// TODO 后续可以为前端提供接口，当前作为托盘菜单使用
+/// 打开 Verge 最新日志
+#[tauri::command]
+pub async fn open_app_log() -> CmdResult<()> {
+    open::that(dirs::app_latest_log().stringify_err()?).stringify_err()
+}
+
+// TODO 后续可以为前端提供接口，当前作为托盘菜单使用
+/// 打开 Clash 最新日志
+#[tauri::command]
+pub async fn open_core_log() -> CmdResult<()> {
+    open::that(dirs::clash_latest_log().stringify_err()?).stringify_err()
+}
+
 /// 打开/关闭开发者工具
 #[tauri::command]
 pub fn open_devtools(app_handle: AppHandle) {
@@ -102,7 +117,7 @@ pub async fn download_icon_cache(url: String, name: String) -> CmdResult<String>
     }
 
     if !icon_cache_dir.exists() {
-        let _ = std::fs::create_dir_all(&icon_cache_dir);
+        let _ = fs::create_dir_all(&icon_cache_dir).await;
     }
 
     let temp_path = icon_cache_dir.join(format!("{}.downloading", name.as_str()));
@@ -126,7 +141,7 @@ pub async fn download_icon_cache(url: String, name: String) -> CmdResult<String>
 
     if is_image && !is_html {
         {
-            let mut file = match std::fs::File::create(&temp_path) {
+            let mut file = match fs::File::create(&temp_path).await {
                 Ok(file) => file,
                 Err(_) => {
                     if icon_path.exists() {
@@ -135,12 +150,12 @@ pub async fn download_icon_cache(url: String, name: String) -> CmdResult<String>
                     return Err("Failed to create temporary file".into());
                 }
             };
-
-            std::io::copy(&mut content.as_ref(), &mut file).stringify_err()?;
+            file.write_all(content.as_ref()).await.stringify_err()?;
+            file.flush().await.stringify_err()?;
         }
 
         if !icon_path.exists() {
-            match std::fs::rename(&temp_path, &icon_path) {
+            match fs::rename(&temp_path, &icon_path).await {
                 Ok(_) => {}
                 Err(_) => {
                     let _ = temp_path.remove_if_exists().await;
@@ -226,7 +241,7 @@ pub async fn copy_icon_file(path: String, icon_info: IconInfo) -> CmdResult<Stri
 /// 通知UI已准备就绪
 #[tauri::command]
 pub fn notify_ui_ready() -> CmdResult<()> {
-    log::info!(target: "app", "前端UI已准备就绪");
+    logging!(info, Type::Cmd, "前端UI已准备就绪");
     crate::utils::resolve::ui::mark_ui_ready();
     Ok(())
 }
@@ -234,7 +249,7 @@ pub fn notify_ui_ready() -> CmdResult<()> {
 /// UI加载阶段
 #[tauri::command]
 pub fn update_ui_stage(stage: String) -> CmdResult<()> {
-    log::info!(target: "app", "UI加载阶段更新: {}", stage.as_str());
+    logging!(info, Type::Cmd, "UI加载阶段更新: {}", stage.as_str());
 
     use crate::utils::resolve::ui::UiReadyStage;
 
@@ -245,7 +260,12 @@ pub fn update_ui_stage(stage: String) -> CmdResult<()> {
         "ResourcesLoaded" => UiReadyStage::ResourcesLoaded,
         "Ready" => UiReadyStage::Ready,
         _ => {
-            log::warn!(target: "app", "未知的UI加载阶段: {}", stage.as_str());
+            logging!(
+                warn,
+                Type::Cmd,
+                "Warning: 未知的UI加载阶段: {}",
+                stage.as_str()
+            );
             return Err(format!("未知的UI加载阶段: {}", stage.as_str()).into());
         }
     };

src-tauri/src/cmd/backup.rs

@@ -11,8 +11,8 @@ pub async fn create_local_backup() -> CmdResult<()> {
 
 /// List local backups
 #[tauri::command]
-pub fn list_local_backup() -> CmdResult<Vec<LocalBackupFile>> {
-    feat::list_local_backup().stringify_err()
+pub async fn list_local_backup() -> CmdResult<Vec<LocalBackupFile>> {
+    feat::list_local_backup().await.stringify_err()
 }
 
 /// Delete local backup
@@ -29,6 +29,8 @@ pub async fn restore_local_backup(filename: String) -> CmdResult<()> {
 
 /// Export local backup to a user selected destination
 #[tauri::command]
-pub fn export_local_backup(filename: String, destination: String) -> CmdResult<()> {
-    feat::export_local_backup(filename, destination).stringify_err()
+pub async fn export_local_backup(filename: String, destination: String) -> CmdResult<()> {
+    feat::export_local_backup(filename, destination)
+        .await
+        .stringify_err()
 }

src-tauri/src/cmd/clash.rs

@@ -1,13 +1,16 @@
 use super::CmdResult;
+use crate::utils::dirs;
 use crate::{
     cmd::StringifyErr,
-    config::Config,
+    config::{ClashInfo, Config},
+    constants,
     core::{CoreManager, handle, validate::CoreConfigValidator},
 };
-use crate::{config::*, feat, logging, utils::logging::Type};
+use crate::{feat, logging, utils::logging::Type};
 use compact_str::CompactString;
 use serde_yaml_ng::Mapping;
 use smartstring::alias::String;
+use tokio::fs;
 
 /// 复制Clash环境变量
 #[tauri::command]
@@ -19,7 +22,7 @@ pub async fn copy_clash_env() -> CmdResult {
 /// 获取Clash信息
 #[tauri::command]
 pub async fn get_clash_info() -> CmdResult<ClashInfo> {
-    Ok(Config::clash().await.latest_ref().get_client_info())
+    Ok(Config::clash().await.latest_arc().get_client_info())
 }
 
 /// 修改Clash配置
@@ -40,10 +43,7 @@ pub async fn patch_clash_mode(payload: String) -> CmdResult {
 pub async fn change_clash_core(clash_core: String) -> CmdResult<Option<String>> {
     logging!(info, Type::Config, "changing core to {clash_core}");
 
-    match CoreManager::global()
-        .change_core(Some(clash_core.clone()))
-        .await
-    {
+    match CoreManager::global().change_core(&clash_core).await {
         Ok(_) => {
             // 切换内核后重启内核
             match CoreManager::global().restart_core().await {
@@ -111,7 +111,7 @@ pub async fn test_delay(url: String) -> CmdResult<u32> {
     let result = match feat::test_delay(url).await {
         Ok(delay) => delay,
         Err(e) => {
-            log::error!(target: "app", "{}", e);
+            logging!(error, Type::Cmd, "{}", e);
             10000u32
         }
     };
@@ -128,7 +128,7 @@ pub async fn save_dns_config(dns_config: Mapping) -> CmdResult {
     // 获取DNS配置文件路径
     let dns_path = dirs::app_home_dir()
         .stringify_err()?
-        .join("dns_config.yaml");
+        .join(constants::files::DNS_CONFIG);
 
     // 保存DNS配置到文件
     let yaml_str = serde_yaml_ng::to_string(&dns_config).stringify_err()?;
@@ -141,28 +141,20 @@ pub async fn save_dns_config(dns_config: Mapping) -> CmdResult {
 /// 应用或撤销DNS配置
 #[tauri::command]
 pub async fn apply_dns_config(apply: bool) -> CmdResult {
-    use crate::{
-        config::Config,
-        core::{CoreManager, handle},
-        utils::dirs,
-    };
-
     if apply {
         // 读取DNS配置文件
         let dns_path = dirs::app_home_dir()
             .stringify_err()?
-            .join("dns_config.yaml");
+            .join(constants::files::DNS_CONFIG);
 
         if !dns_path.exists() {
             logging!(warn, Type::Config, "DNS config file not found");
             return Err("DNS config file not found".into());
         }
 
-        let dns_yaml = tokio::fs::read_to_string(&dns_path)
-            .await
-            .stringify_err_log(|e| {
-                logging!(error, Type::Config, "Failed to read DNS config: {e}");
-            })?;
+        let dns_yaml = fs::read_to_string(&dns_path).await.stringify_err_log(|e| {
+            logging!(error, Type::Config, "Failed to read DNS config: {e}");
+        })?;
 
         // 解析DNS配置
         let patch_config = serde_yaml_ng::from_str::<serde_yaml_ng::Mapping>(&dns_yaml)
@@ -177,7 +169,9 @@ pub async fn apply_dns_config(apply: bool) -> CmdResult {
         patch.insert("dns".into(), patch_config.into());
 
         // 应用DNS配置到运行时配置
-        Config::runtime().await.draft_mut().patch_config(patch);
+        Config::runtime().await.edit_draft(|d| {
+            d.patch_config(patch);
+        });
 
         // 重新生成配置
         Config::generate().await.stringify_err_log(|err| {
@@ -195,7 +189,6 @@ pub async fn apply_dns_config(apply: bool) -> CmdResult {
             })?;
 
         logging!(info, Type::Config, "DNS config successfully applied");
-        handle::Handle::refresh_clash();
     } else {
         // 当关闭DNS设置时，重新生成配置（不加载DNS配置文件）
         logging!(
@@ -218,9 +211,9 @@ pub async fn apply_dns_config(apply: bool) -> CmdResult {
             })?;
 
         logging!(info, Type::Config, "Config regenerated successfully");
-        handle::Handle::refresh_clash();
     }
 
+    handle::Handle::refresh_clash();
     Ok(())
 }
 
@@ -231,7 +224,7 @@ pub fn check_dns_config_exists() -> CmdResult<bool> {
 
     let dns_path = dirs::app_home_dir()
         .stringify_err()?
-        .join("dns_config.yaml");
+        .join(constants::files::DNS_CONFIG);
 
     Ok(dns_path.exists())
 }
@@ -244,7 +237,7 @@ pub async fn get_dns_config_content() -> CmdResult<String> {
 
     let dns_path = dirs::app_home_dir()
         .stringify_err()?
-        .join("dns_config.yaml");
+        .join(constants::files::DNS_CONFIG);
 
     if !fs::try_exists(&dns_path).await.stringify_err()? {
         return Err("DNS config file not found".into());
@@ -257,10 +250,8 @@ pub async fn get_dns_config_content() -> CmdResult<String> {
 /// 验证DNS配置文件
 #[tauri::command]
 pub async fn validate_dns_config() -> CmdResult<(bool, String)> {
-    use crate::utils::dirs;
-
     let app_dir = dirs::app_home_dir().stringify_err()?;
-    let dns_path = app_dir.join("dns_config.yaml");
+    let dns_path = app_dir.join(constants::files::DNS_CONFIG);
     let dns_path_str = dns_path.to_str().unwrap_or_default();
 
     if !dns_path.exists() {

src-tauri/src/cmd/media_unlock_checker/youtube.rs

@@ -13,19 +13,23 @@ pub(super) async fn check_youtube_premium(client: &Client) -> UnlockItem {
         Ok(response) => {
             if let Ok(body) = response.text().await {
                 let body_lower = body.to_lowercase();
+                let mut status = "Failed";
+                let mut region = None;
 
                 if body_lower.contains("youtube premium is not available in your country") {
-                    return UnlockItem {
-                        name: "Youtube Premium".to_string(),
-                        status: "No".to_string(),
-                        region: None,
-                        check_time: Some(get_local_date_string()),
-                    };
-                }
-
-                if body_lower.contains("ad-free") {
-                    let re = match Regex::new(r#"id="country-code"[^>]*>([^<]+)<"#) {
-                        Ok(re) => re,
+                    status = "No";
+                } else if body_lower.contains("ad-free") {
+                    match Regex::new(r#"id="country-code"[^>]*>([^<]+)<"#) {
+                        Ok(re) => {
+                            if let Some(caps) = re.captures(&body)
+                                && let Some(m) = caps.get(1)
+                            {
+                                let country_code = m.as_str().trim();
+                                let emoji = country_code_to_emoji(country_code);
+                                region = Some(format!("{emoji}{country_code}"));
+                                status = "Yes";
+                            }
+                        }
                         Err(e) => {
                             logging!(
                                 error,
@@ -33,34 +37,14 @@ pub(super) async fn check_youtube_premium(client: &Client) -> UnlockItem {
                                 "Failed to compile YouTube Premium regex: {}",
                                 e
                             );
-                            return UnlockItem {
-                                name: "Youtube Premium".to_string(),
-                                status: "Failed".to_string(),
-                                region: None,
-                                check_time: Some(get_local_date_string()),
-                            };
                         }
-                    };
-                    let region = re.captures(&body).and_then(|caps| {
-                        caps.get(1).map(|m| {
-                            let country_code = m.as_str().trim();
-                            let emoji = country_code_to_emoji(country_code);
-                            format!("{emoji}{country_code}")
-                        })
-                    });
-
-                    return UnlockItem {
-                        name: "Youtube Premium".to_string(),
-                        status: "Yes".to_string(),
-                        region,
-                        check_time: Some(get_local_date_string()),
-                    };
+                    }
                 }
 
                 UnlockItem {
                     name: "Youtube Premium".to_string(),
-                    status: "Failed".to_string(),
-                    region: None,
+                    status: status.to_string(),
+                    region,
                     check_time: Some(get_local_date_string()),
                 }
             } else {

src-tauri/src/cmd/network.rs

@@ -2,13 +2,14 @@ use super::CmdResult;
 use crate::cmd::StringifyErr;
 use crate::core::{EventDrivenProxyManager, async_proxy_query::AsyncProxyQuery};
 use crate::process::AsyncHandler;
+use crate::{logging, utils::logging::Type};
 use network_interface::NetworkInterface;
 use serde_yaml_ng::Mapping;
 
 /// get the system proxy
 #[tauri::command]
 pub async fn get_sys_proxy() -> CmdResult<Mapping> {
-    log::debug!(target: "app", "异步获取系统代理配置");
+    logging!(debug, Type::Network, "异步获取系统代理配置");
 
     let current = AsyncProxyQuery::get_system_proxy().await;
 
@@ -20,14 +21,21 @@ pub async fn get_sys_proxy() -> CmdResult<Mapping> {
     );
     map.insert("bypass".into(), current.bypass.into());
 
-    log::debug!(target: "app", "返回系统代理配置: enable={}, {}:{}", current.enable, current.host, current.port);
+    logging!(
+        debug,
+        Type::Network,
+        "返回系统代理配置: enable={}, {}:{}",
+        current.enable,
+        current.host,
+        current.port
+    );
     Ok(map)
 }
 
 /// 获取自动代理配置
 #[tauri::command]
 pub async fn get_auto_proxy() -> CmdResult<Mapping> {
-    log::debug!(target: "app", "开始获取自动代理配置（事件驱动）");
+    logging!(debug, Type::Network, "开始获取自动代理配置（事件驱动）");
 
     let proxy_manager = EventDrivenProxyManager::global();
 
@@ -41,7 +49,13 @@ pub async fn get_auto_proxy() -> CmdResult<Mapping> {
     map.insert("enable".into(), current.enable.into());
     map.insert("url".into(), current.url.clone().into());
 
-    log::debug!(target: "app", "返回自动代理配置（缓存）: enable={}, url={}", current.enable, current.url);
+    logging!(
+        debug,
+        Type::Network,
+        "返回自动代理配置（缓存）: enable={}, url={}",
+        current.enable,
+        current.url
+    );
     Ok(map)
 }
 

src-tauri/src/cmd/profile.rs

@@ -1,5 +1,6 @@
 use super::CmdResult;
 use super::StringifyErr;
+use crate::utils::draft::SharedBox;
 use crate::{
     config::{
         Config, IProfiles, PrfItem, PrfOption,
@@ -15,68 +16,19 @@ use crate::{
     ret_err,
     utils::{dirs, help, logging::Type},
 };
+use scopeguard::defer;
 use smartstring::alias::String;
-use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::time::Duration;
 
-// 全局请求序列号跟踪，用于避免队列化执行
-static CURRENT_REQUEST_SEQUENCE: AtomicU64 = AtomicU64::new(0);
-
 static CURRENT_SWITCHING_PROFILE: AtomicBool = AtomicBool::new(false);
 
 #[tauri::command]
-pub async fn get_profiles() -> CmdResult<IProfiles> {
-    // 策略1: 尝试快速获取latest数据
-    let latest_result = tokio::time::timeout(Duration::from_millis(500), async {
-        let profiles = Config::profiles().await;
-        let latest = profiles.latest_ref();
-        IProfiles {
-            current: latest.current.clone(),
-            items: latest.items.clone(),
-        }
-    })
-    .await;
-
-    match latest_result {
-        Ok(profiles) => {
-            logging!(info, Type::Cmd, "快速获取配置列表成功");
-            return Ok(profiles);
-        }
-        Err(_) => {
-            logging!(warn, Type::Cmd, "快速获取配置超时(500ms)");
-        }
-    }
-
-    // 策略2: 如果快速获取失败，尝试获取data()
-    let data_result = tokio::time::timeout(Duration::from_secs(2), async {
-        let profiles = Config::profiles().await;
-        let data = profiles.latest_ref();
-        IProfiles {
-            current: data.current.clone(),
-            items: data.items.clone(),
-        }
-    })
-    .await;
-
-    match data_result {
-        Ok(profiles) => {
-            logging!(info, Type::Cmd, "获取draft配置列表成功");
-            return Ok(profiles);
-        }
-        Err(join_err) => {
-            logging!(
-                error,
-                Type::Cmd,
-                "获取draft配置任务失败或超时: {}",
-                join_err
-            );
-        }
-    }
-
-    // 策略3: fallback，尝试重新创建配置
-    logging!(warn, Type::Cmd, "所有获取配置策略都失败，尝试fallback");
-
-    Ok(IProfiles::new().await)
+pub async fn get_profiles() -> CmdResult<SharedBox<IProfiles>> {
+    logging!(debug, Type::Cmd, "获取配置文件列表");
+    let draft = Config::profiles().await;
+    let data = draft.data_arc();
+    Ok(data)
 }
 
 /// 增强配置文件
@@ -85,7 +37,7 @@ pub async fn enhance_profiles() -> CmdResult {
     match feat::enhance_profiles().await {
         Ok(_) => {}
         Err(e) => {
-            log::error!(target: "app", "{}", e);
+            logging!(error, Type::Cmd, "{}", e);
             return Err(e.to_string().into());
         }
     }
@@ -99,7 +51,7 @@ pub async fn import_profile(url: std::string::String, option: Option<PrfOption>)
     logging!(info, Type::Cmd, "[导入订阅] 开始导入: {}", url);
 
     // 直接依赖 PrfItem::from_url 自身的超时/重试逻辑，不再使用 tokio::time::timeout 包裹
-    let item = match PrfItem::from_url(&url, None, None, option).await {
+    let item = &mut match PrfItem::from_url(&url, None, None, option.as_ref()).await {
         Ok(it) => {
             logging!(info, Type::Cmd, "[导入订阅] 下载完成，开始保存配置");
             it
@@ -110,7 +62,7 @@ pub async fn import_profile(url: std::string::String, option: Option<PrfOption>)
         }
     };
 
-    match profiles_append_item_safe(item.clone()).await {
+    match profiles_append_item_safe(item).await {
         Ok(_) => match profiles_save_file_safe().await {
             Ok(_) => {
                 logging!(info, Type::Cmd, "[导入订阅] 配置文件保存成功");
@@ -145,13 +97,15 @@ pub async fn import_profile(url: std::string::String, option: Option<PrfOption>)
 /// 调整profile的顺序
 #[tauri::command]
 pub async fn reorder_profile(active_id: String, over_id: String) -> CmdResult {
-    match profiles_reorder_safe(active_id, over_id).await {
+    match profiles_reorder_safe(&active_id, &over_id).await {
         Ok(_) => {
-            log::info!(target: "app", "重新排序配置文件");
+            logging!(info, Type::Cmd, "重新排序配置文件");
+            Config::profiles().await.apply();
             Ok(())
         }
         Err(err) => {
-            log::error!(target: "app", "重新排序配置文件失败: {}", err);
+            Config::profiles().await.discard();
+            logging!(error, Type::Cmd, "重新排序配置文件失败: {}", err);
             Err(format!("重新排序配置文件失败: {}", err).into())
         }
     }
@@ -161,29 +115,37 @@ pub async fn reorder_profile(active_id: String, over_id: String) -> CmdResult {
 /// 创建一个新的配置文件
 #[tauri::command]
 pub async fn create_profile(item: PrfItem, file_data: Option<String>) -> CmdResult {
-    match profiles_append_item_with_filedata_safe(item.clone(), file_data).await {
+    match profiles_append_item_with_filedata_safe(&item, file_data).await {
         Ok(_) => {
             // 发送配置变更通知
             if let Some(uid) = &item.uid {
                 logging!(info, Type::Cmd, "[创建订阅] 发送配置变更通知: {}", uid);
                 handle::Handle::notify_profile_changed(uid.clone());
             }
+            Config::profiles().await.apply();
             Ok(())
         }
-        Err(err) => match err.to_string().as_str() {
-            "the file already exists" => Err("the file already exists".into()),
-            _ => Err(format!("add profile error: {err}").into()),
-        },
+        Err(err) => {
+            Config::profiles().await.discard();
+            match err.to_string().as_str() {
+                "the file already exists" => Err("the file already exists".into()),
+                _ => Err(format!("add profile error: {err}").into()),
+            }
+        }
     }
 }
 
 /// 更新配置文件
 #[tauri::command]
 pub async fn update_profile(index: String, option: Option<PrfOption>) -> CmdResult {
-    match feat::update_profile(index, option, Some(true)).await {
-        Ok(_) => Ok(()),
+    match feat::update_profile(&index, option.as_ref(), true, true).await {
+        Ok(_) => {
+            let _: () = Config::profiles().await.apply();
+            Ok(())
+        }
         Err(e) => {
-            log::error!(target: "app", "{}", e);
+            Config::profiles().await.discard();
+            logging!(error, Type::Cmd, "{}", e);
             Err(e.to_string().into())
         }
     }
@@ -192,14 +154,11 @@ pub async fn update_profile(index: String, option: Option<PrfOption>) -> CmdResu
 /// 删除配置文件
 #[tauri::command]
 pub async fn delete_profile(index: String) -> CmdResult {
-    println!("delete_profile: {}", index);
     // 使用Send-safe helper函数
-    let should_update = profiles_delete_item_safe(index.clone())
-        .await
-        .stringify_err()?;
+    let should_update = profiles_delete_item_safe(&index).await.stringify_err()?;
     profiles_save_file_safe().await.stringify_err()?;
-
     if should_update {
+        Config::profiles().await.apply();
         match CoreManager::global().update_config().await {
             Ok(_) => {
                 handle::Handle::refresh_clash();
@@ -208,7 +167,7 @@ pub async fn delete_profile(index: String) -> CmdResult {
                 handle::Handle::notify_profile_changed(index);
             }
             Err(e) => {
-                log::error!(target: "app", "{}", e);
+                logging!(error, Type::Cmd, "{}", e);
                 return Err(e.to_string().into());
             }
         }
@@ -223,7 +182,7 @@ async fn validate_new_profile(new_profile: &String) -> Result<(), ()> {
     // 获取目标配置文件路径
     let config_file_result = {
         let profiles_config = Config::profiles().await;
-        let profiles_data = profiles_config.latest_ref();
+        let profiles_data = profiles_config.latest_arc();
         match profiles_data.get_item(new_profile) {
             Ok(item) => {
                 if let Some(file) = &item.file {
@@ -285,7 +244,7 @@ async fn validate_new_profile(new_profile: &String) -> Result<(), ()> {
                         );
                         handle::Handle::notice_message(
                             "config_validate::yaml_syntax_error",
-                            error_msg.clone(),
+                            error_msg,
                         );
                         Err(())
                     }
@@ -294,7 +253,7 @@ async fn validate_new_profile(new_profile: &String) -> Result<(), ()> {
                         logging!(error, Type::Cmd, "{}", error_msg);
                         handle::Handle::notice_message(
                             "config_validate::yaml_parse_error",
-                            error_msg.clone(),
+                            error_msg,
                         );
                         Err(())
                     }
@@ -303,19 +262,13 @@ async fn validate_new_profile(new_profile: &String) -> Result<(), ()> {
             Ok(Err(err)) => {
                 let error_msg = format!("无法读取目标配置文件: {err}");
                 logging!(error, Type::Cmd, "{}", error_msg);
-                handle::Handle::notice_message(
-                    "config_validate::file_read_error",
-                    error_msg.clone(),
-                );
+                handle::Handle::notice_message("config_validate::file_read_error", error_msg);
                 Err(())
             }
             Err(_) => {
                 let error_msg = "读取配置文件超时(5秒)".to_string();
                 logging!(error, Type::Cmd, "{}", error_msg);
-                handle::Handle::notice_message(
-                    "config_validate::file_read_timeout",
-                    error_msg.clone(),
-                );
+                handle::Handle::notice_message("config_validate::file_read_timeout", error_msg);
                 Err(())
             }
         }
@@ -325,80 +278,52 @@ async fn validate_new_profile(new_profile: &String) -> Result<(), ()> {
 }
 
 /// 执行配置更新并处理结果
-async fn restore_previous_profile(prev_profile: String) -> CmdResult<()> {
+async fn restore_previous_profile(prev_profile: &String) -> CmdResult<()> {
     logging!(info, Type::Cmd, "尝试恢复到之前的配置: {}", prev_profile);
     let restore_profiles = IProfiles {
-        current: Some(prev_profile),
+        current: Some(prev_profile.to_owned()),
         items: None,
     };
     Config::profiles()
         .await
-        .draft_mut()
-        .patch_config(restore_profiles)
-        .stringify_err()?;
+        .edit_draft(|d| d.patch_config(&restore_profiles));
     Config::profiles().await.apply();
     crate::process::AsyncHandler::spawn(|| async move {
         if let Err(e) = profiles_save_file_safe().await {
-            log::warn!(target: "app", "异步保存恢复配置文件失败: {e}");
+            logging!(warn, Type::Cmd, "Warning: 异步保存恢复配置文件失败: {e}");
         }
     });
     logging!(info, Type::Cmd, "成功恢复到之前的配置");
     Ok(())
 }
 
-async fn handle_success(current_sequence: u64, current_value: Option<String>) -> CmdResult<bool> {
-    let latest_sequence = CURRENT_REQUEST_SEQUENCE.load(Ordering::SeqCst);
-    if current_sequence < latest_sequence {
-        logging!(
-            info,
-            Type::Cmd,
-            "内核操作后发现更新的请求 (序列号: {} < {})，忽略当前结果",
-            current_sequence,
-            latest_sequence
-        );
-        Config::profiles().await.discard();
-        return Ok(false);
-    }
-
-    logging!(
-        info,
-        Type::Cmd,
-        "配置更新成功，序列号: {}",
-        current_sequence
-    );
+async fn handle_success(current_value: Option<&String>) -> CmdResult<bool> {
     Config::profiles().await.apply();
     handle::Handle::refresh_clash();
 
     if let Err(e) = Tray::global().update_tooltip().await {
-        log::warn!(target: "app", "异步更新托盘提示失败: {e}");
+        logging!(warn, Type::Cmd, "Warning: 异步更新托盘提示失败: {e}");
     }
 
     if let Err(e) = Tray::global().update_menu().await {
-        log::warn!(target: "app", "异步更新托盘菜单失败: {e}");
+        logging!(warn, Type::Cmd, "Warning: 异步更新托盘菜单失败: {e}");
     }
 
     if let Err(e) = profiles_save_file_safe().await {
-        log::warn!(target: "app", "异步保存配置文件失败: {e}");
+        logging!(warn, Type::Cmd, "Warning: 异步保存配置文件失败: {e}");
     }
 
-    if let Some(current) = &current_value {
-        logging!(
-            info,
-            Type::Cmd,
-            "向前端发送配置变更事件: {}, 序列号: {}",
-            current,
-            current_sequence
-        );
-        handle::Handle::notify_profile_changed(current.clone());
+    if let Some(current) = current_value {
+        logging!(info, Type::Cmd, "向前端发送配置变更事件: {}", current);
+        handle::Handle::notify_profile_changed(current.to_owned());
     }
 
-    CURRENT_SWITCHING_PROFILE.store(false, Ordering::SeqCst);
     Ok(true)
 }
 
 async fn handle_validation_failure(
     error_msg: String,
-    current_profile: Option<String>,
+    current_profile: Option<&String>,
 ) -> CmdResult<bool> {
     logging!(warn, Type::Cmd, "配置验证失败: {}", error_msg);
     Config::profiles().await.discard();
@@ -406,53 +331,34 @@ async fn handle_validation_failure(
         restore_previous_profile(prev_profile).await?;
     }
     handle::Handle::notice_message("config_validate::error", error_msg);
-    CURRENT_SWITCHING_PROFILE.store(false, Ordering::SeqCst);
     Ok(false)
 }
 
-async fn handle_update_error<E: std::fmt::Display>(e: E, current_sequence: u64) -> CmdResult<bool> {
-    logging!(
-        warn,
-        Type::Cmd,
-        "更新过程发生错误: {}, 序列号: {}",
-        e,
-        current_sequence
-    );
+async fn handle_update_error<E: std::fmt::Display>(e: E) -> CmdResult<bool> {
+    logging!(warn, Type::Cmd, "更新过程发生错误: {}", e,);
     Config::profiles().await.discard();
     handle::Handle::notice_message("config_validate::boot_error", e.to_string());
-    CURRENT_SWITCHING_PROFILE.store(false, Ordering::SeqCst);
     Ok(false)
 }
 
-async fn handle_timeout(current_profile: Option<String>, current_sequence: u64) -> CmdResult<bool> {
+async fn handle_timeout(current_profile: Option<&String>) -> CmdResult<bool> {
     let timeout_msg = "配置更新超时(30秒)，可能是配置验证或核心通信阻塞";
-    logging!(
-        error,
-        Type::Cmd,
-        "{}, 序列号: {}",
-        timeout_msg,
-        current_sequence
-    );
+    logging!(error, Type::Cmd, "{}", timeout_msg);
     Config::profiles().await.discard();
     if let Some(prev_profile) = current_profile {
         restore_previous_profile(prev_profile).await?;
     }
     handle::Handle::notice_message("config_validate::timeout", timeout_msg);
-    CURRENT_SWITCHING_PROFILE.store(false, Ordering::SeqCst);
     Ok(false)
 }
 
 async fn perform_config_update(
-    current_sequence: u64,
-    current_value: Option<String>,
-    current_profile: Option<String>,
+    current_value: Option<&String>,
+    current_profile: Option<&String>,
 ) -> CmdResult<bool> {
-    logging!(
-        info,
-        Type::Cmd,
-        "开始内核配置更新，序列号: {}",
-        current_sequence
-    );
+    defer! {
+        CURRENT_SWITCHING_PROFILE.store(false, Ordering::Release);
+    }
     let update_result = tokio::time::timeout(
         Duration::from_secs(30),
         CoreManager::global().update_config(),
@@ -460,99 +366,50 @@ async fn perform_config_update(
     .await;
 
     match update_result {
-        Ok(Ok((true, _))) => handle_success(current_sequence, current_value).await,
+        Ok(Ok((true, _))) => handle_success(current_value).await,
         Ok(Ok((false, error_msg))) => handle_validation_failure(error_msg, current_profile).await,
-        Ok(Err(e)) => handle_update_error(e, current_sequence).await,
-        Err(_) => handle_timeout(current_profile, current_sequence).await,
+        Ok(Err(e)) => handle_update_error(e).await,
+        Err(_) => handle_timeout(current_profile).await,
     }
 }
 
 /// 修改profiles的配置
 #[tauri::command]
 pub async fn patch_profiles_config(profiles: IProfiles) -> CmdResult<bool> {
-    if CURRENT_SWITCHING_PROFILE.load(Ordering::SeqCst) {
+    if CURRENT_SWITCHING_PROFILE
+        .compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed)
+        .is_err()
+    {
         logging!(info, Type::Cmd, "当前正在切换配置，放弃请求");
         return Ok(false);
     }
-    CURRENT_SWITCHING_PROFILE.store(true, Ordering::SeqCst);
 
-    // 为当前请求分配序列号
-    let current_sequence = CURRENT_REQUEST_SEQUENCE.fetch_add(1, Ordering::SeqCst) + 1;
-    let target_profile = profiles.current.clone();
+    let target_profile = profiles.current.as_ref();
 
     logging!(
         info,
         Type::Cmd,
-        "开始修改配置文件，请求序列号: {}, 目标profile: {:?}",
-        current_sequence,
+        "开始修改配置文件，目标profile: {:?}",
         target_profile
     );
 
-    let latest_sequence = CURRENT_REQUEST_SEQUENCE.load(Ordering::SeqCst);
-    if current_sequence < latest_sequence {
-        logging!(
-            info,
-            Type::Cmd,
-            "获取锁后发现更新的请求 (序列号: {} < {})，放弃当前请求",
-            current_sequence,
-            latest_sequence
-        );
-        return Ok(false);
-    }
-
     // 保存当前配置，以便在验证失败时恢复
-    let current_profile = Config::profiles().await.latest_ref().current.clone();
-    logging!(info, Type::Cmd, "当前配置: {:?}", current_profile);
+    let previous_profile = Config::profiles().await.data_arc().current.clone();
+    logging!(info, Type::Cmd, "当前配置: {:?}", previous_profile);
 
     // 如果要切换配置，先检查目标配置文件是否有语法错误
-    if let Some(new_profile) = profiles.current.as_ref()
-        && current_profile.as_ref() != Some(new_profile)
-        && validate_new_profile(new_profile).await.is_err()
+    if let Some(switch_to_profile) = target_profile
+        && previous_profile.as_ref() != Some(switch_to_profile)
+        && validate_new_profile(switch_to_profile).await.is_err()
     {
-        CURRENT_SWITCHING_PROFILE.store(false, Ordering::SeqCst);
+        CURRENT_SWITCHING_PROFILE.store(false, Ordering::Release);
         return Ok(false);
     }
+    Config::profiles()
+        .await
+        .edit_draft(|d| d.patch_config(&profiles));
 
-    // 检查请求有效性
-    let latest_sequence = CURRENT_REQUEST_SEQUENCE.load(Ordering::SeqCst);
-    if current_sequence < latest_sequence {
-        logging!(
-            info,
-            Type::Cmd,
-            "在核心操作前发现更新的请求 (序列号: {} < {})，放弃当前请求",
-            current_sequence,
-            latest_sequence
-        );
-        return Ok(false);
-    }
-
-    // 更新profiles配置
-    logging!(
-        info,
-        Type::Cmd,
-        "正在更新配置草稿，序列号: {}",
-        current_sequence
-    );
-
-    let current_value = profiles.current.clone();
-
-    let _ = Config::profiles().await.draft_mut().patch_config(profiles);
-
-    // 在调用内核前再次验证请求有效性
-    let latest_sequence = CURRENT_REQUEST_SEQUENCE.load(Ordering::SeqCst);
-    if current_sequence < latest_sequence {
-        logging!(
-            info,
-            Type::Cmd,
-            "在内核交互前发现更新的请求 (序列号: {} < {})，放弃当前请求",
-            current_sequence,
-            latest_sequence
-        );
-        Config::profiles().await.discard();
-        return Ok(false);
-    }
-
-    perform_config_update(current_sequence, current_value, current_profile).await
+    perform_config_update(target_profile, previous_profile.as_ref()).await
 }
 
 /// 根据profile name修改profiles
@@ -572,33 +429,34 @@ pub async fn patch_profiles_config_by_profile_index(profile_index: String) -> Cm
 pub async fn patch_profile(index: String, profile: PrfItem) -> CmdResult {
     // 保存修改前检查是否有更新 update_interval
     let profiles = Config::profiles().await;
-    let should_refresh_timer = if let Ok(old_profile) = profiles.latest_ref().get_item(&index) {
+    let should_refresh_timer = if let Ok(old_profile) = profiles.latest_arc().get_item(&index)
+        && let Some(new_option) = profile.option.as_ref()
+    {
         let old_interval = old_profile.option.as_ref().and_then(|o| o.update_interval);
-        let new_interval = profile.option.as_ref().and_then(|o| o.update_interval);
+        let new_interval = new_option.update_interval;
         let old_allow_auto_update = old_profile
             .option
             .as_ref()
             .and_then(|o| o.allow_auto_update);
-        let new_allow_auto_update = profile.option.as_ref().and_then(|o| o.allow_auto_update);
+        let new_allow_auto_update = new_option.allow_auto_update;
         (old_interval != new_interval) || (old_allow_auto_update != new_allow_auto_update)
     } else {
         false
     };
 
-    profiles_patch_item_safe(index.clone(), profile)
+    profiles_patch_item_safe(&index, &profile)
         .await
         .stringify_err()?;
 
     // 如果更新间隔或允许自动更新变更，异步刷新定时器
     if should_refresh_timer {
-        let index_clone = index.clone();
         crate::process::AsyncHandler::spawn(move || async move {
             logging!(info, Type::Timer, "定时器更新间隔已变更，正在刷新定时器...");
             if let Err(e) = crate::core::Timer::global().refresh().await {
                 logging!(error, Type::Timer, "刷新定时器失败: {}", e);
             } else {
                 // 刷新成功后发送自定义事件，不触发配置重载
-                crate::core::handle::Handle::notify_timer_updated(index_clone);
+                crate::core::handle::Handle::notify_timer_updated(index);
             }
         });
     }
@@ -610,7 +468,7 @@ pub async fn patch_profile(index: String, profile: PrfItem) -> CmdResult {
 #[tauri::command]
 pub async fn view_profile(index: String) -> CmdResult {
     let profiles = Config::profiles().await;
-    let profiles_ref = profiles.latest_ref();
+    let profiles_ref = profiles.latest_arc();
     let file = profiles_ref
         .get_item(&index)
         .stringify_err()?
@@ -631,10 +489,15 @@ pub async fn view_profile(index: String) -> CmdResult {
 /// 读取配置文件内容
 #[tauri::command]
 pub async fn read_profile_file(index: String) -> CmdResult<String> {
-    let profiles = Config::profiles().await;
-    let profiles_ref = profiles.latest_ref();
-    let item = profiles_ref.get_item(&index).stringify_err()?;
-    let data = item.read_file().stringify_err()?;
+    let item = {
+        let profiles = Config::profiles().await;
+        let profiles_ref = profiles.latest_arc();
+        PrfItem {
+            file: profiles_ref.get_item(&index).stringify_err()?.file.clone(),
+            ..Default::default()
+        }
+    };
+    let data = item.read_file().await.stringify_err()?;
     Ok(data)
 }
 

src-tauri/src/cmd/runtime.rs

@@ -8,14 +8,14 @@ use std::collections::HashMap;
 /// 获取运行时配置
 #[tauri::command]
 pub async fn get_runtime_config() -> CmdResult<Option<Mapping>> {
-    Ok(Config::runtime().await.latest_ref().config.clone())
+    Ok(Config::runtime().await.latest_arc().config.clone())
 }
 
 /// 获取运行时YAML配置
 #[tauri::command]
 pub async fn get_runtime_yaml() -> CmdResult<String> {
     let runtime = Config::runtime().await;
-    let runtime = runtime.latest_ref();
+    let runtime = runtime.latest_arc();
 
     let config = runtime.config.as_ref();
     config
@@ -31,19 +31,19 @@ pub async fn get_runtime_yaml() -> CmdResult<String> {
 /// 获取运行时存在的键
 #[tauri::command]
 pub async fn get_runtime_exists() -> CmdResult<Vec<String>> {
-    Ok(Config::runtime().await.latest_ref().exists_keys.clone())
+    Ok(Config::runtime().await.latest_arc().exists_keys.clone())
 }
 
 /// 获取运行时日志
 #[tauri::command]
 pub async fn get_runtime_logs() -> CmdResult<HashMap<String, Vec<(String, String)>>> {
-    Ok(Config::runtime().await.latest_ref().chain_logs.clone())
+    Ok(Config::runtime().await.latest_arc().chain_logs.clone())
 }
 
 #[tauri::command]
 pub async fn get_runtime_proxy_chain_config(proxy_chain_exit_node: String) -> CmdResult<String> {
     let runtime = Config::runtime().await;
-    let runtime = runtime.latest_ref();
+    let runtime = runtime.latest_arc();
 
     let config = runtime
         .config
@@ -98,9 +98,7 @@ pub async fn update_proxy_chain_config_in_runtime(
 ) -> CmdResult<()> {
     {
         let runtime = Config::runtime().await;
-        let mut draft = runtime.draft_mut();
-        draft.update_proxy_chain_config(proxy_chain_config);
-        drop(draft);
+        runtime.edit_draft(|d| d.update_proxy_chain_config(proxy_chain_config));
         runtime.apply();
     }
 

src-tauri/src/cmd/save_profile.rs

@@ -12,28 +12,37 @@ use tokio::fs;
 /// 保存profiles的配置
 #[tauri::command]
 pub async fn save_profile_file(index: String, file_data: Option<String>) -> CmdResult {
-    if file_data.is_none() {
-        return Ok(());
-    }
-
-    // 在异步操作前完成所有文件操作
-    let (file_path, original_content, is_merge_file) = {
-        let profiles = Config::profiles().await;
-        let profiles_guard = profiles.latest_ref();
-        let item = profiles_guard.get_item(&index).stringify_err()?;
-        // 确定是否为merge类型文件
-        let is_merge = item.itype.as_ref().is_some_and(|t| t == "merge");
-        let content = item.read_file().stringify_err()?;
-        let path = item.file.clone().ok_or("file field is null")?;
-        let profiles_dir = dirs::app_profiles_dir().stringify_err()?;
-        (profiles_dir.join(path.as_str()), content, is_merge)
+    let file_data = match file_data {
+        Some(d) => d,
+        None => return Ok(()),
     };
 
+    // 在异步操作前获取必要元数据并释放锁
+    let (rel_path, is_merge_file) = {
+        let profiles = Config::profiles().await;
+        let profiles_guard = profiles.latest_arc();
+        let item = profiles_guard.get_item(&index).stringify_err()?;
+        let is_merge = item.itype.as_ref().is_some_and(|t| t == "merge");
+        let path = item.file.clone().ok_or("file field is null")?;
+        (path, is_merge)
+    };
+
+    // 读取原始内容（在释放profiles_guard后进行）
+    let original_content = PrfItem {
+        file: Some(rel_path.clone()),
+        ..Default::default()
+    }
+    .read_file()
+    .await
+    .stringify_err()?;
+
+    let profiles_dir = dirs::app_profiles_dir().stringify_err()?;
+    let file_path = profiles_dir.join(rel_path.as_str());
+    let file_path_str = file_path.to_string_lossy().to_string();
+
     // 保存新的配置文件
-    let file_data = file_data.ok_or("file_data is None")?;
     fs::write(&file_path, &file_data).await.stringify_err()?;
 
-    let file_path_str = file_path.to_string_lossy().to_string();
     logging!(
         info,
         Type::Config,
@@ -42,102 +51,107 @@ pub async fn save_profile_file(index: String, file_data: Option<String>) -> CmdR
         is_merge_file
     );
 
-    // 对于 merge 文件，只进行语法验证，不进行后续内核验证
     if is_merge_file {
-        logging!(
-            info,
-            Type::Config,
-            "[cmd配置save] 检测到merge文件，只进行语法验证"
-        );
-        match CoreConfigValidator::validate_config_file(&file_path_str, Some(true)).await {
-            Ok((true, _)) => {
-                logging!(info, Type::Config, "[cmd配置save] merge文件语法验证通过");
-                // 成功后尝试更新整体配置
-                match CoreManager::global().update_config().await {
-                    Ok(_) => {
-                        // 配置更新成功，刷新前端
-                        handle::Handle::refresh_clash();
-                    }
-                    Err(e) => {
-                        logging!(
-                            warn,
-                            Type::Config,
-                            "[cmd配置save] 更新整体配置时发生错误: {}",
-                            e
-                        );
-                    }
-                }
-                return Ok(());
-            }
-            Ok((false, error_msg)) => {
+        return handle_merge_file(&file_path_str, &file_path, &original_content).await;
+    }
+
+    handle_full_validation(&file_path_str, &file_path, &original_content).await
+}
+
+async fn restore_original(
+    file_path: &std::path::Path,
+    original_content: &str,
+) -> Result<(), String> {
+    fs::write(file_path, original_content).await.stringify_err()
+}
+
+fn is_script_error(err: &str, file_path_str: &str) -> bool {
+    file_path_str.ends_with(".js")
+        || err.contains("Script syntax error")
+        || err.contains("Script must contain a main function")
+        || err.contains("Failed to read script file")
+}
+
+async fn handle_merge_file(
+    file_path_str: &str,
+    file_path: &std::path::Path,
+    original_content: &str,
+) -> CmdResult {
+    logging!(
+        info,
+        Type::Config,
+        "[cmd配置save] 检测到merge文件，只进行语法验证"
+    );
+
+    match CoreConfigValidator::validate_config_file(file_path_str, Some(true)).await {
+        Ok((true, _)) => {
+            logging!(info, Type::Config, "[cmd配置save] merge文件语法验证通过");
+            if let Err(e) = CoreManager::global().update_config().await {
                 logging!(
                     warn,
                     Type::Config,
-                    "[cmd配置save] merge文件语法验证失败: {}",
-                    error_msg
+                    "[cmd配置save] 更新整体配置时发生错误: {}",
+                    e
                 );
-                // 恢复原始配置文件
-                fs::write(&file_path, original_content)
-                    .await
-                    .stringify_err()?;
-                // 发送合并文件专用错误通知
-                let result = (false, error_msg.clone());
-                crate::cmd::validate::handle_yaml_validation_notice(&result, "合并配置文件");
-                return Ok(());
-            }
-            Err(e) => {
-                logging!(error, Type::Config, "[cmd配置save] 验证过程发生错误: {}", e);
-                // 恢复原始配置文件
-                fs::write(&file_path, original_content)
-                    .await
-                    .stringify_err()?;
-                return Err(e.to_string().into());
+            } else {
+                handle::Handle::refresh_clash();
             }
+            Ok(())
+        }
+        Ok((false, error_msg)) => {
+            logging!(
+                warn,
+                Type::Config,
+                "[cmd配置save] merge文件语法验证失败: {}",
+                error_msg
+            );
+            restore_original(file_path, original_content).await?;
+            let result = (false, error_msg.clone());
+            crate::cmd::validate::handle_yaml_validation_notice(&result, "合并配置文件");
+            Ok(())
+        }
+        Err(e) => {
+            logging!(error, Type::Config, "[cmd配置save] 验证过程发生错误: {}", e);
+            restore_original(file_path, original_content).await?;
+            Err(e.to_string().into())
         }
     }
+}
 
-    // 非merge文件使用完整验证流程
-    match CoreConfigValidator::validate_config_file(&file_path_str, None).await {
+async fn handle_full_validation(
+    file_path_str: &str,
+    file_path: &std::path::Path,
+    original_content: &str,
+) -> CmdResult {
+    match CoreConfigValidator::validate_config_file(file_path_str, None).await {
         Ok((true, _)) => {
             logging!(info, Type::Config, "[cmd配置save] 验证成功");
             Ok(())
         }
         Ok((false, error_msg)) => {
             logging!(warn, Type::Config, "[cmd配置save] 验证失败: {}", error_msg);
-            // 恢复原始配置文件
-            fs::write(&file_path, original_content)
-                .await
-                .stringify_err()?;
-
-            // 智能判断错误类型
-            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");
+            restore_original(file_path, original_content).await?;
 
             if error_msg.contains("YAML syntax error")
                 || error_msg.contains("Failed to read file:")
-                || (!file_path_str.ends_with(".js") && !is_script_error)
+                || (!file_path_str.ends_with(".js") && !is_script_error(&error_msg, file_path_str))
             {
-                // 普通YAML错误使用YAML通知处理
                 logging!(
                     info,
                     Type::Config,
                     "[cmd配置save] YAML配置文件验证失败，发送通知"
                 );
-                let result = (false, error_msg.clone());
+                let result = (false, error_msg.to_owned());
                 crate::cmd::validate::handle_yaml_validation_notice(&result, "YAML配置文件");
-            } else if is_script_error {
-                // 脚本错误使用专门的通知处理
+            } else if is_script_error(&error_msg, file_path_str) {
                 logging!(
                     info,
                     Type::Config,
                     "[cmd配置save] 脚本文件验证失败，发送通知"
                 );
-                let result = (false, error_msg.clone());
+                let result = (false, error_msg.to_owned());
                 crate::cmd::validate::handle_script_validation_notice(&result, "脚本文件");
             } else {
-                // 普通配置错误使用一般通知
                 logging!(
                     info,
                     Type::Config,
@@ -150,10 +164,7 @@ pub async fn save_profile_file(index: String, file_data: Option<String>) -> CmdR
         }
         Err(e) => {
             logging!(error, Type::Config, "[cmd配置save] 验证过程发生错误: {}", e);
-            // 恢复原始配置文件
-            fs::write(&file_path, original_content)
-                .await
-                .stringify_err()?;
+            restore_original(file_path, original_content).await?;
             Err(e.to_string().into())
         }
     }

src-tauri/src/cmd/system.rs

@@ -1,26 +1,28 @@
+use std::sync::Arc;
+
 use super::CmdResult;
 use crate::{
-    core::{CoreManager, handle},
+    core::{CoreManager, handle, manager::RunningMode},
     logging,
     module::sysinfo::PlatformSpecification,
     utils::logging::Type,
 };
+#[cfg(target_os = "windows")]
+use deelevate::{PrivilegeLevel, Token};
 use once_cell::sync::Lazy;
-use std::{
-    sync::atomic::{AtomicI64, Ordering},
-    time::{SystemTime, UNIX_EPOCH},
-};
 use tauri_plugin_clipboard_manager::ClipboardExt;
+use tokio::time::Instant;
 
 // 存储应用启动时间的全局变量
-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)
+static APP_START_TIME: Lazy<Instant> = Lazy::new(Instant::now);
+#[cfg(not(target_os = "windows"))]
+static APPS_RUN_AS_ADMIN: Lazy<bool> = Lazy::new(|| unsafe { libc::geteuid() } == 0);
+#[cfg(target_os = "windows")]
+static APPS_RUN_AS_ADMIN: Lazy<bool> = Lazy::new(|| {
+    Token::with_current_process()
+        .and_then(|token| token.privilege_level())
+        .map(|level| level != PrivilegeLevel::NotPrivileged)
+        .unwrap_or(false)
 });
 
 #[tauri::command]
@@ -45,52 +47,18 @@ pub async fn get_system_info() -> CmdResult<String> {
 
 /// 获取当前内核运行模式
 #[tauri::command]
-pub async fn get_running_mode() -> Result<String, String> {
-    Ok(CoreManager::global().get_running_mode().to_string())
+pub async fn get_running_mode() -> Result<Arc<RunningMode>, String> {
+    Ok(CoreManager::global().get_running_mode())
 }
 
 /// 获取应用的运行时间（毫秒）
 #[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)
+pub fn get_app_uptime() -> CmdResult<u128> {
+    Ok(APP_START_TIME.elapsed().as_millis())
 }
 
 /// 检查应用是否以管理员身份运行
 #[tauri::command]
-#[cfg(target_os = "windows")]
 pub fn is_admin() -> CmdResult<bool> {
-    use deelevate::{PrivilegeLevel, Token};
-
-    let result = Token::with_current_process()
-        .and_then(|token| token.privilege_level())
-        .map(|level| level != PrivilegeLevel::NotPrivileged)
-        .unwrap_or(false);
-
-    Ok(result)
-}
-
-/// 非Windows平台检测是否以管理员身份运行
-#[tauri::command]
-#[cfg(not(target_os = "windows"))]
-pub fn is_admin() -> CmdResult<bool> {
-    #[cfg(target_os = "macos")]
-    {
-        Ok(unsafe { libc::geteuid() } == 0)
-    }
-
-    #[cfg(target_os = "linux")]
-    {
-        Ok(unsafe { libc::geteuid() } == 0)
-    }
-
-    #[cfg(not(any(target_os = "macos", target_os = "linux")))]
-    {
-        Ok(false)
-    }
+    Ok(*APPS_RUN_AS_ADMIN)
 }

src-tauri/src/cmd/uwp.rs

@@ -17,7 +17,7 @@ mod platform {
 mod platform {
     use super::CmdResult;
 
-    pub fn invoke_uwp_tool() -> CmdResult {
+    pub const fn invoke_uwp_tool() -> CmdResult {
         Ok(())
     }
 }

src-tauri/src/cmd/verge.rs

@@ -1,20 +1,14 @@
 use super::CmdResult;
-use crate::{cmd::StringifyErr, config::*, feat};
+use crate::{cmd::StringifyErr, config::IVerge, feat, utils::draft::SharedBox};
 
 /// 获取Verge配置
 #[tauri::command]
-pub async fn get_verge_config() -> CmdResult<IVergeResponse> {
-    let verge = Config::verge().await;
-    let verge_data = {
-        let ref_data = verge.latest_ref();
-        ref_data.clone()
-    };
-    let verge_response = IVergeResponse::from(*verge_data);
-    Ok(verge_response)
+pub async fn get_verge_config() -> CmdResult<SharedBox<IVerge>> {
+    feat::fetch_verge_config().await.stringify_err()
 }
 
 /// 修改Verge配置
 #[tauri::command]
 pub async fn patch_verge_config(payload: IVerge) -> CmdResult {
-    feat::patch_verge(payload, false).await.stringify_err()
+    feat::patch_verge(&payload, false).await.stringify_err()
 }

src-tauri/src/cmd/webdav.rs

@@ -1,5 +1,9 @@
 use super::CmdResult;
-use crate::{cmd::StringifyErr, config::*, core, feat};
+use crate::{
+    cmd::StringifyErr,
+    config::{Config, IVerge},
+    core, feat,
+};
 use reqwest_dav::list_cmd::ListFile;
 use smartstring::alias::String;
 
@@ -12,18 +16,11 @@ pub async fn save_webdav_config(url: String, username: String, password: String)
         webdav_password: Some(password),
         ..IVerge::default()
     };
-    Config::verge()
-        .await
-        .draft_mut()
-        .patch_config(patch.clone());
+    Config::verge().await.edit_draft(|e| e.patch_config(&patch));
     Config::verge().await.apply();
 
-    // 分离数据获取和异步调用
-    let verge_data = Config::verge().await.latest_ref().clone();
-    verge_data
-        .save_file()
-        .await
-        .map_err(|err| err.to_string())?;
+    let verge_data = Config::verge().await.latest_arc();
+    verge_data.save_file().await.stringify_err()?;
     core::backup::WebDavClient::global().reset();
     Ok(())
 }

src-tauri/src/config/clash.rs

@@ -1,6 +1,8 @@
 use crate::config::Config;
+use crate::constants::{network, tun as tun_const};
 use crate::utils::dirs::{ipc_path, path_to_str};
 use crate::utils::{dirs, help};
+use crate::{logging, utils::logging::Type};
 use anyhow::Result;
 use serde::{Deserialize, Serialize};
 use serde_yaml_ng::{Mapping, Value};
@@ -40,15 +42,13 @@ impl IClashTemp {
                 Self(Self::guard(map))
             }
             Err(err) => {
-                log::error!(target: "app", "{err}");
+                logging!(error, Type::Config, "{err}");
                 template
             }
         }
     }
 
     pub fn template() -> Self {
-        use crate::constants::{network, tun as tun_const};
-
         let mut map = Mapping::new();
         let mut tun_config = Mapping::new();
         let mut cors_map = Mapping::new();
@@ -214,9 +214,9 @@ impl IClashTemp {
                 Value::Number(val_num) => val_num.as_u64().map(|u| u as u16),
                 _ => None,
             })
-            .unwrap_or(7896);
+            .unwrap_or(network::ports::DEFAULT_TPROXY);
         if port == 0 {
-            port = 7896;
+            port = network::ports::DEFAULT_TPROXY;
         }
         port
     }
@@ -300,7 +300,7 @@ impl IClashTemp {
         // 检查 enable_external_controller 设置，用于运行时配置生成
         let enable_external_controller = Config::verge()
             .await
-            .latest_ref()
+            .latest_arc()
             .enable_external_controller
             .unwrap_or(false);
 
@@ -330,7 +330,7 @@ impl IClashTemp {
             .ok()
             .and_then(|path| path_to_str(&path).ok().map(|s| s.into()))
             .unwrap_or_else(|| {
-                log::error!(target: "app", "Failed to get IPC path");
+                logging!(error, Type::Config, "Failed to get IPC path");
                 crate::constants::network::DEFAULT_EXTERNAL_CONTROLLER.into()
             })
     }

src-tauri/src/config/config.rs

@@ -1,9 +1,10 @@
 use super::{IClashTemp, IProfiles, IRuntime, IVerge};
 use crate::{
+    cmd,
     config::{PrfItem, profiles_append_item_safe},
     constants::{files, timing},
-    core::{CoreManager, handle, validate::CoreConfigValidator},
-    enhance, logging,
+    core::{CoreManager, handle, service, tray, validate::CoreConfigValidator},
+    enhance, logging, logging_error,
     utils::{Draft, dirs, help, logging::Type},
 };
 use anyhow::{Result, anyhow};
@@ -14,40 +15,40 @@ use tokio::sync::OnceCell;
 use tokio::time::sleep;
 
 pub struct Config {
-    clash_config: Draft<Box<IClashTemp>>,
-    verge_config: Draft<Box<IVerge>>,
-    profiles_config: Draft<Box<IProfiles>>,
-    runtime_config: Draft<Box<IRuntime>>,
+    clash_config: Draft<IClashTemp>,
+    verge_config: Draft<IVerge>,
+    profiles_config: Draft<IProfiles>,
+    runtime_config: Draft<IRuntime>,
 }
 
 impl Config {
-    pub async fn global() -> &'static Config {
+    pub async fn global() -> &'static Self {
         static CONFIG: OnceCell<Config> = OnceCell::const_new();
         CONFIG
             .get_or_init(|| async {
-                Config {
-                    clash_config: Draft::from(Box::new(IClashTemp::new().await)),
-                    verge_config: Draft::from(Box::new(IVerge::new().await)),
-                    profiles_config: Draft::from(Box::new(IProfiles::new().await)),
-                    runtime_config: Draft::from(Box::new(IRuntime::new())),
+                Self {
+                    clash_config: Draft::new(IClashTemp::new().await),
+                    verge_config: Draft::new(IVerge::new().await),
+                    profiles_config: Draft::new(IProfiles::new().await),
+                    runtime_config: Draft::new(IRuntime::new()),
                 }
             })
             .await
     }
 
-    pub async fn clash() -> Draft<Box<IClashTemp>> {
+    pub async fn clash() -> Draft<IClashTemp> {
         Self::global().await.clash_config.clone()
     }
 
-    pub async fn verge() -> Draft<Box<IVerge>> {
+    pub async fn verge() -> Draft<IVerge> {
         Self::global().await.verge_config.clone()
     }
 
-    pub async fn profiles() -> Draft<Box<IProfiles>> {
+    pub async fn profiles() -> Draft<IProfiles> {
         Self::global().await.profiles_config.clone()
     }
 
-    pub async fn runtime() -> Draft<Box<IRuntime>> {
+    pub async fn runtime() -> Draft<IRuntime> {
         Self::global().await.runtime_config.clone()
     }
 
@@ -55,6 +56,22 @@ impl Config {
     pub async fn init_config() -> Result<()> {
         Self::ensure_default_profile_items().await?;
 
+        // init Tun mode
+        if !cmd::system::is_admin().unwrap_or_default()
+            && service::is_service_available().await.is_err()
+        {
+            let verge = Self::verge().await;
+            verge.edit_draft(|d| {
+                d.enable_tun_mode = Some(false);
+            });
+            verge.apply();
+            let _ = tray::Tray::global().update_menu().await;
+
+            // 分离数据获取和异步调用避免Send问题
+            let verge_data = Self::verge().await.latest_arc();
+            logging_error!(Type::Core, verge_data.save_file().await);
+        }
+
         let validation_result = Self::generate_and_validate().await?;
 
         if let Some((msg_type, msg_content)) = validation_result {
@@ -68,13 +85,13 @@ impl Config {
     // Ensure "Merge" and "Script" profile items exist, adding them if missing.
     async fn ensure_default_profile_items() -> Result<()> {
         let profiles = Self::profiles().await;
-        if profiles.latest_ref().get_item(&"Merge".into()).is_err() {
-            let merge_item = PrfItem::from_merge(Some("Merge".into()))?;
-            profiles_append_item_safe(merge_item.clone()).await?;
+        if profiles.latest_arc().get_item("Merge").is_err() {
+            let merge_item = &mut PrfItem::from_merge(Some("Merge".into()))?;
+            profiles_append_item_safe(merge_item).await?;
         }
-        if profiles.latest_ref().get_item(&"Script".into()).is_err() {
-            let script_item = PrfItem::from_script(Some("Script".into()))?;
-            profiles_append_item_safe(script_item.clone()).await?;
+        if profiles.latest_arc().get_item("Script").is_err() {
+            let script_item = &mut PrfItem::from_script(Some("Script".into()))?;
+            profiles_append_item_safe(script_item).await?;
         }
         Ok(())
     }
@@ -137,26 +154,26 @@ impl Config {
             ConfigType::Check => dirs::app_home_dir()?.join(files::CHECK_CONFIG),
         };
 
-        let runtime = Config::runtime().await;
-        let config = runtime
-            .latest_ref()
+        let runtime = Self::runtime().await;
+        let runtime_arc = runtime.latest_arc();
+        let config = runtime_arc
             .config
             .as_ref()
-            .ok_or_else(|| anyhow!("failed to get runtime config"))?
-            .clone();
-        drop(runtime); // 显式释放锁
+            .ok_or_else(|| anyhow!("failed to get runtime config"))?;
 
-        help::save_yaml(&path, &config, Some("# Generated by Clash Verge")).await?;
+        help::save_yaml(&path, config, Some("# Generated by Clash Verge")).await?;
         Ok(path)
     }
 
     pub async fn generate() -> Result<()> {
         let (config, exists_keys, logs) = enhance::enhance().await;
 
-        *Config::runtime().await.draft_mut() = Box::new(IRuntime {
-            config: Some(config),
-            exists_keys,
-            chain_logs: logs,
+        Self::runtime().await.edit_draft(|d| {
+            *d = IRuntime {
+                config: Some(config),
+                exists_keys,
+                chain_logs: logs,
+            }
         });
 
         Ok(())
@@ -172,11 +189,11 @@ impl Config {
         };
 
         let operation = || async {
-            if Config::runtime().await.latest_ref().config.is_some() {
+            if Self::runtime().await.latest_arc().config.is_some() {
                 return Ok::<(), BackoffError<anyhow::Error>>(());
             }
 
-            Config::generate().await.map_err(BackoffError::transient)
+            Self::generate().await.map_err(BackoffError::transient)
         };
 
         if let Err(e) = backoff::future::retry(backoff_strategy, operation).await {
@@ -213,7 +230,7 @@ mod tests {
     #[test]
     #[allow(unused_variables)]
     fn test_draft_size_non_boxed() {
-        let draft = Draft::from(IRuntime::new());
+        let draft = Draft::new(IRuntime::new());
         let iruntime_size = std::mem::size_of_val(&draft);
         assert_eq!(iruntime_size, std::mem::size_of::<Draft<IRuntime>>());
     }
@@ -221,7 +238,7 @@ mod tests {
     #[test]
     #[allow(unused_variables)]
     fn test_draft_size_boxed() {
-        let draft = Draft::from(Box::new(IRuntime::new()));
+        let draft = Draft::new(Box::new(IRuntime::new()));
         let box_iruntime_size = std::mem::size_of_val(&draft);
         assert_eq!(
             box_iruntime_size,

src-tauri/src/config/encrypt.rs

@@ -5,9 +5,16 @@ use aes_gcm::{
 };
 use base64::{Engine, engine::general_purpose::STANDARD};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use std::cell::Cell;
+use std::future::Future;
 
 const NONCE_LENGTH: usize = 12;
 
+// Use task-local context so the flag follows the async task across threads
+tokio::task_local! {
+    static ENCRYPTION_ACTIVE: Cell<bool>;
+}
+
 /// Encrypt data
 #[allow(deprecated)]
 pub fn encrypt_data(data: &str) -> Result<String, Box<dyn std::error::Error>> {
@@ -59,39 +66,45 @@ where
     T: Serialize,
     S: Serializer,
 {
-    // 如果序列化失败，返回 None
-    let json = match serde_json::to_string(value) {
-        Ok(j) => j,
-        Err(_) => return serializer.serialize_none(),
-    };
-
-    // 如果加密失败，返回 None
-    match encrypt_data(&json) {
-        Ok(encrypted) => serializer.serialize_str(&encrypted),
-        Err(_) => serializer.serialize_none(),
+    if is_encryption_active() {
+        let json = serde_json::to_string(value).map_err(serde::ser::Error::custom)?;
+        let encrypted = encrypt_data(&json).map_err(serde::ser::Error::custom)?;
+        serializer.serialize_str(&encrypted)
+    } else {
+        value.serialize(serializer)
     }
 }
 
 /// Deserialize decrypted function
-pub fn deserialize_encrypted<'a, T, D>(deserializer: D) -> Result<T, D::Error>
+pub fn deserialize_encrypted<'a, D, T>(deserializer: D) -> Result<T, D::Error>
 where
     T: for<'de> Deserialize<'de> + Default,
     D: Deserializer<'a>,
 {
-    // 如果反序列化字符串失败，返回默认值
-    let encrypted = match String::deserialize(deserializer) {
-        Ok(s) => s,
-        Err(_) => return Ok(T::default()),
-    };
+    if is_encryption_active() {
+        let encrypted_opt: Option<String> = Option::deserialize(deserializer)?;
 
-    // 如果解密失败，返回默认值
-    let decrypted_string = match decrypt_data(&encrypted) {
-        Ok(data) => data,
-        Err(_) => return Ok(T::default()),
-    };
-    // 如果 JSON 解析失败，返回默认值
-    match serde_json::from_str(&decrypted_string) {
-        Ok(value) => Ok(value),
-        Err(_) => Ok(T::default()),
+        match encrypted_opt {
+            Some(encrypted) if !encrypted.is_empty() => {
+                let decrypted_string =
+                    decrypt_data(&encrypted).map_err(serde::de::Error::custom)?;
+                serde_json::from_str(&decrypted_string).map_err(serde::de::Error::custom)
+            }
+            _ => Ok(T::default()),
+        }
+    } else {
+        T::deserialize(deserializer)
     }
 }
+
+pub async fn with_encryption<F, Fut, R>(f: F) -> R
+where
+    F: FnOnce() -> Fut,
+    Fut: Future<Output = R>,
+{
+    ENCRYPTION_ACTIVE.scope(Cell::new(true), f()).await
+}
+
+fn is_encryption_active() -> bool {
+    ENCRYPTION_ACTIVE.try_with(|c| c.get()).unwrap_or(false)
+}

src-tauri/src/config/prfitem.rs

@@ -1,13 +1,17 @@
-use crate::utils::{
-    dirs, help,
-    network::{NetworkManager, ProxyType},
-    tmpl,
+use crate::{
+    config::profiles,
+    utils::{
+        dirs, help,
+        network::{NetworkManager, ProxyType},
+        tmpl,
+    },
 };
 use anyhow::{Context, Result, bail};
 use serde::{Deserialize, Serialize};
 use serde_yaml_ng::Mapping;
 use smartstring::alias::String;
-use std::{fs, time::Duration};
+use std::time::Duration;
+use tokio::fs;
 
 #[derive(Debug, Clone, Deserialize, Serialize, Default)]
 pub struct PrfItem {
@@ -118,26 +122,29 @@ pub struct PrfOption {
 }
 
 impl PrfOption {
-    pub fn merge(one: Option<Self>, other: Option<Self>) -> Option<Self> {
+    pub fn merge(one: Option<&Self>, other: Option<&Self>) -> Option<Self> {
         match (one, other) {
-            (Some(mut a), Some(b)) => {
-                a.user_agent = b.user_agent.or(a.user_agent);
-                a.with_proxy = b.with_proxy.or(a.with_proxy);
-                a.self_proxy = b.self_proxy.or(a.self_proxy);
-                a.danger_accept_invalid_certs = b
+            (Some(a_ref), Some(b_ref)) => {
+                let mut result = a_ref.clone();
+                result.user_agent = b_ref.user_agent.clone().or(result.user_agent);
+                result.with_proxy = b_ref.with_proxy.or(result.with_proxy);
+                result.self_proxy = b_ref.self_proxy.or(result.self_proxy);
+                result.danger_accept_invalid_certs = b_ref
                     .danger_accept_invalid_certs
-                    .or(a.danger_accept_invalid_certs);
-                a.allow_auto_update = b.allow_auto_update.or(a.allow_auto_update);
-                a.update_interval = b.update_interval.or(a.update_interval);
-                a.merge = b.merge.or(a.merge);
-                a.script = b.script.or(a.script);
-                a.rules = b.rules.or(a.rules);
-                a.proxies = b.proxies.or(a.proxies);
-                a.groups = b.groups.or(a.groups);
-                a.timeout_seconds = b.timeout_seconds.or(a.timeout_seconds);
-                Some(a)
+                    .or(result.danger_accept_invalid_certs);
+                result.allow_auto_update = b_ref.allow_auto_update.or(result.allow_auto_update);
+                result.update_interval = b_ref.update_interval.or(result.update_interval);
+                result.merge = b_ref.merge.clone().or(result.merge);
+                result.script = b_ref.script.clone().or(result.script);
+                result.rules = b_ref.rules.clone().or(result.rules);
+                result.proxies = b_ref.proxies.clone().or(result.proxies);
+                result.groups = b_ref.groups.clone().or(result.groups);
+                result.timeout_seconds = b_ref.timeout_seconds.or(result.timeout_seconds);
+                Some(result)
             }
-            t => t.0.or(t.1),
+            (Some(a_ref), None) => Some(a_ref.clone()),
+            (None, Some(b_ref)) => Some(b_ref.clone()),
+            (None, None) => None,
         }
     }
 }
@@ -145,13 +152,14 @@ impl PrfOption {
 impl PrfItem {
     /// From partial item
     /// must contain `itype`
-    pub async fn from(item: PrfItem, file_data: Option<String>) -> Result<PrfItem> {
+    pub async fn from(item: &Self, file_data: Option<String>) -> Result<Self> {
         if item.itype.is_none() {
             bail!("type should not be null");
         }
 
         let itype = item
             .itype
+            .as_ref()
             .ok_or_else(|| anyhow::anyhow!("type should not be null"))?;
         match itype.as_str() {
             "remote" => {
@@ -159,14 +167,16 @@ impl PrfItem {
                     .url
                     .as_ref()
                     .ok_or_else(|| anyhow::anyhow!("url should not be null"))?;
-                let name = item.name;
-                let desc = item.desc;
-                PrfItem::from_url(url, name, desc, item.option).await
+                let name = item.name.as_ref();
+                let desc = item.desc.as_ref();
+                let option = item.option.as_ref();
+                Self::from_url(url, name, desc, option).await
             }
             "local" => {
-                let name = item.name.unwrap_or_else(|| "Local File".into());
-                let desc = item.desc.unwrap_or_else(|| "".into());
-                PrfItem::from_local(name, desc, file_data, item.option).await
+                let name = item.name.clone().unwrap_or_else(|| "Local File".into());
+                let desc = item.desc.clone().unwrap_or_else(|| "".into());
+                let option = item.option.as_ref();
+                Self::from_local(name, desc, file_data, option).await
             }
             typ => bail!("invalid profile item type \"{typ}\""),
         }
@@ -178,8 +188,8 @@ impl PrfItem {
         name: String,
         desc: String,
         file_data: Option<String>,
-        option: Option<PrfOption>,
-    ) -> Result<PrfItem> {
+        option: Option<&PrfOption>,
+    ) -> Result<Self> {
         let uid = help::get_uid("L").into();
         let file = format!("{uid}.yaml").into();
         let opt_ref = option.as_ref();
@@ -191,31 +201,31 @@ impl PrfItem {
         let mut groups = opt_ref.and_then(|o| o.groups.clone());
 
         if merge.is_none() {
-            let merge_item = PrfItem::from_merge(None)?;
-            crate::config::profiles::profiles_append_item_safe(merge_item.clone()).await?;
-            merge = merge_item.uid;
+            let merge_item = &mut Self::from_merge(None)?;
+            profiles::profiles_append_item_safe(merge_item).await?;
+            merge = merge_item.uid.clone();
         }
         if script.is_none() {
-            let script_item = PrfItem::from_script(None)?;
-            crate::config::profiles::profiles_append_item_safe(script_item.clone()).await?;
-            script = script_item.uid;
+            let script_item = &mut Self::from_script(None)?;
+            profiles::profiles_append_item_safe(script_item).await?;
+            script = script_item.uid.clone();
         }
         if rules.is_none() {
-            let rules_item = PrfItem::from_rules()?;
-            crate::config::profiles::profiles_append_item_safe(rules_item.clone()).await?;
-            rules = rules_item.uid;
+            let rules_item = &mut Self::from_rules()?;
+            profiles::profiles_append_item_safe(rules_item).await?;
+            rules = rules_item.uid.clone();
         }
         if proxies.is_none() {
-            let proxies_item = PrfItem::from_proxies()?;
-            crate::config::profiles::profiles_append_item_safe(proxies_item.clone()).await?;
-            proxies = proxies_item.uid;
+            let proxies_item = &mut Self::from_proxies()?;
+            profiles::profiles_append_item_safe(proxies_item).await?;
+            proxies = proxies_item.uid.clone();
         }
         if groups.is_none() {
-            let groups_item = PrfItem::from_groups()?;
-            crate::config::profiles::profiles_append_item_safe(groups_item.clone()).await?;
-            groups = groups_item.uid;
+            let groups_item = &mut Self::from_groups()?;
+            profiles::profiles_append_item_safe(groups_item).await?;
+            groups = groups_item.uid.clone();
         }
-        Ok(PrfItem {
+        Ok(Self {
             uid: Some(uid),
             itype: Some("local".into()),
             name: Some(name),
@@ -243,24 +253,23 @@ impl PrfItem {
     /// create a new item from url
     pub async fn from_url(
         url: &str,
-        name: Option<String>,
-        desc: Option<String>,
-        option: Option<PrfOption>,
-    ) -> Result<PrfItem> {
-        let opt_ref = option.as_ref();
-        let with_proxy = opt_ref.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));
+        name: Option<&String>,
+        desc: Option<&String>,
+        option: Option<&PrfOption>,
+    ) -> Result<Self> {
+        let with_proxy = option.is_some_and(|o| o.with_proxy.unwrap_or(false));
+        let self_proxy = option.is_some_and(|o| o.self_proxy.unwrap_or(false));
         let accept_invalid_certs =
-            opt_ref.is_some_and(|o| o.danger_accept_invalid_certs.unwrap_or(false));
-        let allow_auto_update = opt_ref.map(|o| o.allow_auto_update.unwrap_or(true));
-        let user_agent = opt_ref.and_then(|o| o.user_agent.clone());
-        let update_interval = opt_ref.and_then(|o| o.update_interval);
-        let timeout = opt_ref.and_then(|o| o.timeout_seconds).unwrap_or(20);
-        let mut merge = opt_ref.and_then(|o| o.merge.clone());
-        let mut script = opt_ref.and_then(|o| o.script.clone());
-        let mut rules = opt_ref.and_then(|o| o.rules.clone());
-        let mut proxies = opt_ref.and_then(|o| o.proxies.clone());
-        let mut groups = opt_ref.and_then(|o| o.groups.clone());
+            option.is_some_and(|o| o.danger_accept_invalid_certs.unwrap_or(false));
+        let allow_auto_update = option.map(|o| o.allow_auto_update.unwrap_or(true));
+        let user_agent = option.and_then(|o| o.user_agent.clone());
+        let update_interval = option.and_then(|o| o.update_interval);
+        let timeout = option.and_then(|o| o.timeout_seconds).unwrap_or(20);
+        let mut merge = option.and_then(|o| o.merge.clone());
+        let mut script = option.and_then(|o| o.script.clone());
+        let mut rules = option.and_then(|o| o.rules.clone());
+        let mut proxies = option.and_then(|o| o.proxies.clone());
+        let mut groups = option.and_then(|o| o.groups.clone());
 
         // 选择代理类型
         let proxy_type = if self_proxy {
@@ -297,18 +306,27 @@ impl PrfItem {
         let header = resp.headers();
 
         // parse the Subscription UserInfo
-        let extra = match header.get("Subscription-Userinfo") {
-            Some(value) => {
-                let sub_info = value.to_str().unwrap_or("");
-                Some(PrfExtra {
-                    upload: help::parse_str(sub_info, "upload").unwrap_or(0),
-                    download: help::parse_str(sub_info, "download").unwrap_or(0),
-                    total: help::parse_str(sub_info, "total").unwrap_or(0),
-                    expire: help::parse_str(sub_info, "expire").unwrap_or(0),
-                })
+        let extra;
+        'extra: {
+            for (k, v) in header.iter() {
+                let key_lower = k.as_str().to_ascii_lowercase();
+                // Accept standard custom-metadata prefixes (x-amz-meta-, x-obs-meta-, x-cos-meta-, etc.).
+                if key_lower
+                    .strip_suffix("subscription-userinfo")
+                    .is_some_and(|prefix| prefix.is_empty() || prefix.ends_with('-'))
+                {
+                    let sub_info = v.to_str().unwrap_or("");
+                    extra = Some(PrfExtra {
+                        upload: help::parse_str(sub_info, "upload").unwrap_or(0),
+                        download: help::parse_str(sub_info, "download").unwrap_or(0),
+                        total: help::parse_str(sub_info, "total").unwrap_or(0),
+                        expire: help::parse_str(sub_info, "expire").unwrap_or(0),
+                    });
+                    break 'extra;
+                }
             }
-            None => None,
-        };
+            extra = None;
+        }
 
         // parse the Content-Disposition
         let filename = match header.get("Content-Disposition") {
@@ -356,7 +374,11 @@ impl PrfItem {
 
         let uid = help::get_uid("R").into();
         let file = format!("{uid}.yaml").into();
-        let name = name.unwrap_or_else(|| filename.unwrap_or_else(|| "Remote File".into()).into());
+        let name = name.map(|s| s.to_owned()).unwrap_or_else(|| {
+            filename
+                .map(|s| s.into())
+                .unwrap_or_else(|| "Remote File".into())
+        });
         let data = resp.text_with_charset()?;
 
         // process the charset "UTF-8 with BOM"
@@ -371,36 +393,36 @@ impl PrfItem {
         }
 
         if merge.is_none() {
-            let merge_item = PrfItem::from_merge(None)?;
-            crate::config::profiles::profiles_append_item_safe(merge_item.clone()).await?;
-            merge = merge_item.uid;
+            let merge_item = &mut Self::from_merge(None)?;
+            profiles::profiles_append_item_safe(merge_item).await?;
+            merge = merge_item.uid.clone();
         }
         if script.is_none() {
-            let script_item = PrfItem::from_script(None)?;
-            crate::config::profiles::profiles_append_item_safe(script_item.clone()).await?;
-            script = script_item.uid;
+            let script_item = &mut Self::from_script(None)?;
+            profiles::profiles_append_item_safe(script_item).await?;
+            script = script_item.uid.clone();
         }
         if rules.is_none() {
-            let rules_item = PrfItem::from_rules()?;
-            crate::config::profiles::profiles_append_item_safe(rules_item.clone()).await?;
-            rules = rules_item.uid;
+            let rules_item = &mut Self::from_rules()?;
+            profiles::profiles_append_item_safe(rules_item).await?;
+            rules = rules_item.uid.clone();
         }
         if proxies.is_none() {
-            let proxies_item = PrfItem::from_proxies()?;
-            crate::config::profiles::profiles_append_item_safe(proxies_item.clone()).await?;
-            proxies = proxies_item.uid;
+            let proxies_item = &mut Self::from_proxies()?;
+            profiles::profiles_append_item_safe(proxies_item).await?;
+            proxies = proxies_item.uid.clone();
         }
         if groups.is_none() {
-            let groups_item = PrfItem::from_groups()?;
-            crate::config::profiles::profiles_append_item_safe(groups_item.clone()).await?;
-            groups = groups_item.uid;
+            let groups_item = &mut Self::from_groups()?;
+            profiles::profiles_append_item_safe(groups_item).await?;
+            groups = groups_item.uid.clone();
         }
 
-        Ok(PrfItem {
+        Ok(Self {
             uid: Some(uid),
             itype: Some("remote".into()),
             name: Some(name),
-            desc,
+            desc: desc.cloned(),
             file: Some(file),
             url: Some(url.into()),
             selected: None,
@@ -423,16 +445,15 @@ impl PrfItem {
 
     /// ## Merge type (enhance)
     /// create the enhanced item by using `merge` rule
-    pub fn from_merge(uid: Option<String>) -> Result<PrfItem> {
-        let mut id = help::get_uid("m").into();
-        let mut template = tmpl::ITEM_MERGE_EMPTY.into();
-        if let Some(uid) = uid {
-            id = uid;
-            template = tmpl::ITEM_MERGE.into();
-        }
+    pub fn from_merge(uid: Option<String>) -> Result<Self> {
+        let (id, template) = if let Some(uid) = uid {
+            (uid, tmpl::ITEM_MERGE.into())
+        } else {
+            (help::get_uid("m").into(), tmpl::ITEM_MERGE_EMPTY.into())
+        };
         let file = format!("{id}.yaml").into();
 
-        Ok(PrfItem {
+        Ok(Self {
             uid: Some(id),
             itype: Some("merge".into()),
             name: None,
@@ -450,14 +471,14 @@ impl PrfItem {
 
     /// ## Script type (enhance)
     /// create the enhanced item by using javascript quick.js
-    pub fn from_script(uid: Option<String>) -> Result<PrfItem> {
-        let mut id = help::get_uid("s").into();
-        if let Some(uid) = uid {
-            id = uid;
-        }
+    pub fn from_script(uid: Option<String>) -> Result<Self> {
+        let id = if let Some(uid) = uid {
+            uid
+        } else {
+            help::get_uid("s").into()
+        };
         let file = format!("{id}.js").into(); // js ext
-
-        Ok(PrfItem {
+        Ok(Self {
             uid: Some(id),
             itype: Some("script".into()),
             name: None,
@@ -474,11 +495,11 @@ impl PrfItem {
     }
 
     /// ## Rules type (enhance)
-    pub fn from_rules() -> Result<PrfItem> {
+    pub fn from_rules() -> Result<Self> {
         let uid = help::get_uid("r").into();
         let file = format!("{uid}.yaml").into(); // yaml ext
 
-        Ok(PrfItem {
+        Ok(Self {
             uid: Some(uid),
             itype: Some("rules".into()),
             name: None,
@@ -495,11 +516,11 @@ impl PrfItem {
     }
 
     /// ## Proxies type (enhance)
-    pub fn from_proxies() -> Result<PrfItem> {
+    pub fn from_proxies() -> Result<Self> {
         let uid = help::get_uid("p").into();
         let file = format!("{uid}.yaml").into(); // yaml ext
 
-        Ok(PrfItem {
+        Ok(Self {
             uid: Some(uid),
             itype: Some("proxies".into()),
             name: None,
@@ -516,11 +537,11 @@ impl PrfItem {
     }
 
     /// ## Groups type (enhance)
-    pub fn from_groups() -> Result<PrfItem> {
+    pub fn from_groups() -> Result<Self> {
         let uid = help::get_uid("g").into();
         let file = format!("{uid}.yaml").into(); // yaml ext
 
-        Ok(PrfItem {
+        Ok(Self {
             uid: Some(uid),
             itype: Some("groups".into()),
             name: None,
@@ -537,28 +558,59 @@ impl PrfItem {
     }
 
     /// get the file data
-    pub fn read_file(&self) -> Result<String> {
+    pub async fn read_file(&self) -> Result<String> {
         let file = self
             .file
-            .clone()
+            .as_ref()
             .ok_or_else(|| anyhow::anyhow!("could not find the file"))?;
         let path = dirs::app_profiles_dir()?.join(file.as_str());
-        let content = fs::read_to_string(path).context("failed to read the file")?;
+        let content = fs::read_to_string(path)
+            .await
+            .context("failed to read the file")?;
         Ok(content.into())
     }
 
     /// save the file data
-    pub fn save_file(&self, data: String) -> Result<()> {
+    pub async fn save_file(&self, data: String) -> Result<()> {
         let file = self
             .file
-            .clone()
+            .as_ref()
             .ok_or_else(|| anyhow::anyhow!("could not find the file"))?;
         let path = dirs::app_profiles_dir()?.join(file.as_str());
-        fs::write(path, data.as_bytes()).context("failed to save the file")
+        fs::write(path, data.as_bytes())
+            .await
+            .context("failed to save the file")
+    }
+}
+
+impl PrfItem {
+    /// 获取current指向的订阅的merge
+    pub fn current_merge(&self) -> Option<String> {
+        self.option.as_ref().and_then(|o| o.merge.clone())
+    }
+
+    /// 获取current指向的订阅的script
+    pub fn current_script(&self) -> Option<String> {
+        self.option.as_ref().and_then(|o| o.script.clone())
+    }
+
+    /// 获取current指向的订阅的rules
+    pub fn current_rules(&self) -> Option<String> {
+        self.option.as_ref().and_then(|o| o.rules.clone())
+    }
+
+    /// 获取current指向的订阅的proxies
+    pub fn current_proxies(&self) -> Option<String> {
+        self.option.as_ref().and_then(|o| o.proxies.clone())
+    }
+
+    /// 获取current指向的订阅的groups
+    pub fn current_groups(&self) -> Option<String> {
+        self.option.as_ref().and_then(|o| o.groups.clone())
     }
 }
 
 // 向前兼容，默认为订阅启用自动更新
-fn default_allow_auto_update() -> Option<bool> {
+const fn default_allow_auto_update() -> Option<bool> {
     Some(true)
 }

src-tauri/src/config/profiles.rs

@@ -3,11 +3,12 @@ use crate::utils::{
     dirs::{self, PathBufExec},
     help,
 };
+use crate::{logging, utils::logging::Type};
 use anyhow::{Context, Result, bail};
 use serde::{Deserialize, Serialize};
 use serde_yaml_ng::Mapping;
 use smartstring::alias::String;
-use std::collections::HashSet;
+use std::{collections::HashSet, sync::Arc};
 use tokio::fs;
 
 /// Define the `profiles.yaml` schema
@@ -31,7 +32,7 @@ pub struct CleanupResult {
 macro_rules! patch {
     ($lv: expr, $rv: expr, $key: tt) => {
         if ($rv.$key).is_some() {
-            $lv.$key = $rv.$key;
+            $lv.$key = $rv.$key.to_owned();
         }
     };
 }
@@ -49,39 +50,30 @@ impl IProfiles {
         }
         None
     }
-    pub async fn new() -> Self {
-        match dirs::profiles_path() {
-            Ok(path) => match help::read_yaml::<Self>(&path).await {
-                Ok(mut profiles) => {
-                    if profiles.items.is_none() {
-                        profiles.items = Some(vec![]);
-                    }
-                    // compatible with the old old old version
-                    if let Some(items) = profiles.items.as_mut() {
-                        for item in items.iter_mut() {
-                            if item.uid.is_none() {
-                                item.uid = Some(help::get_uid("d").into());
-                            }
-                        }
-                    }
-                    profiles
-                }
-                Err(err) => {
-                    log::error!(target: "app", "{err}");
-                    Self::template()
-                }
-            },
-            Err(err) => {
-                log::error!(target: "app", "{err}");
-                Self::template()
-            }
-        }
-    }
 
-    pub fn template() -> Self {
-        Self {
-            items: Some(vec![]),
-            ..Self::default()
+    pub async fn new() -> Self {
+        let path = match dirs::profiles_path() {
+            Ok(p) => p,
+            Err(err) => {
+                logging!(error, Type::Config, "{err}");
+                return Self::default();
+            }
+        };
+
+        match help::read_yaml::<Self>(&path).await {
+            Ok(mut profiles) => {
+                let items = profiles.items.get_or_insert_with(Vec::new);
+                for item in items.iter_mut() {
+                    if item.uid.is_none() {
+                        item.uid = Some(help::get_uid("d").into());
+                    }
+                }
+                profiles
+            }
+            Err(err) => {
+                logging!(error, Type::Config, "{err}");
+                Self::default()
+            }
         }
     }
 
@@ -95,55 +87,64 @@ impl IProfiles {
     }
 
     /// 只修改current，valid和chain
-    pub fn patch_config(&mut self, patch: IProfiles) -> Result<()> {
+    pub fn patch_config(&mut self, patch: &Self) {
         if self.items.is_none() {
             self.items = Some(vec![]);
         }
 
-        if let Some(current) = patch.current
+        if let Some(current) = &patch.current
             && let Some(items) = self.items.as_ref()
         {
             let some_uid = Some(current);
-            if items.iter().any(|e| e.uid == some_uid) {
-                self.current = some_uid;
+            if items.iter().any(|e| e.uid.as_ref() == some_uid) {
+                self.current = some_uid.cloned();
             }
         }
-
-        Ok(())
     }
 
-    pub fn get_current(&self) -> Option<String> {
-        self.current.clone()
+    pub const fn get_current(&self) -> Option<&String> {
+        self.current.as_ref()
     }
 
     /// get items ref
-    pub fn get_items(&self) -> Option<&Vec<PrfItem>> {
+    pub const fn get_items(&self) -> Option<&Vec<PrfItem>> {
         self.items.as_ref()
     }
 
     /// find the item by the uid
-    pub fn get_item(&self, uid: &String) -> Result<&PrfItem> {
-        if let Some(items) = self.items.as_ref() {
-            let some_uid = Some(uid.clone());
+    pub fn get_item(&self, uid: impl AsRef<str>) -> Result<&PrfItem> {
+        let uid_str = uid.as_ref();
 
+        if let Some(items) = self.items.as_ref() {
             for each in items.iter() {
-                if each.uid == some_uid {
+                if let Some(uid_val) = &each.uid
+                    && uid_val.as_str() == uid_str
+                {
                     return Ok(each);
                 }
             }
         }
 
-        bail!("failed to get the profile item \"uid:{uid}\"");
+        bail!("failed to get the profile item \"uid:{}\"", uid_str);
+    }
+
+    pub fn get_item_arc(&self, uid: &str) -> Option<Arc<PrfItem>> {
+        self.items.as_ref().and_then(|items| {
+            items
+                .iter()
+                .find(|it| it.uid.as_deref() == Some(uid))
+                .map(|it| Arc::new(it.clone()))
+        })
     }
 
     /// append new item
     /// if the file_data is some
     /// then should save the data to file
-    pub async fn append_item(&mut self, mut item: PrfItem) -> Result<()> {
-        if item.uid.is_none() {
+    pub async fn append_item(&mut self, item: &mut PrfItem) -> Result<()> {
+        let uid = &item.uid;
+        if uid.is_none() {
             bail!("the uid should not be null");
         }
-        let uid = item.uid.clone();
 
         // save the file data
         // move the field value after save
@@ -165,7 +166,7 @@ impl IProfiles {
         if self.current.is_none()
             && (item.itype == Some("remote".into()) || item.itype == Some("local".into()))
         {
-            self.current = uid;
+            self.current = uid.to_owned();
         }
 
         if self.items.is_none() {
@@ -173,24 +174,23 @@ impl IProfiles {
         }
 
         if let Some(items) = self.items.as_mut() {
-            items.push(item)
+            items.push(item.to_owned());
         }
 
-        // self.save_file().await
         Ok(())
     }
 
     /// reorder items
-    pub async fn reorder(&mut self, active_id: String, over_id: String) -> Result<()> {
+    pub async fn reorder(&mut self, active_id: &String, over_id: &String) -> Result<()> {
         let mut items = self.items.take().unwrap_or_default();
         let mut old_index = None;
         let mut new_index = None;
 
         for (i, _) in items.iter().enumerate() {
-            if items[i].uid == Some(active_id.clone()) {
+            if items[i].uid.as_ref() == Some(active_id) {
                 old_index = Some(i);
             }
-            if items[i].uid == Some(over_id.clone()) {
+            if items[i].uid.as_ref() == Some(over_id) {
                 new_index = Some(i);
             }
         }
@@ -206,11 +206,11 @@ impl IProfiles {
     }
 
     /// update the item value
-    pub async fn patch_item(&mut self, uid: String, item: PrfItem) -> Result<()> {
+    pub async fn patch_item(&mut self, uid: &String, item: &PrfItem) -> Result<()> {
         let mut items = self.items.take().unwrap_or_default();
 
         for each in items.iter_mut() {
-            if each.uid == Some(uid.clone()) {
+            if each.uid.as_ref() == Some(uid) {
                 patch!(each, item, itype);
                 patch!(each, item, name);
                 patch!(each, item, desc);
@@ -232,13 +232,13 @@ impl IProfiles {
 
     /// be used to update the remote item
     /// only patch `updated` `extra` `file_data`
-    pub async fn update_item(&mut self, uid: String, mut item: PrfItem) -> Result<()> {
+    pub async fn update_item(&mut self, uid: &String, item: &mut PrfItem) -> Result<()> {
         if self.items.is_none() {
             self.items = Some(vec![]);
         }
 
         // find the item
-        let _ = self.get_item(&uid)?;
+        let _ = self.get_item(uid)?;
 
         if let Some(items) = self.items.as_mut() {
             let some_uid = Some(uid.clone());
@@ -247,8 +247,8 @@ impl IProfiles {
                 if each.uid == some_uid {
                     each.extra = item.extra;
                     each.updated = item.updated;
-                    each.home = item.home;
-                    each.option = PrfOption::merge(each.option.clone(), item.option);
+                    each.home = item.home.to_owned();
+                    each.option = PrfOption::merge(each.option.as_ref(), item.option.as_ref());
                     // save the file data
                     // move the field value after save
                     if let Some(file_data) = item.file_data.take() {
@@ -279,10 +279,10 @@ impl IProfiles {
 
     /// delete item
     /// if delete the current then return true
-    pub async fn delete_item(&mut self, uid: String) -> Result<bool> {
-        let current = self.current.as_ref().unwrap_or(&uid);
+    pub async fn delete_item(&mut self, uid: &String) -> Result<bool> {
+        let current = self.current.as_ref().unwrap_or(uid);
         let current = current.clone();
-        let item = self.get_item(&uid)?;
+        let item = self.get_item(uid)?;
         let merge_uid = item.option.as_ref().and_then(|e| e.merge.clone());
         let script_uid = item.option.as_ref().and_then(|e| e.script.clone());
         let rules_uid = item.option.as_ref().and_then(|e| e.rules.clone());
@@ -330,7 +330,7 @@ impl IProfiles {
                 .await;
         }
         // delete the original uid
-        if current == uid {
+        if current == *uid {
             self.current = None;
             for item in items.iter() {
                 if item.itype == Some("remote".into()) || item.itype == Some("local".into()) {
@@ -342,7 +342,7 @@ impl IProfiles {
 
         self.items = Some(items);
         self.save_file().await?;
-        Ok(current == uid)
+        Ok(current == *uid)
     }
 
     /// 获取current指向的订阅内容
@@ -362,88 +362,18 @@ impl IProfiles {
         }
     }
 
-    /// 获取current指向的订阅的merge
-    pub fn current_merge(&self) -> Option<String> {
-        match (self.current.as_ref(), self.items.as_ref()) {
-            (Some(current), Some(items)) => {
-                if let Some(item) = items.iter().find(|e| e.uid.as_ref() == Some(current)) {
-                    let merge = item.option.as_ref().and_then(|e| e.merge.clone());
-                    return merge;
-                }
-                None
-            }
-            _ => None,
-        }
-    }
-
-    /// 获取current指向的订阅的script
-    pub fn current_script(&self) -> Option<String> {
-        match (self.current.as_ref(), self.items.as_ref()) {
-            (Some(current), Some(items)) => {
-                if let Some(item) = items.iter().find(|e| e.uid.as_ref() == Some(current)) {
-                    let script = item.option.as_ref().and_then(|e| e.script.clone());
-                    return script;
-                }
-                None
-            }
-            _ => None,
-        }
-    }
-
-    /// 获取current指向的订阅的rules
-    pub fn current_rules(&self) -> Option<String> {
-        match (self.current.as_ref(), self.items.as_ref()) {
-            (Some(current), Some(items)) => {
-                if let Some(item) = items.iter().find(|e| e.uid.as_ref() == Some(current)) {
-                    let rules = item.option.as_ref().and_then(|e| e.rules.clone());
-                    return rules;
-                }
-                None
-            }
-            _ => None,
-        }
-    }
-
-    /// 获取current指向的订阅的proxies
-    pub fn current_proxies(&self) -> Option<String> {
-        match (self.current.as_ref(), self.items.as_ref()) {
-            (Some(current), Some(items)) => {
-                if let Some(item) = items.iter().find(|e| e.uid.as_ref() == Some(current)) {
-                    let proxies = item.option.as_ref().and_then(|e| e.proxies.clone());
-                    return proxies;
-                }
-                None
-            }
-            _ => None,
-        }
-    }
-
-    /// 获取current指向的订阅的groups
-    pub fn current_groups(&self) -> Option<String> {
-        match (self.current.as_ref(), self.items.as_ref()) {
-            (Some(current), Some(items)) => {
-                if let Some(item) = items.iter().find(|e| e.uid.as_ref() == Some(current)) {
-                    let groups = item.option.as_ref().and_then(|e| e.groups.clone());
-                    return groups;
-                }
-                None
-            }
-            _ => None,
-        }
-    }
-
     /// 判断profile是否是current指向的
-    pub fn is_current_profile_index(&self, index: String) -> bool {
-        self.current == Some(index)
+    pub fn is_current_profile_index(&self, index: &String) -> bool {
+        self.current.as_ref() == Some(index)
     }
 
     /// 获取所有的profiles(uid，名称)
-    pub fn all_profile_uid_and_name(&self) -> Option<Vec<(String, String)>> {
+    pub fn all_profile_uid_and_name(&self) -> Option<Vec<(&String, &String)>> {
         self.items.as_ref().map(|items| {
             items
                 .iter()
                 .filter_map(|e| {
-                    if let (Some(uid), Some(name)) = (e.uid.clone(), e.name.clone()) {
+                    if let (Some(uid), Some(name)) = (e.uid.as_ref(), e.name.as_ref()) {
                         Some((uid, name))
                     } else {
                         None
@@ -453,6 +383,18 @@ impl IProfiles {
         })
     }
 
+    /// 通过 uid 获取名称
+    pub fn get_name_by_uid(&self, uid: &String) -> Option<&String> {
+        if let Some(items) = &self.items {
+            for item in items {
+                if item.uid.as_ref() == Some(uid) {
+                    return item.name.as_ref();
+                }
+            }
+        }
+        None
+    }
+
     /// 以 app 中的 profile 列表为准，删除不再需要的文件
     pub async fn cleanup_orphaned_files(&self) -> Result<CleanupResult> {
         let profiles_dir = dirs::app_profiles_dir()?;
@@ -491,7 +433,7 @@ impl IProfiles {
             {
                 // 检查是否为全局扩展文件
                 if protected_files.contains(file_name) {
-                    log::debug!(target: "app", "保护全局扩展配置文件: {file_name}");
+                    logging!(debug, Type::Config, "保护全局扩展配置文件: {file_name}");
                     continue;
                 }
 
@@ -500,11 +442,15 @@ impl IProfiles {
                     match path.to_path_buf().remove_if_exists().await {
                         Ok(_) => {
                             deleted_files.push(file_name.into());
-                            log::info!(target: "app", "已清理冗余文件: {file_name}");
+                            logging!(info, Type::Config, "已清理冗余文件: {file_name}");
                         }
                         Err(e) => {
                             failed_deletions.push(format!("{file_name}: {e}").into());
-                            log::warn!(target: "app", "清理文件失败: {file_name} - {e}");
+                            logging!(
+                                warn,
+                                Type::Config,
+                                "Warning: 清理文件失败: {file_name} - {e}"
+                            );
                         }
                     }
                 }
@@ -517,8 +463,9 @@ impl IProfiles {
             failed_deletions,
         };
 
-        log::info!(
-            target: "app",
+        logging!(
+            info,
+            Type::Config,
             "Profile 文件清理完成: 总文件数={}, 删除文件数={}, 失败数={}",
             result.total_files,
             result.deleted_files.len(),
@@ -539,14 +486,14 @@ impl IProfiles {
     }
 
     /// 获取所有 active profile 关联的文件名
-    fn get_all_active_files(&self) -> HashSet<String> {
-        let mut active_files = HashSet::new();
+    fn get_all_active_files(&self) -> HashSet<&str> {
+        let mut active_files: HashSet<&str> = HashSet::new();
 
         if let Some(items) = &self.items {
             for item in items {
                 // 收集所有类型 profile 的文件
                 if let Some(file) = &item.file {
-                    active_files.insert(file.clone());
+                    active_files.insert(file);
                 }
 
                 // 对于主 profile 类型（remote/local），还需要收集其关联的扩展文件
@@ -559,35 +506,35 @@ impl IProfiles {
                         && let Ok(merge_item) = self.get_item(merge_uid)
                         && let Some(file) = &merge_item.file
                     {
-                        active_files.insert(file.clone());
+                        active_files.insert(file);
                     }
 
                     if let Some(script_uid) = &option.script
                         && let Ok(script_item) = self.get_item(script_uid)
                         && let Some(file) = &script_item.file
                     {
-                        active_files.insert(file.clone());
+                        active_files.insert(file);
                     }
 
                     if let Some(rules_uid) = &option.rules
                         && let Ok(rules_item) = self.get_item(rules_uid)
                         && let Some(file) = &rules_item.file
                     {
-                        active_files.insert(file.clone());
+                        active_files.insert(file);
                     }
 
                     if let Some(proxies_uid) = &option.proxies
                         && let Ok(proxies_item) = self.get_item(proxies_uid)
                         && let Some(file) = &proxies_item.file
                     {
-                        active_files.insert(file.clone());
+                        active_files.insert(file);
                     }
 
                     if let Some(groups_uid) = &option.groups
                         && let Ok(groups_item) = self.get_item(groups_uid)
                         && let Some(file) = &groups_item.file
                     {
-                        active_files.insert(file.clone());
+                        active_files.insert(file);
                     }
                 }
             }
@@ -626,14 +573,14 @@ impl IProfiles {
 use crate::config::Config;
 
 pub async fn profiles_append_item_with_filedata_safe(
-    item: PrfItem,
+    item: &PrfItem,
     file_data: Option<String>,
 ) -> Result<()> {
-    let item = PrfItem::from(item, file_data).await?;
+    let item = &mut PrfItem::from(item, file_data).await?;
     profiles_append_item_safe(item).await
 }
 
-pub async fn profiles_append_item_safe(item: PrfItem) -> Result<()> {
+pub async fn profiles_append_item_safe(item: &mut PrfItem) -> Result<()> {
     Config::profiles()
         .await
         .with_data_modify(|mut profiles| async move {
@@ -643,7 +590,7 @@ pub async fn profiles_append_item_safe(item: PrfItem) -> Result<()> {
         .await
 }
 
-pub async fn profiles_patch_item_safe(index: String, item: PrfItem) -> Result<()> {
+pub async fn profiles_patch_item_safe(index: &String, item: &PrfItem) -> Result<()> {
     Config::profiles()
         .await
         .with_data_modify(|mut profiles| async move {
@@ -653,7 +600,7 @@ pub async fn profiles_patch_item_safe(index: String, item: PrfItem) -> Result<()
         .await
 }
 
-pub async fn profiles_delete_item_safe(index: String) -> Result<bool> {
+pub async fn profiles_delete_item_safe(index: &String) -> Result<bool> {
     Config::profiles()
         .await
         .with_data_modify(|mut profiles| async move {
@@ -663,7 +610,7 @@ pub async fn profiles_delete_item_safe(index: String) -> Result<bool> {
         .await
 }
 
-pub async fn profiles_reorder_safe(active_id: String, over_id: String) -> Result<()> {
+pub async fn profiles_reorder_safe(active_id: &String, over_id: &String) -> Result<()> {
     Config::profiles()
         .await
         .with_data_modify(|mut profiles| async move {
@@ -683,7 +630,7 @@ pub async fn profiles_save_file_safe() -> Result<()> {
         .await
 }
 
-pub async fn profiles_draft_update_item_safe(index: String, item: PrfItem) -> Result<()> {
+pub async fn profiles_draft_update_item_safe(index: &String, item: &mut PrfItem) -> Result<()> {
     Config::profiles()
         .await
         .with_data_modify(|mut profiles| async move {

src-tauri/src/config/verge.rs

@@ -1,3 +1,4 @@
+use crate::config::Config;
 use crate::{
     config::{DEFAULT_PAC, deserialize_encrypted, serialize_encrypted},
     logging,
@@ -45,19 +46,24 @@ pub struct IVerge {
     pub enable_memory_usage: Option<bool>,
 
     /// enable group icon
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub enable_group_icon: Option<bool>,
 
     /// common tray icon
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub common_tray_icon: Option<bool>,
 
     /// tray icon
     #[cfg(target_os = "macos")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub tray_icon: Option<String>,
 
     /// menu icon
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub menu_icon: Option<String>,
 
     /// menu order
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub menu_order: Option<Vec<String>>,
 
     /// sysproxy tray icon
@@ -114,6 +120,7 @@ pub struct IVerge {
 
     /// hotkey map
     /// format: {func},{key}
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub hotkeys: Option<Vec<String>>,
 
     /// enable global hotkey
@@ -133,7 +140,7 @@ pub struct IVerge {
     pub default_latency_test: Option<String>,
 
     /// 默认的延迟测试超时时间
-    pub default_latency_timeout: Option<i32>,
+    pub default_latency_timeout: Option<i16>,
 
     /// 是否自动检测当前节点延迟
     pub enable_auto_delay_detection: Option<bool>,
@@ -142,7 +149,7 @@ pub struct IVerge {
     pub enable_builtin_enhanced: Option<bool>,
 
     /// proxy 页面布局 列数
-    pub proxy_layout_column: Option<i32>,
+    pub proxy_layout_column: Option<u8>,
 
     /// 测试站列表
     pub test_list: Option<Vec<IVergeTestItem>>,
@@ -201,6 +208,7 @@ pub struct IVerge {
     )]
     pub webdav_password: Option<String>,
 
+    #[serde(skip)]
     pub enable_tray_speed: Option<bool>,
 
     // pub enable_tray_icon: Option<bool>,
@@ -254,7 +262,7 @@ impl IVerge {
     /// 验证并修正配置文件中的clash_core值
     pub async fn validate_and_fix_config() -> Result<()> {
         let config_path = dirs::verge_path()?;
-        let mut config = match help::read_yaml::<IVerge>(&config_path).await {
+        let mut config = match help::read_yaml::<Self>(&config_path).await {
             Ok(config) => config,
             Err(_) => Self::template(),
         };
@@ -303,20 +311,20 @@ impl IVerge {
     }
 
     /// 配置修正后重新加载配置
-    async fn reload_config_after_fix(updated_config: IVerge) -> Result<()> {
-        use crate::config::Config;
-
-        let config_draft = Config::verge().await;
-        *config_draft.draft_mut() = Box::new(updated_config.clone());
-        config_draft.apply();
-
+    async fn reload_config_after_fix(updated_config: Self) -> Result<()> {
         logging!(
             info,
             Type::Config,
             "内存配置已强制更新，新的clash_core: {:?}",
-            updated_config.clash_core
+            &updated_config.clash_core
         );
 
+        let config_draft = Config::verge().await;
+        config_draft.edit_draft(|d| {
+            *d = updated_config;
+        });
+        config_draft.apply();
+
         Ok(())
     }
 
@@ -343,7 +351,7 @@ impl IVerge {
 
     pub async fn new() -> Self {
         match dirs::verge_path() {
-            Ok(path) => match help::read_yaml::<IVerge>(&path).await {
+            Ok(path) => match help::read_yaml::<Self>(&path).await {
                 Ok(mut config) => {
                     // compatibility
                     if let Some(start_page) = config.start_page.clone()
@@ -354,12 +362,12 @@ impl IVerge {
                     config
                 }
                 Err(err) => {
-                    log::error!(target: "app", "{err}");
+                    logging!(error, Type::Config, "{err}");
                     Self::template()
                 }
             },
             Err(err) => {
-                log::error!(target: "app", "{err}");
+                logging!(error, Type::Config, "{err}");
                 Self::template()
             }
         }
@@ -438,11 +446,11 @@ impl IVerge {
     /// patch verge config
     /// only save to file
     #[allow(clippy::cognitive_complexity)]
-    pub fn patch_config(&mut self, patch: IVerge) {
+    pub fn patch_config(&mut self, patch: &Self) {
         macro_rules! patch {
             ($key: tt) => {
                 if patch.$key.is_some() {
-                    self.$key = patch.$key;
+                    self.$key = patch.$key.clone();
                 }
             };
         }
@@ -523,7 +531,7 @@ impl IVerge {
         patch!(enable_external_controller);
     }
 
-    pub fn get_singleton_port() -> u16 {
+    pub const fn get_singleton_port() -> u16 {
         crate::constants::network::ports::SINGLETON_SERVER
     }
 
@@ -544,156 +552,3 @@ impl IVerge {
         }
     }
 }
-
-#[derive(Debug, Clone, Serialize)]
-pub struct IVergeResponse {
-    pub app_log_level: Option<String>,
-    pub app_log_max_size: Option<u64>,
-    pub app_log_max_count: Option<usize>,
-    pub language: Option<String>,
-    pub theme_mode: Option<String>,
-    pub tray_event: Option<String>,
-    pub env_type: Option<String>,
-    pub start_page: Option<String>,
-    pub startup_script: Option<String>,
-    pub traffic_graph: Option<bool>,
-    pub enable_memory_usage: Option<bool>,
-    pub enable_group_icon: Option<bool>,
-    pub common_tray_icon: Option<bool>,
-    #[cfg(target_os = "macos")]
-    pub tray_icon: Option<String>,
-    pub menu_icon: Option<String>,
-    pub menu_order: Option<Vec<String>>,
-    pub sysproxy_tray_icon: Option<bool>,
-    pub tun_tray_icon: Option<bool>,
-    pub enable_tun_mode: Option<bool>,
-    pub enable_auto_launch: Option<bool>,
-    pub enable_silent_start: Option<bool>,
-    pub enable_system_proxy: Option<bool>,
-    pub enable_proxy_guard: Option<bool>,
-    pub enable_global_hotkey: Option<bool>,
-    pub use_default_bypass: Option<bool>,
-    pub system_proxy_bypass: Option<String>,
-    pub proxy_guard_duration: Option<u64>,
-    pub proxy_auto_config: Option<bool>,
-    pub pac_file_content: Option<String>,
-    pub proxy_host: Option<String>,
-    pub theme_setting: Option<IVergeTheme>,
-    pub web_ui_list: Option<Vec<String>>,
-    pub clash_core: Option<String>,
-    pub hotkeys: Option<Vec<String>>,
-    pub auto_close_connection: Option<bool>,
-    pub auto_check_update: Option<bool>,
-    pub default_latency_test: Option<String>,
-    pub default_latency_timeout: Option<i32>,
-    pub enable_auto_delay_detection: Option<bool>,
-    pub enable_builtin_enhanced: Option<bool>,
-    pub proxy_layout_column: Option<i32>,
-    pub test_list: Option<Vec<IVergeTestItem>>,
-    pub auto_log_clean: Option<i32>,
-    #[cfg(not(target_os = "windows"))]
-    pub verge_redir_port: Option<u16>,
-    #[cfg(not(target_os = "windows"))]
-    pub verge_redir_enabled: Option<bool>,
-    #[cfg(target_os = "linux")]
-    pub verge_tproxy_port: Option<u16>,
-    #[cfg(target_os = "linux")]
-    pub verge_tproxy_enabled: Option<bool>,
-    pub verge_mixed_port: Option<u16>,
-    pub verge_socks_port: Option<u16>,
-    pub verge_socks_enabled: Option<bool>,
-    pub verge_port: Option<u16>,
-    pub verge_http_enabled: Option<bool>,
-    pub webdav_url: Option<String>,
-    pub webdav_username: Option<String>,
-    pub webdav_password: Option<String>,
-    pub enable_tray_speed: Option<bool>,
-    // pub enable_tray_icon: Option<bool>,
-    pub tray_inline_proxy_groups: 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 enable_hover_jump_navigator: Option<bool>,
-    pub hover_jump_navigator_delay: Option<u64>,
-    pub enable_external_controller: Option<bool>,
-}
-
-impl From<IVerge> for IVergeResponse {
-    fn from(verge: IVerge) -> Self {
-        // 先获取验证后的clash_core值，避免后续借用冲突
-        let valid_clash_core = verge.get_valid_clash_core();
-        Self {
-            app_log_level: verge.app_log_level,
-            app_log_max_size: verge.app_log_max_size,
-            app_log_max_count: verge.app_log_max_count,
-            language: verge.language,
-            theme_mode: verge.theme_mode,
-            tray_event: verge.tray_event,
-            env_type: verge.env_type,
-            start_page: verge.start_page,
-            startup_script: verge.startup_script,
-            traffic_graph: verge.traffic_graph,
-            enable_memory_usage: verge.enable_memory_usage,
-            enable_group_icon: verge.enable_group_icon,
-            common_tray_icon: verge.common_tray_icon,
-            #[cfg(target_os = "macos")]
-            tray_icon: verge.tray_icon,
-            menu_icon: verge.menu_icon,
-            menu_order: verge.menu_order,
-            sysproxy_tray_icon: verge.sysproxy_tray_icon,
-            tun_tray_icon: verge.tun_tray_icon,
-            enable_tun_mode: verge.enable_tun_mode,
-            enable_auto_launch: verge.enable_auto_launch,
-            enable_silent_start: verge.enable_silent_start,
-            enable_system_proxy: verge.enable_system_proxy,
-            enable_proxy_guard: verge.enable_proxy_guard,
-            enable_global_hotkey: verge.enable_global_hotkey,
-            use_default_bypass: verge.use_default_bypass,
-            system_proxy_bypass: verge.system_proxy_bypass,
-            proxy_guard_duration: verge.proxy_guard_duration,
-            proxy_auto_config: verge.proxy_auto_config,
-            pac_file_content: verge.pac_file_content,
-            proxy_host: verge.proxy_host,
-            theme_setting: verge.theme_setting,
-            web_ui_list: verge.web_ui_list,
-            clash_core: Some(valid_clash_core),
-            hotkeys: verge.hotkeys,
-            auto_close_connection: verge.auto_close_connection,
-            auto_check_update: verge.auto_check_update,
-            default_latency_test: verge.default_latency_test,
-            default_latency_timeout: verge.default_latency_timeout,
-            enable_auto_delay_detection: verge.enable_auto_delay_detection,
-            enable_builtin_enhanced: verge.enable_builtin_enhanced,
-            proxy_layout_column: verge.proxy_layout_column,
-            test_list: verge.test_list,
-            auto_log_clean: verge.auto_log_clean,
-            #[cfg(not(target_os = "windows"))]
-            verge_redir_port: verge.verge_redir_port,
-            #[cfg(not(target_os = "windows"))]
-            verge_redir_enabled: verge.verge_redir_enabled,
-            #[cfg(target_os = "linux")]
-            verge_tproxy_port: verge.verge_tproxy_port,
-            #[cfg(target_os = "linux")]
-            verge_tproxy_enabled: verge.verge_tproxy_enabled,
-            verge_mixed_port: verge.verge_mixed_port,
-            verge_socks_port: verge.verge_socks_port,
-            verge_socks_enabled: verge.verge_socks_enabled,
-            verge_port: verge.verge_port,
-            verge_http_enabled: verge.verge_http_enabled,
-            webdav_url: verge.webdav_url,
-            webdav_username: verge.webdav_username,
-            webdav_password: verge.webdav_password,
-            enable_tray_speed: verge.enable_tray_speed,
-            // enable_tray_icon: verge.enable_tray_icon,
-            tray_inline_proxy_groups: verge.tray_inline_proxy_groups,
-            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,
-            enable_hover_jump_navigator: verge.enable_hover_jump_navigator,
-            hover_jump_navigator_delay: verge.hover_jump_navigator_delay,
-            enable_external_controller: verge.enable_external_controller,
-        }
-    }
-}

src-tauri/src/constants.rs

@@ -5,15 +5,13 @@ pub mod network {
     pub const DEFAULT_EXTERNAL_CONTROLLER: &str = "127.0.0.1:9097";
 
     pub mod ports {
-        #[allow(dead_code)]
+        #[cfg(not(target_os = "windows"))]
         pub const DEFAULT_REDIR: u16 = 7895;
-        #[allow(dead_code)]
+        #[cfg(target_os = "linux")]
         pub const DEFAULT_TPROXY: u16 = 7896;
         pub const DEFAULT_MIXED: u16 = 7897;
         pub const DEFAULT_SOCKS: u16 = 7898;
         pub const DEFAULT_HTTP: u16 = 7899;
-        #[allow(dead_code)]
-        pub const DEFAULT_EXTERNAL_CONTROLLER: u16 = 9097;
 
         #[cfg(not(feature = "verge-dev"))]
         pub const SINGLETON_SERVER: u16 = 33331;
@@ -39,11 +37,8 @@ pub mod timing {
 
     pub const CONFIG_UPDATE_DEBOUNCE: Duration = Duration::from_millis(500);
     pub const CONFIG_RELOAD_DELAY: Duration = Duration::from_millis(300);
-    pub const PROCESS_VERIFY_DELAY: Duration = Duration::from_millis(100);
-    #[allow(dead_code)]
     pub const EVENT_EMIT_DELAY: Duration = Duration::from_millis(20);
     pub const STARTUP_ERROR_DELAY: Duration = Duration::from_secs(2);
-    #[allow(dead_code)]
     pub const ERROR_BATCH_DELAY: Duration = Duration::from_millis(300);
 
     #[cfg(target_os = "windows")]
@@ -53,40 +48,16 @@ pub mod timing {
 }
 
 pub mod retry {
-    #[allow(dead_code)]
     pub const EVENT_EMIT_THRESHOLD: u64 = 10;
-    #[allow(dead_code)]
-    pub const SWR_ERROR_RETRY: usize = 2;
 }
 
 pub mod files {
     pub const RUNTIME_CONFIG: &str = "clash-verge.yaml";
     pub const CHECK_CONFIG: &str = "clash-verge-check.yaml";
-    #[allow(dead_code)]
     pub const DNS_CONFIG: &str = "dns_config.yaml";
-    #[allow(dead_code)]
     pub const WINDOW_STATE: &str = "window_state.json";
 }
 
-pub mod process {
-    pub const VERGE_MIHOMO: &str = "verge-mihomo";
-    pub const VERGE_MIHOMO_ALPHA: &str = "verge-mihomo-alpha";
-
-    pub fn process_names() -> [&'static str; 2] {
-        [VERGE_MIHOMO, VERGE_MIHOMO_ALPHA]
-    }
-
-    #[cfg(windows)]
-    pub fn with_extension(name: &str) -> String {
-        format!("{}.exe", name)
-    }
-
-    #[cfg(not(windows))]
-    pub fn with_extension(name: &str) -> String {
-        name.to_string()
-    }
-}
-
 pub mod error_patterns {
     pub const CONNECTION_ERRORS: &[&str] = &[
         "Failed to create connection",

src-tauri/src/core/async_proxy_query.rs

@@ -1,5 +1,6 @@
 #[cfg(target_os = "windows")]
 use crate::process::AsyncHandler;
+use crate::{logging, utils::logging::Type};
 use anyhow::Result;
 use serde::{Deserialize, Serialize};
 use tokio::time::{Duration, timeout};
@@ -41,15 +42,21 @@ impl AsyncProxyQuery {
     pub async fn get_auto_proxy() -> AsyncAutoproxy {
         match timeout(Duration::from_secs(3), Self::get_auto_proxy_impl()).await {
             Ok(Ok(proxy)) => {
-                log::debug!(target: "app", "异步获取自动代理成功: enable={}, url={}", proxy.enable, proxy.url);
+                logging!(
+                    debug,
+                    Type::Network,
+                    "异步获取自动代理成功: enable={}, url={}",
+                    proxy.enable,
+                    proxy.url
+                );
                 proxy
             }
             Ok(Err(e)) => {
-                log::warn!(target: "app", "异步获取自动代理失败: {e}");
+                logging!(warn, Type::Network, "Warning: 异步获取自动代理失败: {e}");
                 AsyncAutoproxy::default()
             }
             Err(_) => {
-                log::warn!(target: "app", "异步获取自动代理超时");
+                logging!(warn, Type::Network, "Warning: 异步获取自动代理超时");
                 AsyncAutoproxy::default()
             }
         }
@@ -59,15 +66,22 @@ impl AsyncProxyQuery {
     pub async fn get_system_proxy() -> AsyncSysproxy {
         match timeout(Duration::from_secs(3), Self::get_system_proxy_impl()).await {
             Ok(Ok(proxy)) => {
-                log::debug!(target: "app", "异步获取系统代理成功: enable={}, {}:{}", proxy.enable, proxy.host, proxy.port);
+                logging!(
+                    debug,
+                    Type::Network,
+                    "异步获取系统代理成功: enable={}, {}:{}",
+                    proxy.enable,
+                    proxy.host,
+                    proxy.port
+                );
                 proxy
             }
             Ok(Err(e)) => {
-                log::warn!(target: "app", "异步获取系统代理失败: {e}");
+                logging!(warn, Type::Network, "Warning: 异步获取系统代理失败: {e}");
                 AsyncSysproxy::default()
             }
             Err(_) => {
-                log::warn!(target: "app", "异步获取系统代理超时");
+                logging!(warn, Type::Network, "Warning: 异步获取系统代理超时");
                 AsyncSysproxy::default()
             }
         }
@@ -99,7 +113,7 @@ impl AsyncProxyQuery {
                 RegOpenKeyExW(HKEY_CURRENT_USER, key_path.as_ptr(), 0, KEY_READ, &mut hkey);
 
             if result != 0 {
-                log::debug!(target: "app", "无法打开注册表项");
+                logging!(debug, Type::Network, "无法打开注册表项");
                 return Ok(AsyncAutoproxy::default());
             }
 
@@ -125,7 +139,7 @@ impl AsyncProxyQuery {
                     .position(|&x| x == 0)
                     .unwrap_or(url_buffer.len());
                 pac_url = String::from_utf16_lossy(&url_buffer[..end_pos]);
-                log::debug!(target: "app", "从注册表读取到PAC URL: {pac_url}");
+                logging!(debug, Type::Network, "从注册表读取到PAC URL: {pac_url}");
             }
 
             // 2. 检查自动检测设置是否启用
@@ -150,7 +164,11 @@ impl AsyncProxyQuery {
                 || (detect_query_result == 0 && detect_value_type == REG_DWORD && auto_detect != 0);
 
             if pac_enabled {
-                log::debug!(target: "app", "PAC配置启用: URL={pac_url}, AutoDetect={auto_detect}");
+                logging!(
+                    debug,
+                    Type::Network,
+                    "PAC配置启用: URL={pac_url}, AutoDetect={auto_detect}"
+                );
 
                 if pac_url.is_empty() && auto_detect != 0 {
                     pac_url = "auto-detect".into();
@@ -161,7 +179,7 @@ impl AsyncProxyQuery {
                     url: pac_url,
                 })
             } else {
-                log::debug!(target: "app", "PAC配置未启用");
+                logging!(debug, Type::Network, "PAC配置未启用");
                 Ok(AsyncAutoproxy::default())
             }
         }
@@ -177,7 +195,11 @@ impl AsyncProxyQuery {
         }
 
         let stdout = String::from_utf8_lossy(&output.stdout);
-        log::debug!(target: "app", "scutil output: {stdout}");
+        crate::logging!(
+            debug,
+            crate::utils::logging::Type::Network,
+            "scutil output: {stdout}"
+        );
 
         let mut pac_enabled = false;
         let mut pac_url = String::new();
@@ -196,7 +218,11 @@ impl AsyncProxyQuery {
             }
         }
 
-        log::debug!(target: "app", "解析结果: pac_enabled={pac_enabled}, pac_url={pac_url}");
+        crate::logging!(
+            debug,
+            crate::utils::logging::Type::Network,
+            "解析结果: pac_enabled={pac_enabled}, pac_url={pac_url}"
+        );
 
         Ok(AsyncAutoproxy {
             enable: pac_enabled && !pac_url.is_empty(),
@@ -321,11 +347,12 @@ impl AsyncProxyQuery {
                 &mut buffer_size,
             );
 
-            let mut proxy_server = String::new();
-            if server_result == 0 && value_type == REG_SZ && buffer_size > 0 {
+            let proxy_server = if server_result == 0 && value_type == REG_SZ && buffer_size > 0 {
                 let end_pos = buffer.iter().position(|&x| x == 0).unwrap_or(buffer.len());
-                proxy_server = String::from_utf16_lossy(&buffer[..end_pos]);
-            }
+                String::from_utf16_lossy(&buffer[..end_pos])
+            } else {
+                String::new()
+            };
 
             // 读取代理绕过列表
             let proxy_override_name = "ProxyOverride\0".encode_utf16().collect::<Vec<u16>>();
@@ -342,14 +369,16 @@ impl AsyncProxyQuery {
                 &mut bypass_buffer_size,
             );
 
-            let mut bypass_list = String::new();
-            if override_result == 0 && bypass_value_type == REG_SZ && bypass_buffer_size > 0 {
-                let end_pos = bypass_buffer
-                    .iter()
-                    .position(|&x| x == 0)
-                    .unwrap_or(bypass_buffer.len());
-                bypass_list = String::from_utf16_lossy(&bypass_buffer[..end_pos]);
-            }
+            let bypass_list =
+                if override_result == 0 && bypass_value_type == REG_SZ && bypass_buffer_size > 0 {
+                    let end_pos = bypass_buffer
+                        .iter()
+                        .position(|&x| x == 0)
+                        .unwrap_or(bypass_buffer.len());
+                    String::from_utf16_lossy(&bypass_buffer[..end_pos])
+                } else {
+                    String::new()
+                };
 
             RegCloseKey(hkey);
 
@@ -363,7 +392,11 @@ impl AsyncProxyQuery {
                     (proxy_server, 8080)
                 };
 
-                log::debug!(target: "app", "从注册表读取到代理设置: {host}:{port}, bypass: {bypass_list}");
+                logging!(
+                    debug,
+                    Type::Network,
+                    "从注册表读取到代理设置: {host}:{port}, bypass: {bypass_list}"
+                );
 
                 Ok(AsyncSysproxy {
                     enable: true,
@@ -386,7 +419,7 @@ impl AsyncProxyQuery {
         }
 
         let stdout = String::from_utf8_lossy(&output.stdout);
-        log::debug!(target: "app", "scutil proxy output: {stdout}");
+        logging!(debug, Type::Network, "scutil proxy output: {stdout}");
 
         let mut http_enabled = false;
         let mut http_host = String::new();

src-tauri/src/core/backup.rs

@@ -1,19 +1,24 @@
-use crate::{config::Config, utils::dirs};
+use crate::constants::files::DNS_CONFIG;
+use crate::{
+    config::Config,
+    logging,
+    process::AsyncHandler,
+    utils::{dirs, logging::Type},
+};
 use anyhow::Error;
+use arc_swap::{ArcSwap, ArcSwapOption};
 use once_cell::sync::OnceCell;
-use parking_lot::Mutex;
 use reqwest_dav::list_cmd::{ListEntity, ListFile};
 use smartstring::alias::String;
 use std::{
     collections::HashMap,
     env::{consts::OS, temp_dir},
-    fs,
     io::Write,
     path::PathBuf,
     sync::Arc,
     time::Duration,
 };
-use tokio::time::timeout;
+use tokio::{fs, time::timeout};
 use zip::write::SimpleFileOptions;
 
 // 应用版本常量，来自 tauri.conf.json
@@ -40,35 +45,35 @@ enum Operation {
 }
 
 impl Operation {
-    fn timeout(&self) -> u64 {
+    const fn timeout(&self) -> u64 {
         match self {
-            Operation::Upload => TIMEOUT_UPLOAD,
-            Operation::Download => TIMEOUT_DOWNLOAD,
-            Operation::List => TIMEOUT_LIST,
-            Operation::Delete => TIMEOUT_DELETE,
+            Self::Upload => TIMEOUT_UPLOAD,
+            Self::Download => TIMEOUT_DOWNLOAD,
+            Self::List => TIMEOUT_LIST,
+            Self::Delete => TIMEOUT_DELETE,
         }
     }
 }
 
 pub struct WebDavClient {
-    config: Arc<Mutex<Option<WebDavConfig>>>,
-    clients: Arc<Mutex<HashMap<Operation, reqwest_dav::Client>>>,
+    config: Arc<ArcSwapOption<WebDavConfig>>,
+    clients: Arc<ArcSwap<HashMap<Operation, reqwest_dav::Client>>>,
 }
 
 impl WebDavClient {
-    pub fn global() -> &'static WebDavClient {
+    pub fn global() -> &'static Self {
         static WEBDAV_CLIENT: OnceCell<WebDavClient> = OnceCell::new();
-        WEBDAV_CLIENT.get_or_init(|| WebDavClient {
-            config: Arc::new(Mutex::new(None)),
-            clients: Arc::new(Mutex::new(HashMap::new())),
+        WEBDAV_CLIENT.get_or_init(|| Self {
+            config: Arc::new(ArcSwapOption::new(None)),
+            clients: Arc::new(ArcSwap::new(Arc::new(HashMap::new()))),
         })
     }
 
     async fn get_client(&self, op: Operation) -> Result<reqwest_dav::Client, Error> {
         // 先尝试从缓存获取
         {
-            let clients = self.clients.lock();
-            if let Some(client) = clients.get(&op) {
+            let clients_map = self.clients.load();
+            if let Some(client) = clients_map.get(&op) {
                 return Ok(client.clone());
             }
         }
@@ -76,13 +81,13 @@ impl WebDavClient {
         // 获取或创建配置
         let config = {
             // 首先检查是否已有配置
-            let existing_config = self.config.lock().as_ref().cloned();
+            let existing_config = self.config.load();
 
-            if let Some(cfg) = existing_config {
-                cfg
+            if let Some(cfg_arc) = existing_config.clone() {
+                (*cfg_arc).clone()
             } else {
                 // 释放锁后获取异步配置
-                let verge = Config::verge().await.latest_ref().clone();
+                let verge = Config::verge().await.data_arc();
                 if verge.webdav_url.is_none()
                     || verge.webdav_username.is_none()
                     || verge.webdav_password.is_none()
@@ -94,15 +99,17 @@ impl WebDavClient {
                 let config = WebDavConfig {
                     url: verge
                         .webdav_url
+                        .as_ref()
+                        .cloned()
                         .unwrap_or_default()
                         .trim_end_matches('/')
                         .into(),
-                    username: verge.webdav_username.unwrap_or_default(),
-                    password: verge.webdav_password.unwrap_or_default(),
+                    username: verge.webdav_username.as_ref().cloned().unwrap_or_default(),
+                    password: verge.webdav_password.as_ref().cloned().unwrap_or_default(),
                 };
 
-                // 重新获取锁并存储配置
-                *self.config.lock() = Some(config.clone());
+                // 存储配置到 ArcSwapOption
+                self.config.store(Some(Arc::new(config.clone())));
                 config
             }
         };
@@ -138,9 +145,14 @@ impl WebDavClient {
             .is_err()
         {
             match client.mkcol(dirs::BACKUP_DIR).await {
-                Ok(_) => log::info!("Successfully created backup directory"),
+                Ok(_) => logging!(info, Type::Backup, "Successfully created backup directory"),
                 Err(e) => {
-                    log::warn!("Failed to create backup directory: {}", e);
+                    logging!(
+                        warn,
+                        Type::Backup,
+                        "Warning: Failed to create backup directory: {}",
+                        e
+                    );
                     // 清除缓存，强制下次重新尝试
                     self.reset();
                     return Err(anyhow::Error::msg(format!(
@@ -151,18 +163,19 @@ impl WebDavClient {
             }
         }
 
-        // 缓存客户端
+        // 缓存客户端（替换 Arc<Mutex<HashMap<...>>> 的写法）
         {
-            let mut clients = self.clients.lock();
-            clients.insert(op, client.clone());
+            let mut map = (**self.clients.load()).clone();
+            map.insert(op, client.clone());
+            self.clients.store(map.into());
         }
 
         Ok(client)
     }
 
     pub fn reset(&self) {
-        *self.config.lock() = None;
-        self.clients.lock().clear();
+        self.config.store(None);
+        self.clients.store(Arc::new(HashMap::new()));
     }
 
     pub async fn upload(&self, file_path: PathBuf, file_name: String) -> Result<(), Error> {
@@ -170,7 +183,7 @@ impl WebDavClient {
         let webdav_path: String = format!("{}/{}", dirs::BACKUP_DIR, file_name).into();
 
         // 读取文件并上传，如果失败尝试一次重试
-        let file_content = fs::read(&file_path)?;
+        let file_content = fs::read(&file_path).await?;
 
         // 添加超时保护
         let upload_result = timeout(
@@ -181,7 +194,11 @@ impl WebDavClient {
 
         match upload_result {
             Err(_) => {
-                log::warn!("Upload timed out, retrying once");
+                logging!(
+                    warn,
+                    Type::Backup,
+                    "Warning: Upload timed out, retrying once"
+                );
                 tokio::time::sleep(Duration::from_millis(500)).await;
                 timeout(
                     Duration::from_secs(TIMEOUT_UPLOAD),
@@ -192,7 +209,11 @@ impl WebDavClient {
             }
 
             Ok(Err(e)) => {
-                log::warn!("Upload failed, retrying once: {e}");
+                logging!(
+                    warn,
+                    Type::Backup,
+                    "Warning: Upload failed, retrying once: {e}"
+                );
                 tokio::time::sleep(Duration::from_millis(500)).await;
                 timeout(
                     Duration::from_secs(TIMEOUT_UPLOAD),
@@ -212,7 +233,7 @@ impl WebDavClient {
         let fut = async {
             let response = client.get(path.as_str()).await?;
             let content = response.bytes().await?;
-            fs::write(&storage_path, &content)?;
+            fs::write(&storage_path, &content).await?;
             Ok::<(), Error>(())
         };
 
@@ -250,18 +271,19 @@ impl WebDavClient {
     }
 }
 
-pub fn create_backup() -> Result<(String, PathBuf), Error> {
+pub async fn create_backup() -> Result<(String, PathBuf), Error> {
     let now = chrono::Local::now().format("%Y-%m-%d_%H-%M-%S").to_string();
     let zip_file_name: String = format!("{OS}-backup-{now}.zip").into();
     let zip_path = temp_dir().join(zip_file_name.as_str());
 
-    let file = fs::File::create(&zip_path)?;
+    let value = zip_path.clone();
+    let file = AsyncHandler::spawn_blocking(move || std::fs::File::create(&value)).await??;
     let mut zip = zip::ZipWriter::new(file);
     zip.add_directory("profiles/", SimpleFileOptions::default())?;
     let options = SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored);
-    if let Ok(entries) = fs::read_dir(dirs::app_profiles_dir()?) {
-        for entry in entries {
-            let entry = entry?;
+
+    if let Ok(mut entries) = fs::read_dir(dirs::app_profiles_dir()?).await {
+        while let Some(entry) = entries.next_entry().await? {
             let path = entry.path();
             if path.is_file() {
                 let file_name_os = entry.file_name();
@@ -270,16 +292,16 @@ pub fn create_backup() -> Result<(String, PathBuf), Error> {
                     .ok_or_else(|| anyhow::Error::msg("Invalid file name encoding"))?;
                 let backup_path = format!("profiles/{}", file_name);
                 zip.start_file(backup_path, options)?;
-                let file_content = fs::read(&path)?;
+                let file_content = fs::read(&path).await?;
                 zip.write_all(&file_content)?;
             }
         }
     }
     zip.start_file(dirs::CLASH_CONFIG, options)?;
-    zip.write_all(fs::read(dirs::clash_path()?)?.as_slice())?;
+    zip.write_all(fs::read(dirs::clash_path()?).await?.as_slice())?;
 
-    let mut verge_config: serde_json::Value =
-        serde_yaml_ng::from_str(&fs::read_to_string(dirs::verge_path()?)?)?;
+    let verge_text = fs::read_to_string(dirs::verge_path()?).await?;
+    let mut verge_config: serde_json::Value = serde_yaml_ng::from_str(&verge_text)?;
     if let Some(obj) = verge_config.as_object_mut() {
         obj.remove("webdav_username");
         obj.remove("webdav_password");
@@ -288,14 +310,14 @@ pub fn create_backup() -> Result<(String, PathBuf), Error> {
     zip.start_file(dirs::VERGE_CONFIG, options)?;
     zip.write_all(serde_yaml_ng::to_string(&verge_config)?.as_bytes())?;
 
-    let dns_config_path = dirs::app_home_dir()?.join(dirs::DNS_CONFIG);
+    let dns_config_path = dirs::app_home_dir()?.join(DNS_CONFIG);
     if dns_config_path.exists() {
-        zip.start_file(dirs::DNS_CONFIG, options)?;
-        zip.write_all(fs::read(&dns_config_path)?.as_slice())?;
+        zip.start_file(DNS_CONFIG, options)?;
+        zip.write_all(fs::read(&dns_config_path).await?.as_slice())?;
     }
 
     zip.start_file(dirs::PROFILE_YAML, options)?;
-    zip.write_all(fs::read(dirs::profiles_path()?)?.as_slice())?;
+    zip.write_all(fs::read(dirs::profiles_path()?).await?.as_slice())?;
     zip.finish()?;
     Ok((zip_file_name, zip_path))
 }

src-tauri/src/core/event_driven_proxy.rs

@@ -7,6 +7,7 @@ use tokio_stream::{StreamExt, wrappers::UnboundedReceiverStream};
 use crate::config::{Config, IVerge};
 use crate::core::{async_proxy_query::AsyncProxyQuery, handle};
 use crate::process::AsyncHandler;
+use crate::{logging, utils::logging::Type};
 use once_cell::sync::Lazy;
 use smartstring::alias::String;
 use sysproxy::{Autoproxy, Sysproxy};
@@ -74,7 +75,7 @@ struct ProxyConfig {
 static PROXY_MANAGER: Lazy<EventDrivenProxyManager> = Lazy::new(EventDrivenProxyManager::new);
 
 impl EventDrivenProxyManager {
-    pub fn global() -> &'static EventDrivenProxyManager {
+    pub fn global() -> &'static Self {
         &PROXY_MANAGER
     }
 
@@ -104,14 +105,14 @@ impl EventDrivenProxyManager {
         let query = QueryRequest { response_tx: tx };
 
         if self.query_sender.send(query).is_err() {
-            log::error!(target: "app", "发送查询请求失败，返回缓存数据");
+            logging!(error, Type::Network, "发送查询请求失败，返回缓存数据");
             return self.get_auto_proxy_cached().await;
         }
 
         match timeout(Duration::from_secs(5), rx).await {
             Ok(Ok(result)) => result,
             _ => {
-                log::warn!(target: "app", "查询超时，返回缓存数据");
+                logging!(warn, Type::Network, "Warning: 查询超时，返回缓存数据");
                 self.get_auto_proxy_cached().await
             }
         }
@@ -134,7 +135,7 @@ impl EventDrivenProxyManager {
 
     fn send_event(&self, event: ProxyEvent) {
         if let Err(e) = self.event_sender.send(event) {
-            log::error!(target: "app", "发送代理事件失败: {e}");
+            logging!(error, Type::Network, "发送代理事件失败: {e}");
         }
     }
 
@@ -143,7 +144,7 @@ impl EventDrivenProxyManager {
         event_rx: mpsc::UnboundedReceiver<ProxyEvent>,
         query_rx: mpsc::UnboundedReceiver<QueryRequest>,
     ) {
-        log::info!(target: "app", "事件驱动代理管理器启动");
+        logging!(info, Type::Network, "事件驱动代理管理器启动");
 
         // 将 mpsc 接收器包装成 Stream，避免每次循环创建 future
         let mut event_stream = UnboundedReceiverStream::new(event_rx);
@@ -158,7 +159,7 @@ impl EventDrivenProxyManager {
         loop {
             tokio::select! {
                 Some(event) = event_stream.next() => {
-                    log::debug!(target: "app", "处理代理事件: {event:?}");
+                    logging!(debug, Type::Network, "处理代理事件: {event:?}");
                     let event_clone = event.clone(); // 保存一份副本用于后续检查
                     Self::handle_event(&state, event).await;
 
@@ -179,13 +180,13 @@ impl EventDrivenProxyManager {
                     // 定时检查代理设置
                     let config = Self::get_proxy_config().await;
                     if config.guard_enabled && config.sys_enabled {
-                        log::debug!(target: "app", "定时检查代理设置");
+                        logging!(debug, Type::Network, "定时检查代理设置");
                         Self::check_and_restore_proxy(&state).await;
                     }
                 }
                 else => {
                     // 两个通道都关闭时退出
-                    log::info!(target: "app", "事件或查询通道关闭，代理管理器停止");
+                    logging!(info, Type::Network, "事件或查询通道关闭，代理管理器停止");
                     break;
                 }
             }
@@ -201,7 +202,7 @@ impl EventDrivenProxyManager {
                 Self::initialize_proxy_state(state).await;
             }
             ProxyEvent::AppStopping => {
-                log::info!(target: "app", "清理代理状态");
+                logging!(info, Type::Network, "清理代理状态");
                 Self::update_state_timestamp(state, |s| {
                     s.sys_enabled = false;
                     s.pac_enabled = false;
@@ -224,7 +225,7 @@ impl EventDrivenProxyManager {
     }
 
     async fn initialize_proxy_state(state: &Arc<RwLock<ProxyState>>) {
-        log::info!(target: "app", "初始化代理状态");
+        logging!(info, Type::Network, "初始化代理状态");
 
         let config = Self::get_proxy_config().await;
         let auto_proxy = Self::get_auto_proxy_with_timeout().await;
@@ -239,11 +240,17 @@ impl EventDrivenProxyManager {
         })
         .await;
 
-        log::info!(target: "app", "代理状态初始化完成: sys={}, pac={}", config.sys_enabled, config.pac_enabled);
+        logging!(
+            info,
+            Type::Network,
+            "代理状态初始化完成: sys={}, pac={}",
+            config.sys_enabled,
+            config.pac_enabled
+        );
     }
 
     async fn update_proxy_config(state: &Arc<RwLock<ProxyState>>) {
-        log::debug!(target: "app", "更新代理配置");
+        logging!(debug, Type::Network, "更新代理配置");
 
         let config = Self::get_proxy_config().await;
 
@@ -260,7 +267,7 @@ impl EventDrivenProxyManager {
 
     async fn check_and_restore_proxy(state: &Arc<RwLock<ProxyState>>) {
         if handle::Handle::global().is_exiting() {
-            log::debug!(target: "app", "应用正在退出，跳过系统代理守卫检查");
+            logging!(debug, Type::Network, "应用正在退出，跳过系统代理守卫检查");
             return;
         }
         let (sys_enabled, pac_enabled) = {
@@ -272,7 +279,7 @@ impl EventDrivenProxyManager {
             return;
         }
 
-        log::debug!(target: "app", "检查代理状态");
+        logging!(debug, Type::Network, "检查代理状态");
 
         if pac_enabled {
             Self::check_and_restore_pac_proxy(state).await;
@@ -283,7 +290,7 @@ impl EventDrivenProxyManager {
 
     async fn check_and_restore_pac_proxy(state: &Arc<RwLock<ProxyState>>) {
         if handle::Handle::global().is_exiting() {
-            log::debug!(target: "app", "应用正在退出，跳过PAC代理恢复检查");
+            logging!(debug, Type::Network, "应用正在退出，跳过PAC代理恢复检查");
             return;
         }
 
@@ -296,9 +303,9 @@ impl EventDrivenProxyManager {
         .await;
 
         if !current.enable || current.url != expected.url {
-            log::info!(target: "app", "PAC代理设置异常，正在恢复...");
+            logging!(info, Type::Network, "PAC代理设置异常，正在恢复...");
             if let Err(e) = Self::restore_pac_proxy(&expected.url).await {
-                log::error!(target: "app", "恢复PAC代理失败: {}", e);
+                logging!(error, Type::Network, "恢复PAC代理失败: {}", e);
             }
 
             sleep(Duration::from_millis(500)).await;
@@ -314,7 +321,7 @@ impl EventDrivenProxyManager {
 
     async fn check_and_restore_sys_proxy(state: &Arc<RwLock<ProxyState>>) {
         if handle::Handle::global().is_exiting() {
-            log::debug!(target: "app", "应用正在退出，跳过系统代理恢复检查");
+            logging!(debug, Type::Network, "应用正在退出，跳过系统代理恢复检查");
             return;
         }
 
@@ -327,9 +334,9 @@ impl EventDrivenProxyManager {
         .await;
 
         if !current.enable || current.host != expected.host || current.port != expected.port {
-            log::info!(target: "app", "系统代理设置异常，正在恢复...");
+            logging!(info, Type::Network, "系统代理设置异常，正在恢复...");
             if let Err(e) = Self::restore_sys_proxy(&expected).await {
-                log::error!(target: "app", "恢复系统代理失败: {}", e);
+                logging!(error, Type::Network, "恢复系统代理失败: {}", e);
             }
 
             sleep(Duration::from_millis(500)).await;
@@ -380,7 +387,7 @@ impl EventDrivenProxyManager {
     async fn get_proxy_config() -> ProxyConfig {
         let (sys_enabled, pac_enabled, guard_enabled, guard_duration) = {
             let verge_config = Config::verge().await;
-            let verge = verge_config.latest_ref();
+            let verge = verge_config.latest_arc();
             (
                 verge.enable_system_proxy.unwrap_or(false),
                 verge.proxy_auto_config.unwrap_or(false),
@@ -399,7 +406,7 @@ impl EventDrivenProxyManager {
     async fn get_expected_pac_config() -> Autoproxy {
         let proxy_host = {
             let verge_config = Config::verge().await;
-            let verge = verge_config.latest_ref();
+            let verge = verge_config.latest_arc();
             verge
                 .proxy_host
                 .clone()
@@ -417,13 +424,13 @@ impl EventDrivenProxyManager {
 
         let (verge_mixed_port, proxy_host) = {
             let verge_config = Config::verge().await;
-            let verge_ref = verge_config.latest_ref();
+            let verge_ref = verge_config.latest_arc();
             (verge_ref.verge_mixed_port, verge_ref.proxy_host.clone())
         };
 
         let default_port = {
             let clash_config = Config::clash().await;
-            clash_config.latest_ref().get_mixed_port()
+            clash_config.latest_arc().get_mixed_port()
         };
 
         let port = verge_mixed_port.unwrap_or(default_port);
@@ -443,7 +450,7 @@ impl EventDrivenProxyManager {
         use crate::constants::bypass;
 
         let verge_config = Config::verge().await;
-        let verge = verge_config.latest_ref();
+        let verge = verge_config.latest_arc();
         let use_default = verge.use_default_bypass.unwrap_or(true);
         let custom = verge.system_proxy_bypass.as_deref().unwrap_or("");
 
@@ -457,7 +464,7 @@ impl EventDrivenProxyManager {
     #[cfg(target_os = "windows")]
     async fn restore_pac_proxy(expected_url: &str) -> Result<(), anyhow::Error> {
         if handle::Handle::global().is_exiting() {
-            log::debug!(target: "app", "应用正在退出，跳过PAC代理恢复");
+            logging!(debug, Type::Network, "应用正在退出，跳过PAC代理恢复");
             return Ok(());
         }
         Self::execute_sysproxy_command(&["pac", expected_url]).await
@@ -481,7 +488,7 @@ impl EventDrivenProxyManager {
     #[cfg(target_os = "windows")]
     async fn restore_sys_proxy(expected: &Sysproxy) -> Result<(), anyhow::Error> {
         if handle::Handle::global().is_exiting() {
-            log::debug!(target: "app", "应用正在退出，跳过系统代理恢复");
+            logging!(debug, Type::Network, "应用正在退出，跳过系统代理恢复");
             return Ok(());
         }
         let address = format!("{}:{}", expected.host, expected.port);
@@ -502,8 +509,9 @@ impl EventDrivenProxyManager {
     #[cfg(target_os = "windows")]
     async fn execute_sysproxy_command(args: &[&str]) -> Result<(), anyhow::Error> {
         if handle::Handle::global().is_exiting() {
-            log::debug!(
-                target: "app",
+            logging!(
+                debug,
+                Type::Network,
                 "应用正在退出，取消调用 sysproxy.exe，参数: {:?}",
                 args
             );
@@ -518,14 +526,14 @@ impl EventDrivenProxyManager {
         let binary_path = match dirs::service_path() {
             Ok(path) => path,
             Err(e) => {
-                log::error!(target: "app", "获取服务路径失败: {e}");
+                logging!(error, Type::Network, "获取服务路径失败: {e}");
                 return Err(e);
             }
         };
 
         let sysproxy_exe = binary_path.with_file_name("sysproxy.exe");
         if !sysproxy_exe.exists() {
-            log::error!(target: "app", "sysproxy.exe 不存在");
+            logging!(error, Type::Network, "sysproxy.exe 不存在");
         }
         anyhow::ensure!(sysproxy_exe.exists(), "sysproxy.exe does not exist");
 

src-tauri/src/core/handle.rs

@@ -102,14 +102,14 @@ impl Handle {
         Self::send_event(FrontendEvent::ProfileUpdateCompleted { uid });
     }
 
+    // TODO 利用 &str 等缩短 Clone
     pub fn notice_message<S: Into<String>, M: Into<String>>(status: S, msg: M) {
         let handle = Self::global();
         let status_str = status.into();
         let msg_str = msg.into();
 
         if !*handle.startup_completed.read() {
-            let mut errors = handle.startup_errors.write();
-            errors.push(ErrorMessage {
+            handle.startup_errors.write().push(ErrorMessage {
                 status: status_str,
                 message: msg_str,
             });
@@ -158,7 +158,7 @@ impl Handle {
             .spawn(move || {
                 thread::sleep(timing::STARTUP_ERROR_DELAY);
 
-                let handle = Handle::global();
+                let handle = Self::global();
                 if handle.is_exiting() {
                     return;
                 }

src-tauri/src/core/hotkey.rs

@@ -5,10 +5,9 @@ use crate::{
     singleton_with_logging, utils::logging::Type,
 };
 use anyhow::{Result, bail};
-use parking_lot::Mutex;
+use arc_swap::ArcSwap;
 use smartstring::alias::String;
 use std::{collections::HashMap, fmt, str::FromStr, sync::Arc};
-use tauri::{AppHandle, Manager};
 use tauri_plugin_global_shortcut::{Code, GlobalShortcutExt, ShortcutState};
 
 /// Enum representing all available hotkey functions
@@ -29,16 +28,16 @@ pub enum HotkeyFunction {
 impl fmt::Display for HotkeyFunction {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let s = match self {
-            HotkeyFunction::OpenOrCloseDashboard => "open_or_close_dashboard",
-            HotkeyFunction::ClashModeRule => "clash_mode_rule",
-            HotkeyFunction::ClashModeGlobal => "clash_mode_global",
-            HotkeyFunction::ClashModeDirect => "clash_mode_direct",
-            HotkeyFunction::ToggleSystemProxy => "toggle_system_proxy",
-            HotkeyFunction::ToggleTunMode => "toggle_tun_mode",
-            HotkeyFunction::EntryLightweightMode => "entry_lightweight_mode",
-            HotkeyFunction::Quit => "quit",
+            Self::OpenOrCloseDashboard => "open_or_close_dashboard",
+            Self::ClashModeRule => "clash_mode_rule",
+            Self::ClashModeGlobal => "clash_mode_global",
+            Self::ClashModeDirect => "clash_mode_direct",
+            Self::ToggleSystemProxy => "toggle_system_proxy",
+            Self::ToggleTunMode => "toggle_tun_mode",
+            Self::EntryLightweightMode => "entry_lightweight_mode",
+            Self::Quit => "quit",
             #[cfg(target_os = "macos")]
-            HotkeyFunction::Hide => "hide",
+            Self::Hide => "hide",
         };
         write!(f, "{s}")
     }
@@ -49,16 +48,16 @@ impl FromStr for HotkeyFunction {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s.trim() {
-            "open_or_close_dashboard" => Ok(HotkeyFunction::OpenOrCloseDashboard),
-            "clash_mode_rule" => Ok(HotkeyFunction::ClashModeRule),
-            "clash_mode_global" => Ok(HotkeyFunction::ClashModeGlobal),
-            "clash_mode_direct" => Ok(HotkeyFunction::ClashModeDirect),
-            "toggle_system_proxy" => Ok(HotkeyFunction::ToggleSystemProxy),
-            "toggle_tun_mode" => Ok(HotkeyFunction::ToggleTunMode),
-            "entry_lightweight_mode" => Ok(HotkeyFunction::EntryLightweightMode),
-            "quit" => Ok(HotkeyFunction::Quit),
+            "open_or_close_dashboard" => Ok(Self::OpenOrCloseDashboard),
+            "clash_mode_rule" => Ok(Self::ClashModeRule),
+            "clash_mode_global" => Ok(Self::ClashModeGlobal),
+            "clash_mode_direct" => Ok(Self::ClashModeDirect),
+            "toggle_system_proxy" => Ok(Self::ToggleSystemProxy),
+            "toggle_tun_mode" => Ok(Self::ToggleTunMode),
+            "entry_lightweight_mode" => Ok(Self::EntryLightweightMode),
+            "quit" => Ok(Self::Quit),
             #[cfg(target_os = "macos")]
-            "hide" => Ok(HotkeyFunction::Hide),
+            "hide" => Ok(Self::Hide),
             _ => bail!("invalid hotkey function: {}", s),
         }
     }
@@ -76,8 +75,8 @@ pub enum SystemHotkey {
 impl fmt::Display for SystemHotkey {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let s = match self {
-            SystemHotkey::CmdQ => "CMD+Q",
-            SystemHotkey::CmdW => "CMD+W",
+            Self::CmdQ => "CMD+Q",
+            Self::CmdW => "CMD+W",
         };
         write!(f, "{s}")
     }
@@ -85,86 +84,73 @@ impl fmt::Display for SystemHotkey {
 
 #[cfg(target_os = "macos")]
 impl SystemHotkey {
-    pub fn function(self) -> HotkeyFunction {
+    pub const fn function(self) -> HotkeyFunction {
         match self {
-            SystemHotkey::CmdQ => HotkeyFunction::Quit,
-            SystemHotkey::CmdW => HotkeyFunction::Hide,
+            Self::CmdQ => HotkeyFunction::Quit,
+            Self::CmdW => HotkeyFunction::Hide,
         }
     }
 }
 
 pub struct Hotkey {
-    current: Arc<Mutex<Vec<String>>>,
+    current: ArcSwap<Vec<String>>,
 }
 
 impl Hotkey {
     fn new() -> Self {
         Self {
-            current: Arc::new(Mutex::new(Vec::new())),
+            current: ArcSwap::new(Arc::new(Vec::new())),
         }
     }
 
     /// Execute the function associated with a hotkey function enum
-    fn execute_function(function: HotkeyFunction, app_handle: &AppHandle) {
-        let app_handle = app_handle.clone();
+    fn execute_function(function: HotkeyFunction) {
         match function {
             HotkeyFunction::OpenOrCloseDashboard => {
                 AsyncHandler::spawn(async move || {
                     crate::feat::open_or_close_dashboard().await;
-                    notify_event(app_handle, NotificationEvent::DashboardToggled).await;
+                    notify_event(NotificationEvent::DashboardToggled).await;
                 });
             }
             HotkeyFunction::ClashModeRule => {
                 AsyncHandler::spawn(async move || {
                     feat::change_clash_mode("rule".into()).await;
-                    notify_event(
-                        app_handle,
-                        NotificationEvent::ClashModeChanged { mode: "Rule" },
-                    )
-                    .await;
+                    notify_event(NotificationEvent::ClashModeChanged { mode: "Rule" }).await;
                 });
             }
             HotkeyFunction::ClashModeGlobal => {
                 AsyncHandler::spawn(async move || {
                     feat::change_clash_mode("global".into()).await;
-                    notify_event(
-                        app_handle,
-                        NotificationEvent::ClashModeChanged { mode: "Global" },
-                    )
-                    .await;
+                    notify_event(NotificationEvent::ClashModeChanged { mode: "Global" }).await;
                 });
             }
             HotkeyFunction::ClashModeDirect => {
                 AsyncHandler::spawn(async move || {
                     feat::change_clash_mode("direct".into()).await;
-                    notify_event(
-                        app_handle,
-                        NotificationEvent::ClashModeChanged { mode: "Direct" },
-                    )
-                    .await;
+                    notify_event(NotificationEvent::ClashModeChanged { mode: "Direct" }).await;
                 });
             }
             HotkeyFunction::ToggleSystemProxy => {
                 AsyncHandler::spawn(async move || {
                     feat::toggle_system_proxy().await;
-                    notify_event(app_handle, NotificationEvent::SystemProxyToggled).await;
+                    notify_event(NotificationEvent::SystemProxyToggled).await;
                 });
             }
             HotkeyFunction::ToggleTunMode => {
                 AsyncHandler::spawn(async move || {
                     feat::toggle_tun_mode(None).await;
-                    notify_event(app_handle, NotificationEvent::TunModeToggled).await;
+                    notify_event(NotificationEvent::TunModeToggled).await;
                 });
             }
             HotkeyFunction::EntryLightweightMode => {
                 AsyncHandler::spawn(async move || {
                     entry_lightweight_mode().await;
-                    notify_event(app_handle, NotificationEvent::LightweightModeEntered).await;
+                    notify_event(NotificationEvent::LightweightModeEntered).await;
                 });
             }
             HotkeyFunction::Quit => {
                 AsyncHandler::spawn(async move || {
-                    notify_event(app_handle, NotificationEvent::AppQuit).await;
+                    notify_event(NotificationEvent::AppQuit).await;
                     feat::quit().await;
                 });
             }
@@ -172,7 +158,7 @@ impl Hotkey {
             HotkeyFunction::Hide => {
                 AsyncHandler::spawn(async move || {
                     feat::hide().await;
-                    notify_event(app_handle, NotificationEvent::AppHidden).await;
+                    notify_event(NotificationEvent::AppHidden).await;
                 });
             }
         }
@@ -224,14 +210,12 @@ impl Hotkey {
 
         let is_quit = matches!(function, HotkeyFunction::Quit);
 
-        manager.on_shortcut(hotkey, move |app_handle, hotkey_event, event| {
+        manager.on_shortcut(hotkey, move |_app_handle, hotkey_event, event| {
             let hotkey_event_owned = *hotkey_event;
             let event_owned = event;
             let function_owned = function;
             let is_quit_owned = is_quit;
 
-            let app_handle_cloned = app_handle.clone();
-
             AsyncHandler::spawn(move || async move {
                 if event_owned.state == ShortcutState::Pressed {
                     logging!(
@@ -242,30 +226,30 @@ impl Hotkey {
                     );
 
                     if hotkey_event_owned.key == Code::KeyQ && is_quit_owned {
-                        if let Some(window) = app_handle_cloned.get_webview_window("main")
+                        if let Some(window) = handle::Handle::get_window()
                             && window.is_focused().unwrap_or(false)
                         {
                             logging!(debug, Type::Hotkey, "Executing quit function");
-                            Self::execute_function(function_owned, &app_handle_cloned);
+                            Self::execute_function(function_owned);
                         }
                     } else {
                         logging!(debug, Type::Hotkey, "Executing function directly");
 
                         let is_enable_global_hotkey = Config::verge()
                             .await
-                            .latest_ref()
+                            .latest_arc()
                             .enable_global_hotkey
                             .unwrap_or(true);
 
                         if is_enable_global_hotkey {
-                            Self::execute_function(function_owned, &app_handle_cloned);
+                            Self::execute_function(function_owned);
                         } else {
                             use crate::utils::window_manager::WindowManager;
                             let is_visible = WindowManager::is_main_window_visible();
                             let is_focused = WindowManager::is_main_window_focused();
 
                             if is_focused && is_visible {
-                                Self::execute_function(function_owned, &app_handle_cloned);
+                                Self::execute_function(function_owned);
                             }
                         }
                     }
@@ -288,9 +272,9 @@ impl Hotkey {
 singleton_with_logging!(Hotkey, INSTANCE, "Hotkey");
 
 impl Hotkey {
-    pub async fn init(&self) -> Result<()> {
+    pub async fn init(&self, skip: bool) -> Result<()> {
         let verge = Config::verge().await;
-        let enable_global_hotkey = verge.latest_ref().enable_global_hotkey.unwrap_or(true);
+        let enable_global_hotkey = !skip && verge.latest_arc().enable_global_hotkey.unwrap_or(true);
 
         logging!(
             debug,
@@ -299,12 +283,8 @@ impl Hotkey {
             enable_global_hotkey
         );
 
-        if !enable_global_hotkey {
-            return Ok(());
-        }
-
         // Extract hotkeys data before async operations
-        let hotkeys = verge.latest_ref().hotkeys.as_ref().cloned();
+        let hotkeys = verge.latest_arc().hotkeys.as_ref().cloned();
 
         if let Some(hotkeys) = hotkeys {
             logging!(
@@ -360,7 +340,7 @@ impl Hotkey {
                     }
                 }
             }
-            self.current.lock().clone_from(&hotkeys);
+            self.current.store(Arc::new(hotkeys));
         } else {
             logging!(debug, Type::Hotkey, "No hotkeys configured");
         }
@@ -391,8 +371,8 @@ impl Hotkey {
 
     pub async fn update(&self, new_hotkeys: Vec<String>) -> Result<()> {
         // Extract current hotkeys before async operations
-        let current_hotkeys = self.current.lock().clone();
-        let old_map = Self::get_map_from_vec(&current_hotkeys);
+        let current_hotkeys = &*self.current.load();
+        let old_map = Self::get_map_from_vec(current_hotkeys);
         let new_map = Self::get_map_from_vec(&new_hotkeys);
 
         let (del, add) = Self::get_diff(old_map, new_map);
@@ -406,7 +386,7 @@ impl Hotkey {
         }
 
         // Update the current hotkeys after all async operations
-        *self.current.lock() = new_hotkeys;
+        self.current.store(Arc::new(new_hotkeys));
         Ok(())
     }
 

src-tauri/src/core/manager/config.rs

@@ -17,12 +17,14 @@ impl CoreManager {
         use crate::constants::files::RUNTIME_CONFIG;
 
         let runtime_path = dirs::app_home_dir()?.join(RUNTIME_CONFIG);
-        let clash_config = Config::clash().await.latest_ref().0.clone();
+        let clash_config = &Config::clash().await.latest_arc().0;
 
-        *Config::runtime().await.draft_mut() = Box::new(IRuntime {
-            config: Some(clash_config.clone()),
-            exists_keys: vec![],
-            chain_logs: Default::default(),
+        Config::runtime().await.edit_draft(|d| {
+            *d = IRuntime {
+                config: Some(clash_config.to_owned()),
+                exists_keys: vec![],
+                chain_logs: Default::default(),
+            }
         });
 
         help::save_yaml(&runtime_path, &clash_config, Some("# Clash Verge Runtime")).await?;
@@ -39,25 +41,20 @@ impl CoreManager {
             return Ok((true, String::new()));
         }
 
-        let _permit = self
-            .update_semaphore
-            .try_acquire()
-            .map_err(|_| anyhow!("Config update already in progress"))?;
-
         self.perform_config_update().await
     }
 
     fn should_update_config(&self) -> Result<bool> {
         let now = Instant::now();
-        let mut last = self.last_update.lock();
+        let last = self.get_last_update();
 
-        if let Some(last_time) = *last
-            && now.duration_since(last_time) < timing::CONFIG_UPDATE_DEBOUNCE
+        if let Some(last_time) = last
+            && now.duration_since(*last_time) < timing::CONFIG_UPDATE_DEBOUNCE
         {
             return Ok(false);
         }
 
-        *last = Some(now);
+        self.set_last_update(now);
         Ok(true)
     }
 
@@ -140,7 +137,7 @@ impl CoreManager {
         }
     }
 
-    fn is_connection_io_error(kind: std::io::ErrorKind) -> bool {
+    const fn is_connection_io_error(kind: std::io::ErrorKind) -> bool {
         matches!(
             kind,
             std::io::ErrorKind::ConnectionAborted

src-tauri/src/core/manager/lifecycle.rs

@@ -1,4 +1,5 @@
 use super::{CoreManager, RunningMode};
+use crate::config::{Config, ConfigType, IVerge};
 use crate::{
     core::{
         logger::CLASH_LOGGER,
@@ -41,21 +42,17 @@ impl CoreManager {
         self.start_core().await
     }
 
-    pub async fn change_core(&self, clash_core: Option<String>) -> Result<(), String> {
-        use crate::config::{Config, ConfigType, IVerge};
-
-        let core = clash_core
-            .as_ref()
-            .ok_or_else(|| "Clash core cannot be None".to_string())?;
-
-        if !IVerge::VALID_CLASH_CORES.contains(&core.as_str()) {
-            return Err(format!("Invalid clash core: {}", core).into());
+    pub async fn change_core(&self, clash_core: &String) -> Result<(), String> {
+        if !IVerge::VALID_CLASH_CORES.contains(&clash_core.as_str()) {
+            return Err(format!("Invalid clash core: {}", clash_core).into());
         }
 
-        Config::verge().await.draft_mut().clash_core = clash_core;
+        Config::verge().await.edit_draft(|d| {
+            d.clash_core = Some(clash_core.to_owned());
+        });
         Config::verge().await.apply();
 
-        let verge_data = Config::verge().await.latest_ref().clone();
+        let verge_data = Config::verge().await.latest_arc();
         verge_data.save_file().await.map_err(|e| e.to_string())?;
 
         let run_path = Config::generate_file(ConfigType::Run)
@@ -71,7 +68,8 @@ impl CoreManager {
         #[cfg(target_os = "windows")]
         self.wait_for_service_if_needed().await;
 
-        let mode = match SERVICE_MANAGER.lock().await.current() {
+        let value = SERVICE_MANAGER.lock().await.current();
+        let mode = match value {
             ServiceStatus::Ready => RunningMode::Service,
             _ => RunningMode::Sidecar,
         };
@@ -87,7 +85,7 @@ impl CoreManager {
 
         let needs_service = Config::verge()
             .await
-            .latest_ref()
+            .latest_arc()
             .enable_tun_mode
             .unwrap_or(false);
 

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

@@ -1,12 +1,10 @@
 mod config;
 mod lifecycle;
-mod process;
 mod state;
 
 use anyhow::Result;
-use parking_lot::Mutex;
+use arc_swap::{ArcSwap, ArcSwapOption};
 use std::{fmt, sync::Arc, time::Instant};
-use tokio::sync::Semaphore;
 
 use crate::process::CommandChildGuard;
 use crate::singleton_lazy;
@@ -30,22 +28,21 @@ impl fmt::Display for RunningMode {
 
 #[derive(Debug)]
 pub struct CoreManager {
-    state: Arc<Mutex<State>>,
-    update_semaphore: Arc<Semaphore>,
-    last_update: Arc<Mutex<Option<Instant>>>,
+    state: ArcSwap<State>,
+    last_update: ArcSwapOption<Instant>,
 }
 
 #[derive(Debug)]
 struct State {
-    running_mode: Arc<RunningMode>,
-    child_sidecar: Option<CommandChildGuard>,
+    running_mode: ArcSwap<RunningMode>,
+    child_sidecar: ArcSwapOption<CommandChildGuard>,
 }
 
 impl Default for State {
     fn default() -> Self {
         Self {
-            running_mode: Arc::new(RunningMode::NotRunning),
-            child_sidecar: None,
+            running_mode: ArcSwap::new(Arc::new(RunningMode::NotRunning)),
+            child_sidecar: ArcSwapOption::new(None),
         }
     }
 }
@@ -53,28 +50,44 @@ impl Default for State {
 impl Default for CoreManager {
     fn default() -> Self {
         Self {
-            state: Arc::new(Mutex::new(State::default())),
-            update_semaphore: Arc::new(Semaphore::new(1)),
-            last_update: Arc::new(Mutex::new(None)),
+            state: ArcSwap::new(Arc::new(State::default())),
+            last_update: ArcSwapOption::new(None),
         }
     }
 }
 
 impl CoreManager {
     pub fn get_running_mode(&self) -> Arc<RunningMode> {
-        Arc::clone(&self.state.lock().running_mode)
+        Arc::clone(&self.state.load().running_mode.load())
+    }
+
+    pub fn take_child_sidecar(&self) -> Option<CommandChildGuard> {
+        self.state
+            .load()
+            .child_sidecar
+            .swap(None)
+            .and_then(|arc| Arc::try_unwrap(arc).ok())
+    }
+
+    pub fn get_last_update(&self) -> Option<Arc<Instant>> {
+        self.last_update.load_full()
     }
 
     pub fn set_running_mode(&self, mode: RunningMode) {
-        self.state.lock().running_mode = Arc::new(mode);
+        let state = self.state.load();
+        state.running_mode.store(Arc::new(mode));
     }
 
     pub fn set_running_child_sidecar(&self, child: CommandChildGuard) {
-        self.state.lock().child_sidecar = Some(child);
+        let state = self.state.load();
+        state.child_sidecar.store(Some(Arc::new(child)));
+    }
+
+    pub fn set_last_update(&self, time: Instant) {
+        self.last_update.store(Some(Arc::new(time)));
     }
 
     pub async fn init(&self) -> Result<()> {
-        self.cleanup_orphaned_processes().await?;
         self.start_core().await?;
         Ok(())
     }

src-tauri/src/core/manager/process.rs

@@ -1,244 +0,0 @@
-use super::CoreManager;
-#[cfg(windows)]
-use crate::process::AsyncHandler;
-use crate::{
-    constants::{process, timing},
-    logging,
-    utils::logging::Type,
-};
-use anyhow::Result;
-#[cfg(windows)]
-use anyhow::anyhow;
-
-impl CoreManager {
-    pub async fn cleanup_orphaned_processes(&self) -> Result<()> {
-        logging!(info, Type::Core, "Cleaning orphaned mihomo processes");
-
-        let current_pid = self
-            .state
-            .lock()
-            .child_sidecar
-            .as_ref()
-            .and_then(|c| c.pid());
-        let target_processes = process::process_names();
-
-        let process_futures = target_processes.iter().map(|&name| {
-            let process_name = process::with_extension(name);
-            self.find_processes_by_name(process_name, name)
-        });
-
-        let process_results = futures::future::join_all(process_futures).await;
-
-        let pids_to_kill: Vec<_> = process_results
-            .into_iter()
-            .filter_map(Result::ok)
-            .flat_map(|(pids, name)| {
-                pids.into_iter()
-                    .filter(move |&pid| Some(pid) != current_pid)
-                    .map(move |pid| (pid, name.clone()))
-            })
-            .collect();
-
-        if pids_to_kill.is_empty() {
-            return Ok(());
-        }
-
-        let kill_futures = pids_to_kill
-            .iter()
-            .map(|(pid, name)| self.kill_process_verified(*pid, name.clone()));
-
-        let killed_count = futures::future::join_all(kill_futures)
-            .await
-            .into_iter()
-            .filter(|&success| success)
-            .count();
-
-        if killed_count > 0 {
-            logging!(
-                info,
-                Type::Core,
-                "Cleaned {} orphaned processes",
-                killed_count
-            );
-        }
-
-        Ok(())
-    }
-
-    async fn find_processes_by_name(
-        &self,
-        process_name: String,
-        _target: &str,
-    ) -> Result<(Vec<u32>, String)> {
-        #[cfg(windows)]
-        {
-            use std::mem;
-            use winapi::um::{
-                handleapi::CloseHandle,
-                tlhelp32::{
-                    CreateToolhelp32Snapshot, PROCESSENTRY32W, Process32FirstW, Process32NextW,
-                    TH32CS_SNAPPROCESS,
-                },
-            };
-
-            let process_name_clone = process_name.clone();
-            let pids = AsyncHandler::spawn_blocking(move || -> Result<Vec<u32>> {
-                let mut pids = Vec::new();
-
-                unsafe {
-                    let snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
-                    if snapshot == winapi::um::handleapi::INVALID_HANDLE_VALUE {
-                        return Err(anyhow!("Failed to create process snapshot"));
-                    }
-
-                    let mut pe32: PROCESSENTRY32W = mem::zeroed();
-                    pe32.dwSize = mem::size_of::<PROCESSENTRY32W>() as u32;
-
-                    if Process32FirstW(snapshot, &mut pe32) != 0 {
-                        loop {
-                            let end_pos = pe32
-                                .szExeFile
-                                .iter()
-                                .position(|&x| x == 0)
-                                .unwrap_or(pe32.szExeFile.len());
-
-                            let exe_file = String::from_utf16_lossy(&pe32.szExeFile[..end_pos]);
-                            if exe_file.eq_ignore_ascii_case(&process_name_clone) {
-                                pids.push(pe32.th32ProcessID);
-                            }
-
-                            if Process32NextW(snapshot, &mut pe32) == 0 {
-                                break;
-                            }
-                        }
-                    }
-
-                    CloseHandle(snapshot);
-                }
-
-                Ok(pids)
-            })
-            .await??;
-
-            Ok((pids, process_name))
-        }
-
-        #[cfg(not(windows))]
-        {
-            let cmd = if cfg!(target_os = "macos") {
-                "pgrep"
-            } else {
-                "pidof"
-            };
-            let output = tokio::process::Command::new(cmd)
-                .arg(&process_name)
-                .output()
-                .await?;
-
-            if !output.status.success() {
-                return Ok((Vec::new(), process_name));
-            }
-
-            let stdout = String::from_utf8_lossy(&output.stdout);
-            let pids: Vec<u32> = stdout
-                .split_whitespace()
-                .filter_map(|s| s.parse().ok())
-                .collect();
-
-            Ok((pids, process_name))
-        }
-    }
-
-    async fn kill_process_verified(&self, pid: u32, process_name: String) -> bool {
-        #[cfg(windows)]
-        let success = {
-            use winapi::um::{
-                handleapi::CloseHandle,
-                processthreadsapi::{OpenProcess, TerminateProcess},
-                winnt::{HANDLE, PROCESS_TERMINATE},
-            };
-
-            AsyncHandler::spawn_blocking(move || unsafe {
-                let handle: HANDLE = OpenProcess(PROCESS_TERMINATE, 0, pid);
-                if handle.is_null() {
-                    return false;
-                }
-                let result = TerminateProcess(handle, 1) != 0;
-                CloseHandle(handle);
-                result
-            })
-            .await
-            .unwrap_or(false)
-        };
-
-        #[cfg(not(windows))]
-        let success = tokio::process::Command::new("kill")
-            .args(["-9", &pid.to_string()])
-            .output()
-            .await
-            .map(|output| output.status.success())
-            .unwrap_or(false);
-
-        if !success {
-            return false;
-        }
-
-        tokio::time::sleep(timing::PROCESS_VERIFY_DELAY).await;
-
-        if self.is_process_running(pid).await.unwrap_or(false) {
-            logging!(
-                warn,
-                Type::Core,
-                "Process {} (PID: {}) still running after termination",
-                process_name,
-                pid
-            );
-            false
-        } else {
-            logging!(
-                info,
-                Type::Core,
-                "Terminated process {} (PID: {})",
-                process_name,
-                pid
-            );
-            true
-        }
-    }
-
-    async fn is_process_running(&self, pid: u32) -> Result<bool> {
-        #[cfg(windows)]
-        {
-            use winapi::{
-                shared::minwindef::DWORD,
-                um::{
-                    handleapi::CloseHandle,
-                    processthreadsapi::{GetExitCodeProcess, OpenProcess},
-                    winnt::{HANDLE, PROCESS_QUERY_INFORMATION},
-                },
-            };
-
-            AsyncHandler::spawn_blocking(move || unsafe {
-                let handle: HANDLE = OpenProcess(PROCESS_QUERY_INFORMATION, 0, pid);
-                if handle.is_null() {
-                    return Ok(false);
-                }
-                let mut exit_code: DWORD = 0;
-                let result = GetExitCodeProcess(handle, &mut exit_code);
-                CloseHandle(handle);
-                Ok(result != 0 && exit_code == 259)
-            })
-            .await?
-        }
-
-        #[cfg(not(windows))]
-        {
-            let output = tokio::process::Command::new("ps")
-                .args(["-p", &pid.to_string()])
-                .output()
-                .await?;
-
-            Ok(output.status.success() && !output.stdout.is_empty())
-        }
-    }
-}

src-tauri/src/core/manager/state.rs

@@ -32,7 +32,7 @@ impl CoreManager {
 
         let config_file = Config::generate_file(crate::config::ConfigType::Run).await?;
         let app_handle = handle::Handle::app_handle();
-        let clash_core = Config::verge().await.latest_ref().get_valid_clash_core();
+        let clash_core = Config::verge().await.latest_arc().get_valid_clash_core();
         let config_dir = dirs::app_home_dir()?;
 
         let (mut rx, child) = app_handle
@@ -62,8 +62,12 @@ impl CoreManager {
                     | tauri_plugin_shell::process::CommandEvent::Stderr(line) => {
                         let mut now = DeferredNow::default();
                         let message = CompactString::from(String::from_utf8_lossy(&line).as_ref());
-                        let w = shared_writer.lock().await;
-                        write_sidecar_log(w, &mut now, Level::Error, &message);
+                        write_sidecar_log(
+                            shared_writer.lock().await,
+                            &mut now,
+                            Level::Error,
+                            &message,
+                        );
                         CLASH_LOGGER.append_log(message).await;
                     }
                     tauri_plugin_shell::process::CommandEvent::Terminated(term) => {
@@ -75,8 +79,12 @@ impl CoreManager {
                         } else {
                             CompactString::from("Process terminated")
                         };
-                        let w = shared_writer.lock().await;
-                        write_sidecar_log(w, &mut now, Level::Info, &message);
+                        write_sidecar_log(
+                            shared_writer.lock().await,
+                            &mut now,
+                            Level::Info,
+                            &message,
+                        );
                         CLASH_LOGGER.clear_logs().await;
                         break;
                     }
@@ -93,8 +101,7 @@ impl CoreManager {
         defer! {
             self.set_running_mode(RunningMode::NotRunning);
         }
-        let mut state = self.state.lock();
-        if let Some(child) = state.child_sidecar.take() {
+        if let Some(child) = self.take_child_sidecar() {
             let pid = child.pid();
             drop(child);
             logging!(trace, Type::Core, "Sidecar stopped (PID: {:?})", pid);

src-tauri/src/core/notification.rs

@@ -1,3 +1,4 @@
+use super::handle::Handle;
 use crate::{
     constants::{retry, timing},
     logging,
@@ -11,7 +12,7 @@ use std::{
         mpsc,
     },
     thread,
-    time::Instant,
+    time::{Duration, Instant},
 };
 use tauri::{Emitter, WebviewWindow};
 
@@ -91,23 +92,26 @@ impl NotificationSystem {
     }
 
     fn worker_loop(rx: mpsc::Receiver<FrontendEvent>) {
-        use super::handle::Handle;
-
-        let handle = Handle::global();
-
-        while !handle.is_exiting() {
-            match rx.recv_timeout(std::time::Duration::from_millis(100)) {
+        loop {
+            let handle = Handle::global();
+            if handle.is_exiting() {
+                break;
+            }
+            match rx.recv_timeout(Duration::from_millis(1_000)) {
                 Ok(event) => Self::process_event(handle, event),
+                Err(mpsc::RecvTimeoutError::Timeout) => (),
                 Err(mpsc::RecvTimeoutError::Disconnected) => break,
-                Err(mpsc::RecvTimeoutError::Timeout) => break,
             }
         }
     }
 
+    // Clippy 似乎对 parking lot 的 RwLock 有误报，这里禁用相关警告
+    #[allow(clippy::significant_drop_tightening)]
     fn process_event(handle: &super::handle::Handle, event: FrontendEvent) {
-        let system_guard = handle.notification_system.read();
-        let Some(system) = system_guard.as_ref() else {
-            return;
+        let binding = handle.notification_system.read();
+        let system = match binding.as_ref() {
+            Some(s) => s,
+            None => return,
         };
 
         if system.should_skip_event(&event) {

src-tauri/src/core/service.rs

@@ -1,5 +1,6 @@
 use crate::{
     config::Config,
+    core::tray,
     logging, logging_error,
     utils::{dirs, init::service_writer_config, logging::Type},
 };
@@ -135,7 +136,7 @@ async fn uninstall_service() -> Result<()> {
     let elevator = crate::utils::help::linux_elevator();
     let status = match get_effective_uid() {
         0 => StdCommand::new(uninstall_shell).status()?,
-        _ => StdCommand::new(elevator.clone())
+        _ => StdCommand::new(elevator)
             .arg("sh")
             .arg("-c")
             .arg(uninstall_shell)
@@ -176,7 +177,7 @@ async fn install_service() -> Result<()> {
     let elevator = crate::utils::help::linux_elevator();
     let status = match get_effective_uid() {
         0 => StdCommand::new(install_shell).status()?,
-        _ => StdCommand::new(elevator.clone())
+        _ => StdCommand::new(elevator)
             .arg("sh")
             .arg("-c")
             .arg(install_shell)
@@ -352,7 +353,7 @@ pub(super) async fn start_with_existing_service(config_file: &PathBuf) -> Result
     logging!(info, Type::Service, "尝试使用现有服务启动核心");
 
     let verge_config = Config::verge().await;
-    let clash_core = verge_config.latest_ref().get_valid_clash_core();
+    let clash_core = verge_config.latest_arc().get_valid_clash_core();
     drop(verge_config);
 
     let bin_ext = if cfg!(windows) { ".exe" } else { "" };
@@ -448,7 +449,7 @@ impl ServiceManager {
         Self(ServiceStatus::Unavailable("Need Checks".into()))
     }
 
-    pub fn config() -> Option<clash_verge_service_ipc::IpcConfig> {
+    pub const fn config() -> Option<clash_verge_service_ipc::IpcConfig> {
         Some(clash_verge_service_ipc::IpcConfig {
             default_timeout: Duration::from_millis(30),
             retry_delay: Duration::from_millis(250),
@@ -531,6 +532,7 @@ impl ServiceManager {
                 return Err(anyhow::anyhow!("服务不可用: {}", reason));
             }
         }
+        let _ = tray::Tray::global().update_menu().await;
         Ok(())
     }
 }

src-tauri/src/core/sysopt.rs

@@ -15,6 +15,7 @@ use sysproxy::{Autoproxy, Sysproxy};
 use tauri_plugin_autostart::ManagerExt;
 
 pub struct Sysopt {
+    initialed: AtomicBool,
     update_sysproxy: AtomicBool,
     reset_sysproxy: AtomicBool,
 }
@@ -30,12 +31,12 @@ static DEFAULT_BYPASS: &str = "127.0.0.1,192.168.0.0/16,10.0.0.0/8,172.16.0.0/12
 async fn get_bypass() -> String {
     let use_default = Config::verge()
         .await
-        .latest_ref()
+        .latest_arc()
         .use_default_bypass
         .unwrap_or(true);
     let res = {
         let verge = Config::verge().await;
-        let verge = verge.latest_ref();
+        let verge = verge.latest_arc();
         verge.system_proxy_bypass.clone()
     };
     let custom_bypass = match res {
@@ -83,7 +84,8 @@ async fn execute_sysproxy_command(args: Vec<std::string::String>) -> Result<()>
 
 impl Default for Sysopt {
     fn default() -> Self {
-        Sysopt {
+        Self {
+            initialed: AtomicBool::new(false),
             update_sysproxy: AtomicBool::new(false),
             reset_sysproxy: AtomicBool::new(false),
         }
@@ -94,17 +96,22 @@ impl Default for Sysopt {
 singleton_lazy!(Sysopt, SYSOPT, Sysopt::default);
 
 impl Sysopt {
+    pub fn is_initialed(&self) -> bool {
+        self.initialed.load(Ordering::SeqCst)
+    }
+
     pub fn init_guard_sysproxy(&self) -> Result<()> {
         // 使用事件驱动代理管理器
         let proxy_manager = EventDrivenProxyManager::global();
         proxy_manager.notify_app_started();
 
-        log::info!(target: "app", "已启用事件驱动代理守卫");
+        logging!(info, Type::Core, "已启用事件驱动代理守卫");
         Ok(())
     }
 
     /// init the sysproxy
     pub async fn update_sysproxy(&self) -> Result<()> {
+        self.initialed.store(true, Ordering::SeqCst);
         if self
             .update_sysproxy
             .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
@@ -117,17 +124,17 @@ impl Sysopt {
         }
 
         let port = {
-            let verge_port = Config::verge().await.latest_ref().verge_mixed_port;
+            let verge_port = Config::verge().await.latest_arc().verge_mixed_port;
             match verge_port {
                 Some(port) => port,
-                None => Config::clash().await.latest_ref().get_mixed_port(),
+                None => Config::clash().await.latest_arc().get_mixed_port(),
             }
         };
         let pac_port = IVerge::get_singleton_port();
 
         let (sys_enable, pac_enable, proxy_host) = {
             let verge = Config::verge().await;
-            let verge = verge.latest_ref();
+            let verge = verge.latest_arc();
             (
                 verge.enable_system_proxy.unwrap_or(false),
                 verge.proxy_auto_config.unwrap_or(false),
@@ -224,14 +231,22 @@ impl Sysopt {
             let mut sysproxy: Sysproxy = match Sysproxy::get_system_proxy() {
                 Ok(sp) => sp,
                 Err(e) => {
-                    log::warn!(target: "app", "重置代理时获取系统代理配置失败: {e}, 使用默认配置");
+                    logging!(
+                        warn,
+                        Type::Core,
+                        "Warning: 重置代理时获取系统代理配置失败: {e}, 使用默认配置"
+                    );
                     Sysproxy::default()
                 }
             };
             let mut autoproxy = match Autoproxy::get_auto_proxy() {
                 Ok(ap) => ap,
                 Err(e) => {
-                    log::warn!(target: "app", "重置代理时获取自动代理配置失败: {e}, 使用默认配置");
+                    logging!(
+                        warn,
+                        Type::Core,
+                        "Warning: 重置代理时获取自动代理配置失败: {e}, 使用默认配置"
+                    );
                     Autoproxy::default()
                 }
             };
@@ -251,7 +266,7 @@ impl Sysopt {
 
     /// update the startup
     pub async fn update_launch(&self) -> Result<()> {
-        let enable_auto_launch = { Config::verge().await.latest_ref().enable_auto_launch };
+        let enable_auto_launch = { Config::verge().await.latest_arc().enable_auto_launch };
         let is_enable = enable_auto_launch.unwrap_or(false);
         logging!(
             info,
@@ -265,14 +280,14 @@ impl Sysopt {
         {
             if is_enable {
                 if let Err(e) = startup_shortcut::create_shortcut().await {
-                    log::error!(target: "app", "创建启动快捷方式失败: {e}");
+                    logging!(error, Type::Setup, "创建启动快捷方式失败: {e}");
                     // 如果快捷方式创建失败，回退到原来的方法
                     self.try_original_autostart_method(is_enable);
                 } else {
                     return Ok(());
                 }
             } else if let Err(e) = startup_shortcut::remove_shortcut().await {
-                log::error!(target: "app", "删除启动快捷方式失败: {e}");
+                logging!(error, Type::Setup, "删除启动快捷方式失败: {e}");
                 self.try_original_autostart_method(is_enable);
             } else {
                 return Ok(());
@@ -307,11 +322,11 @@ impl Sysopt {
         {
             match startup_shortcut::is_shortcut_enabled() {
                 Ok(enabled) => {
-                    log::info!(target: "app", "快捷方式自启动状态: {enabled}");
+                    logging!(info, Type::System, "快捷方式自启动状态: {enabled}");
                     return Ok(enabled);
                 }
                 Err(e) => {
-                    log::error!(target: "app", "检查快捷方式失败，尝试原来的方法: {e}");
+                    logging!(error, Type::System, "检查快捷方式失败，尝试原来的方法: {e}");
                 }
             }
         }
@@ -322,11 +337,11 @@ impl Sysopt {
 
         match autostart_manager.is_enabled() {
             Ok(status) => {
-                log::info!(target: "app", "Auto launch status: {status}");
+                logging!(info, Type::System, "Auto launch status: {status}");
                 Ok(status)
             }
             Err(e) => {
-                log::error!(target: "app", "Failed to get auto launch status: {e}");
+                logging!(error, Type::System, "Failed to get auto launch status: {e}");
                 Err(anyhow::anyhow!("Failed to get auto launch status: {}", e))
             }
         }

src-tauri/src/core/timer.rs

@@ -1,4 +1,7 @@
-use crate::{config::Config, feat, logging, logging_error, singleton, utils::logging::Type};
+use crate::{
+    config::Config, core::sysopt::Sysopt, feat, logging, logging_error, singleton,
+    utils::logging::Type,
+};
 use anyhow::{Context, Result};
 use delay_timer::prelude::{DelayTimer, DelayTimerBuilder, TaskBuilder};
 use parking_lot::RwLock;
@@ -10,7 +13,9 @@ use std::{
         Arc,
         atomic::{AtomicBool, AtomicU64, Ordering},
     },
+    time::Duration,
 };
+use tokio::time::{sleep, timeout};
 
 type TaskID = u64;
 
@@ -41,7 +46,7 @@ singleton!(Timer, TIMER_INSTANCE);
 
 impl Timer {
     fn new() -> Self {
-        Timer {
+        Self {
             delay_timer: Arc::new(RwLock::new(DelayTimerBuilder::default().build())),
             timer_map: Arc::new(RwLock::new(HashMap::new())),
             timer_count: AtomicU64::new(1),
@@ -95,10 +100,16 @@ impl Timer {
 
         // Collect profiles that need immediate update
         let profiles_to_update =
-            if let Some(items) = Config::profiles().await.latest_ref().get_items() {
+            if let Some(items) = Config::profiles().await.latest_arc().get_items() {
                 items
                     .iter()
                     .filter_map(|item| {
+                        let allow_auto_update =
+                            item.option.as_ref()?.allow_auto_update.unwrap_or_default();
+                        if !allow_auto_update {
+                            return None;
+                        }
+
                         let interval = item.option.as_ref()?.update_interval? as i64;
                         let updated = item.updated? as i64;
                         let uid = item.uid.as_ref()?;
@@ -143,19 +154,17 @@ impl Timer {
     /// 每 3 秒更新系统托盘菜单，总共执行 3 次
     pub fn add_update_tray_menu_task(&self) -> Result<()> {
         let tid = self.timer_count.fetch_add(1, Ordering::SeqCst);
-        let delay_timer = self.delay_timer.write();
         let task = TaskBuilder::default()
             .set_task_id(tid)
             .set_maximum_parallel_runnable_num(1)
             .set_frequency_count_down_by_seconds(3, 3)
             .spawn_async_routine(|| async move {
-                logging!(info, Type::Timer, "Updating tray menu");
-                crate::core::tray::Tray::global()
-                    .update_tray_display()
-                    .await
+                logging!(debug, Type::Timer, "Updating tray menu");
+                crate::core::tray::Tray::global().update_menu().await
             })
             .context("failed to create update tray menu timer task")?;
-        delay_timer
+        self.delay_timer
+            .write()
             .add_task(task)
             .context("failed to add update tray menu timer task")?;
         Ok(())
@@ -184,14 +193,12 @@ impl Timer {
 
         // Perform sync operations while holding locks
         {
-            let mut timer_map = self.timer_map.write();
-            let delay_timer = self.delay_timer.write();
-
             for (uid, diff) in diff_map {
                 match diff {
                     DiffFlag::Del(tid) => {
-                        timer_map.remove(&uid);
-                        if let Err(e) = delay_timer.remove_task(tid) {
+                        self.timer_map.write().remove(&uid);
+                        let value = self.delay_timer.write().remove_task(tid);
+                        if let Err(e) = value {
                             logging!(
                                 warn,
                                 Type::Timer,
@@ -211,12 +218,13 @@ impl Timer {
                             last_run: chrono::Local::now().timestamp(),
                         };
 
-                        timer_map.insert(uid.clone(), task);
+                        self.timer_map.write().insert(uid.clone(), task);
                         operations_to_add.push((uid, tid, interval));
                     }
                     DiffFlag::Mod(tid, interval) => {
                         // Remove old task first
-                        if let Err(e) = delay_timer.remove_task(tid) {
+                        let value = self.delay_timer.write().remove_task(tid);
+                        if let Err(e) = value {
                             logging!(
                                 warn,
                                 Type::Timer,
@@ -234,7 +242,7 @@ impl Timer {
                             last_run: chrono::Local::now().timestamp(),
                         };
 
-                        timer_map.insert(uid.clone(), task);
+                        self.timer_map.write().insert(uid.clone(), task);
                         operations_to_add.push((uid, tid, interval));
                     }
                 }
@@ -244,8 +252,8 @@ impl Timer {
         // Now perform async operations without holding locks
         for (uid, tid, interval) in operations_to_add {
             // Re-acquire locks for individual operations
-            let mut delay_timer = self.delay_timer.write();
-            if let Err(e) = self.add_task(&mut delay_timer, uid.clone(), tid, interval) {
+            let delay_timer = self.delay_timer.write();
+            if let Err(e) = self.add_task(&delay_timer, uid.clone(), tid, interval) {
                 logging_error!(Type::Timer, "Failed to add task for uid {}: {}", uid, e);
 
                 // Rollback on failure - remove from timer_map
@@ -262,7 +270,7 @@ impl Timer {
     async fn gen_map(&self) -> HashMap<String, u64> {
         let mut new_map = HashMap::new();
 
-        if let Some(items) = Config::profiles().await.latest_ref().get_items() {
+        if let Some(items) = Config::profiles().await.latest_arc().get_items() {
             for item in items.iter() {
                 if let Some(option) = item.option.as_ref()
                     && let Some(allow_auto_update) = option.allow_auto_update
@@ -362,7 +370,7 @@ impl Timer {
     /// Add a timer task with better error handling
     fn add_task(
         &self,
-        delay_timer: &mut DelayTimer,
+        delay_timer: &DelayTimer,
         uid: String,
         tid: TaskID,
         minutes: u64,
@@ -384,7 +392,8 @@ impl Timer {
             .spawn_async_routine(move || {
                 let uid = uid.clone();
                 Box::pin(async move {
-                    Self::async_task(uid).await;
+                    Self::wait_until_sysopt(Duration::from_millis(1000)).await;
+                    Self::async_task(&uid).await;
                 }) as Pin<Box<dyn std::future::Future<Output = ()> + Send>>
             })
             .context("failed to create timer task")?;
@@ -413,13 +422,15 @@ impl Timer {
         };
 
         // Get the profile updated timestamp - now safe to await
-        let config_profiles = Config::profiles().await;
-        let profiles = config_profiles.data_ref().clone();
-        let items = match profiles.get_items() {
-            Some(i) => i,
-            None => {
-                logging!(warn, Type::Timer, "获取配置列表失败");
-                return None;
+        let items = {
+            let profiles = Config::profiles().await;
+            let profiles_guard = profiles.latest_arc();
+            match profiles_guard.get_items() {
+                Some(i) => i.clone(),
+                None => {
+                    logging!(warn, Type::Timer, "获取配置列表失败");
+                    return None;
+                }
             }
         };
 
@@ -468,14 +479,14 @@ impl Timer {
     }
 
     /// Async task with better error handling and logging
-    async fn async_task(uid: String) {
+    async fn async_task(uid: &String) {
         let task_start = std::time::Instant::now();
         logging!(info, Type::Timer, "Running timer task for profile: {}", uid);
 
         match tokio::time::timeout(std::time::Duration::from_secs(40), async {
-            Self::emit_update_event(&uid, true);
+            Self::emit_update_event(uid, true);
 
-            let is_current = Config::profiles().await.latest_ref().current.as_ref() == Some(&uid);
+            let is_current = Config::profiles().await.latest_arc().current.as_ref() == Some(uid);
             logging!(
                 info,
                 Type::Timer,
@@ -484,7 +495,7 @@ impl Timer {
                 is_current
             );
 
-            feat::update_profile(uid.clone(), None, Some(is_current)).await
+            feat::update_profile(uid, None, is_current, false).await
         })
         .await
         {
@@ -509,7 +520,17 @@ impl Timer {
         }
 
         // Emit completed event
-        Self::emit_update_event(&uid, false);
+        Self::emit_update_event(uid, false);
+    }
+
+    async fn wait_until_sysopt(max_wait: Duration) {
+        let _ = timeout(max_wait, async {
+            while !Sysopt::global().is_initialed() {
+                logging!(warn, Type::Timer, "Waiting for Sysopt to be initialized...");
+                sleep(Duration::from_millis(30)).await;
+            }
+        })
+        .await;
     }
 }
 

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

@@ -39,6 +39,8 @@ define_menu! {
     core_dir => CORE_DIR, "tray_core_dir", "Core Dir",
     logs_dir => LOGS_DIR, "tray_logs_dir", "Logs Dir",
     open_dir => OPEN_DIR, "tray_open_dir", "Open Dir",
+    app_log => APP_LOG, "tray_app_log", "Open App Log",
+    core_log => CORE_LOG, "tray_core_log", "Open Core Log",
     restart_clash => RESTART_CLASH, "tray_restart_clash", "Restart Clash Core",
     restart_app => RESTART_APP, "tray_restart_app", "Restart App",
     verge_version => VERGE_VERSION, "tray_verge_version", "Verge Version",

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

@@ -1,10 +1,11 @@
 use once_cell::sync::OnceCell;
-use tauri::Emitter;
 use tauri::tray::TrayIconBuilder;
 use tauri_plugin_mihomo::models::Proxies;
+use tokio::fs;
 #[cfg(target_os = "macos")]
 pub mod speed_rate;
 use crate::config::PrfSelected;
+use crate::core::service;
 use crate::module::lightweight;
 use crate::process::AsyncHandler;
 use crate::utils::window_manager::WindowManager;
@@ -23,9 +24,10 @@ use futures::future::join_all;
 use parking_lot::Mutex;
 use smartstring::alias::String;
 use std::collections::HashMap;
+use std::future::Future;
+use std::pin::Pin;
 use std::sync::Arc;
 use std::{
-    fs,
     sync::atomic::{AtomicBool, Ordering},
     time::{Duration, Instant},
 };
@@ -54,15 +56,18 @@ fn get_tray_click_debounce() -> &'static Mutex<Instant> {
 
 fn should_handle_tray_click() -> bool {
     let debounce_lock = get_tray_click_debounce();
-    let mut last_click = debounce_lock.lock();
     let now = Instant::now();
 
-    if now.duration_since(*last_click) >= Duration::from_millis(TRAY_CLICK_DEBOUNCE_MS) {
-        *last_click = now;
+    if now.duration_since(*debounce_lock.lock()) >= Duration::from_millis(TRAY_CLICK_DEBOUNCE_MS) {
+        *debounce_lock.lock() = now;
         true
     } else {
-        log::debug!(target: "app", "托盘点击被防抖机制忽略，距离上次点击 {:?}ms",
-                  now.duration_since(*last_click).as_millis());
+        logging!(
+            debug,
+            Type::Tray,
+            "托盘点击被防抖机制忽略，距离上次点击 {}ms",
+            now.duration_since(*debounce_lock.lock()).as_millis()
+        );
         false
     }
 }
@@ -81,11 +86,11 @@ pub struct Tray {
 
 impl TrayState {
     pub async fn get_common_tray_icon() -> (bool, Vec<u8>) {
-        let verge = Config::verge().await.latest_ref().clone();
+        let verge = Config::verge().await.latest_arc();
         let is_common_tray_icon = verge.common_tray_icon.unwrap_or(false);
         if is_common_tray_icon
             && let Ok(Some(common_icon_path)) = find_target_icons("common")
-            && let Ok(icon_data) = fs::read(common_icon_path)
+            && let Ok(icon_data) = fs::read(common_icon_path).await
         {
             return (true, icon_data);
         }
@@ -118,11 +123,11 @@ impl TrayState {
     }
 
     pub async fn get_sysproxy_tray_icon() -> (bool, Vec<u8>) {
-        let verge = Config::verge().await.latest_ref().clone();
+        let verge = Config::verge().await.latest_arc();
         let is_sysproxy_tray_icon = verge.sysproxy_tray_icon.unwrap_or(false);
         if is_sysproxy_tray_icon
             && let Ok(Some(sysproxy_icon_path)) = find_target_icons("sysproxy")
-            && let Ok(icon_data) = fs::read(sysproxy_icon_path)
+            && let Ok(icon_data) = fs::read(sysproxy_icon_path).await
         {
             return (true, icon_data);
         }
@@ -155,11 +160,11 @@ impl TrayState {
     }
 
     pub async fn get_tun_tray_icon() -> (bool, Vec<u8>) {
-        let verge = Config::verge().await.latest_ref().clone();
+        let verge = Config::verge().await.latest_arc();
         let is_tun_tray_icon = verge.tun_tray_icon.unwrap_or(false);
         if is_tun_tray_icon
             && let Ok(Some(tun_icon_path)) = find_target_icons("tun")
-            && let Ok(icon_data) = fs::read(tun_icon_path)
+            && let Ok(icon_data) = fs::read(tun_icon_path).await
         {
             return (true, icon_data);
         }
@@ -193,7 +198,7 @@ impl TrayState {
 
 impl Default for Tray {
     fn default() -> Self {
-        Tray {
+        Self {
             last_menu_update: Mutex::new(None),
             menu_updating: AtomicBool::new(false),
         }
@@ -206,7 +211,7 @@ singleton_lazy!(Tray, TRAY, Tray::default);
 impl Tray {
     pub async fn init(&self) -> Result<()> {
         if handle::Handle::global().is_exiting() {
-            log::debug!(target: "app", "应用正在退出，跳过托盘初始化");
+            logging!(debug, Type::Tray, "应用正在退出，跳过托盘初始化");
             return Ok(());
         }
 
@@ -214,11 +219,15 @@ impl Tray {
 
         match self.create_tray_from_handle(app_handle).await {
             Ok(_) => {
-                log::info!(target: "app", "System tray created successfully");
+                logging!(info, Type::Tray, "System tray created successfully");
             }
             Err(e) => {
                 // Don't return error, let application continue running without tray
-                log::warn!(target: "app", "System tray creation failed: {}, Application will continue running without tray icon", e);
+                logging!(
+                    warn,
+                    Type::Tray,
+                    "System tray creation failed: {e}, Application will continue running without tray icon",
+                );
             }
         }
         // TODO: 初始化时，暂时使用此方法更新系统托盘菜单，有效避免代理节点菜单空白
@@ -229,12 +238,12 @@ impl Tray {
     /// 更新托盘点击行为
     pub async fn update_click_behavior(&self) -> Result<()> {
         if handle::Handle::global().is_exiting() {
-            log::debug!(target: "app", "应用正在退出，跳过托盘点击行为更新");
+            logging!(debug, Type::Tray, "应用正在退出，跳过托盘点击行为更新");
             return Ok(());
         }
 
         let app_handle = handle::Handle::app_handle();
-        let tray_event = { Config::verge().await.latest_ref().tray_event.clone() };
+        let tray_event = { Config::verge().await.latest_arc().tray_event.clone() };
         let tray_event = tray_event.unwrap_or_else(|| "main_window".into());
         let tray = app_handle
             .tray_by_id("main")
@@ -249,7 +258,7 @@ impl Tray {
     /// 更新托盘菜单
     pub async fn update_menu(&self) -> Result<()> {
         if handle::Handle::global().is_exiting() {
-            log::debug!(target: "app", "应用正在退出，跳过托盘菜单更新");
+            logging!(debug, Type::Tray, "应用正在退出，跳过托盘菜单更新");
             return Ok(());
         }
         // 调整最小更新间隔，确保状态及时刷新
@@ -294,24 +303,24 @@ impl Tray {
     }
 
     async fn update_menu_internal(&self, app_handle: &AppHandle) -> Result<()> {
-        let verge = Config::verge().await.latest_ref().clone();
+        let verge = Config::verge().await.latest_arc();
         let system_proxy = verge.enable_system_proxy.as_ref().unwrap_or(&false);
         let tun_mode = verge.enable_tun_mode.as_ref().unwrap_or(&false);
+        let tun_mode_available = cmd::system::is_admin().unwrap_or_default()
+            || service::is_service_available().await.is_ok();
         let mode = {
             Config::clash()
                 .await
-                .latest_ref()
+                .latest_arc()
                 .0
                 .get("mode")
                 .map(|val| val.as_str().unwrap_or("rule"))
                 .unwrap_or("rule")
                 .to_owned()
         };
-        let profile_uid_and_name = Config::profiles()
-            .await
-            .data_mut()
-            .all_profile_uid_and_name()
-            .unwrap_or_default();
+        let profiles_config = Config::profiles().await;
+        let profiles_arc = profiles_config.latest_arc();
+        let profile_uid_and_name = profiles_arc.all_profile_uid_and_name().unwrap_or_default();
         let is_lightweight_mode = is_in_lightweight_mode();
 
         match app_handle.tray_by_id("main") {
@@ -322,16 +331,21 @@ impl Tray {
                         Some(mode.as_str()),
                         *system_proxy,
                         *tun_mode,
+                        tun_mode_available,
                         profile_uid_and_name,
                         is_lightweight_mode,
                     )
                     .await?,
                 ));
-                log::debug!(target: "app", "托盘菜单更新成功");
+                logging!(debug, Type::Tray, "托盘菜单更新成功");
                 Ok(())
             }
             None => {
-                log::warn!(target: "app", "更新托盘菜单失败: 托盘不存在");
+                logging!(
+                    warn,
+                    Type::Tray,
+                    "Failed to update tray menu: tray not found"
+                );
                 Ok(())
             }
         }
@@ -341,7 +355,7 @@ impl Tray {
     #[cfg(target_os = "macos")]
     pub async fn update_icon(&self) -> Result<()> {
         if handle::Handle::global().is_exiting() {
-            log::debug!(target: "app", "应用正在退出，跳过托盘图标更新");
+            logging!(debug, Type::Tray, "应用正在退出，跳过托盘图标更新");
             return Ok(());
         }
 
@@ -350,12 +364,16 @@ impl Tray {
         let tray = match app_handle.tray_by_id("main") {
             Some(tray) => tray,
             None => {
-                log::warn!(target: "app", "更新托盘图标失败: 托盘不存在");
+                logging!(
+                    warn,
+                    Type::Tray,
+                    "Failed to update tray icon: tray not found"
+                );
                 return Ok(());
             }
         };
 
-        let verge = Config::verge().await.latest_ref().clone();
+        let verge = Config::verge().await.latest_arc();
         let system_mode = verge.enable_system_proxy.as_ref().unwrap_or(&false);
         let tun_mode = verge.enable_tun_mode.as_ref().unwrap_or(&false);
 
@@ -380,7 +398,7 @@ impl Tray {
     #[cfg(not(target_os = "macos"))]
     pub async fn update_icon(&self) -> Result<()> {
         if handle::Handle::global().is_exiting() {
-            log::debug!(target: "app", "应用正在退出，跳过托盘图标更新");
+            logging!(debug, Type::Tray, "应用正在退出，跳过托盘图标更新");
             return Ok(());
         }
 
@@ -389,12 +407,16 @@ impl Tray {
         let tray = match app_handle.tray_by_id("main") {
             Some(tray) => tray,
             None => {
-                log::warn!(target: "app", "更新托盘图标失败: 托盘不存在");
+                logging!(
+                    warn,
+                    Type::Tray,
+                    "Failed to update tray icon: tray not found"
+                );
                 return Ok(());
             }
         };
 
-        let verge = Config::verge().await.latest_ref().clone();
+        let verge = Config::verge().await.latest_arc();
         let system_mode = verge.enable_system_proxy.as_ref().unwrap_or(&false);
         let tun_mode = verge.enable_tun_mode.as_ref().unwrap_or(&false);
 
@@ -409,34 +431,16 @@ impl Tray {
         Ok(())
     }
 
-    /// 更新托盘显示状态的函数
-    pub async fn update_tray_display(&self) -> Result<()> {
-        if handle::Handle::global().is_exiting() {
-            log::debug!(target: "app", "应用正在退出，跳过托盘显示状态更新");
-            return Ok(());
-        }
-
-        let app_handle = handle::Handle::app_handle();
-        let _tray = app_handle
-            .tray_by_id("main")
-            .ok_or_else(|| anyhow::anyhow!("Failed to get main tray"))?;
-
-        // 更新菜单
-        self.update_menu().await?;
-
-        Ok(())
-    }
-
     /// 更新托盘提示
     pub async fn update_tooltip(&self) -> Result<()> {
         if handle::Handle::global().is_exiting() {
-            log::debug!(target: "app", "应用正在退出，跳过托盘提示更新");
+            logging!(debug, Type::Tray, "应用正在退出，跳过托盘提示更新");
             return Ok(());
         }
 
         let app_handle = handle::Handle::app_handle();
 
-        let verge = Config::verge().await.latest_ref().clone();
+        let verge = Config::verge().await.latest_arc();
         let system_proxy = verge.enable_system_proxy.as_ref().unwrap_or(&false);
         let tun_mode = verge.enable_tun_mode.as_ref().unwrap_or(&false);
 
@@ -450,9 +454,9 @@ impl Tray {
         let mut current_profile_name = "None".into();
         {
             let profiles = Config::profiles().await;
-            let profiles = profiles.latest_ref();
+            let profiles = profiles.latest_arc();
             if let Some(current_profile_uid) = profiles.get_current()
-                && let Ok(profile) = profiles.get_item(&current_profile_uid)
+                && let Ok(profile) = profiles.get_item(current_profile_uid)
             {
                 current_profile_name = match &profile.name {
                     Some(profile_name) => profile_name.to_string(),
@@ -486,7 +490,11 @@ impl Tray {
         if let Some(tray) = app_handle.tray_by_id("main") {
             let _ = tray.set_tooltip(Some(&tooltip));
         } else {
-            log::warn!(target: "app", "更新托盘提示失败: 托盘不存在");
+            logging!(
+                warn,
+                Type::Tray,
+                "Failed to update tray tooltip: tray not found"
+            );
         }
 
         Ok(())
@@ -494,12 +502,10 @@ impl Tray {
 
     pub async fn update_part(&self) -> Result<()> {
         if handle::Handle::global().is_exiting() {
-            log::debug!(target: "app", "应用正在退出，跳过托盘局部更新");
+            logging!(debug, Type::Tray, "应用正在退出，跳过托盘局部更新");
             return Ok(());
         }
-        // self.update_menu().await?;
-        // 更新轻量模式显示状态
-        self.update_tray_display().await?;
+        self.update_menu().await?;
         self.update_icon().await?;
         self.update_tooltip().await?;
         Ok(())
@@ -507,11 +513,11 @@ impl Tray {
 
     pub async fn create_tray_from_handle(&self, app_handle: &AppHandle) -> Result<()> {
         if handle::Handle::global().is_exiting() {
-            log::debug!(target: "app", "应用正在退出，跳过托盘创建");
+            logging!(debug, Type::Tray, "应用正在退出，跳过托盘创建");
             return Ok(());
         }
 
-        log::info!(target: "app", "正在从AppHandle创建系统托盘");
+        logging!(info, Type::Tray, "正在从AppHandle创建系统托盘");
 
         // 获取图标
         let icon_bytes = TrayState::get_common_tray_icon().await.1;
@@ -524,7 +530,7 @@ impl Tray {
 
         #[cfg(any(target_os = "macos", target_os = "windows"))]
         let show_menu_on_left_click = {
-            let tray_event = { Config::verge().await.latest_ref().tray_event.clone() };
+            let tray_event = { Config::verge().await.latest_arc().tray_event.clone() };
             let tray_event: String = tray_event.unwrap_or_else(|| "main_window".into());
             tray_event.as_str() == "tray_menu"
         };
@@ -555,9 +561,9 @@ impl Tray {
             }
 
             AsyncHandler::spawn(|| async move {
-                let tray_event = { Config::verge().await.latest_ref().tray_event.clone() };
+                let tray_event = { Config::verge().await.latest_arc().tray_event.clone() };
                 let tray_event: String = tray_event.unwrap_or_else(|| "main_window".into());
-                log::debug!(target: "app", "tray event: {tray_event:?}");
+                logging!(debug, Type::Tray, "tray event: {tray_event:?}");
 
                 if let TrayIconEvent::Click {
                     button: MouseButton::Left,
@@ -570,9 +576,6 @@ impl Tray {
                         return;
                     }
 
-                    use std::future::Future;
-                    use std::pin::Pin;
-
                     let fut: Pin<Box<dyn Future<Output = ()> + Send>> = match tray_event.as_str() {
                         "system_proxy" => Box::pin(async move {
                             feat::toggle_system_proxy().await;
@@ -592,23 +595,6 @@ impl Tray {
             });
         });
         tray.on_menu_event(on_menu_event);
-        log::info!(target: "app", "系统托盘创建成功");
-        Ok(())
-    }
-
-    // 托盘统一的状态更新函数
-    pub async fn update_all_states(&self) -> Result<()> {
-        if handle::Handle::global().is_exiting() {
-            log::debug!(target: "app", "应用正在退出，跳过托盘状态更新");
-            return Ok(());
-        }
-
-        // 确保所有状态更新完成
-        self.update_tray_display().await?;
-        // self.update_menu().await?;
-        self.update_icon().await?;
-        self.update_tooltip().await?;
-
         Ok(())
     }
 }
@@ -639,23 +625,21 @@ fn create_hotkeys(hotkeys: &Option<Vec<String>>) -> HashMap<String, String> {
 
 async fn create_profile_menu_item(
     app_handle: &AppHandle,
-    profile_uid_and_name: Vec<(String, String)>,
+    profile_uid_and_name: Vec<(&String, &String)>,
 ) -> Result<Vec<CheckMenuItem<Wry>>> {
     let futures = profile_uid_and_name
         .iter()
         .map(|(profile_uid, profile_name)| {
             let app_handle = app_handle.clone();
-            let profile_uid = profile_uid.clone();
-            let profile_name = profile_name.clone();
             async move {
                 let is_current_profile = Config::profiles()
                     .await
-                    .latest_ref()
-                    .is_current_profile_index(profile_uid.clone());
+                    .latest_arc()
+                    .is_current_profile_index(profile_uid);
                 CheckMenuItem::with_id(
                     &app_handle,
                     format!("profiles_{profile_uid}"),
-                    t(&profile_name).await,
+                    t(profile_name).await,
                     true,
                     is_current_profile,
                     None::<&str>,
@@ -726,7 +710,9 @@ fn create_subcreate_proxy_menu_item(
                             is_selected,
                             None::<&str>,
                         )
-                        .map_err(|e| log::warn!(target: "app", "创建代理菜单项失败: {}", e))
+                        .map_err(|e| {
+                            logging!(warn, Type::Tray, "Failed to create proxy menu item: {}", e)
+                        })
                         .ok()
                     })
                     .collect();
@@ -768,7 +754,12 @@ fn create_subcreate_proxy_menu_item(
                     let insertion_index = submenus.len();
                     submenus.push((group_name.into(), insertion_index, submenu));
                 } else {
-                    log::warn!(target: "app", "创建代理组子菜单失败: {}", group_name);
+                    logging!(
+                        warn,
+                        Type::Tray,
+                        "Failed to create proxy group submenu: {}",
+                        group_name
+                    );
                 }
             }
         }
@@ -837,7 +828,8 @@ async fn create_tray_menu(
     mode: Option<&str>,
     system_proxy_enabled: bool,
     tun_mode_enabled: bool,
-    profile_uid_and_name: Vec<(String, String)>,
+    tun_mode_available: bool,
+    profile_uid_and_name: Vec<(&String, &String)>,
     is_lightweight_mode: bool,
 ) -> Result<tauri::menu::Menu<Wry>> {
     let current_proxy_mode = mode.unwrap_or("");
@@ -845,10 +837,10 @@ async fn create_tray_menu(
     // 获取当前配置文件的选中代理组信息
     let current_profile_selected = {
         let profiles_config = Config::profiles().await;
-        let profiles_ref = profiles_config.latest_ref();
+        let profiles_ref = profiles_config.latest_arc();
         profiles_ref
             .get_current()
-            .and_then(|uid| profiles_ref.get_item(&uid).ok())
+            .and_then(|uid| profiles_ref.get_item(uid).ok())
             .and_then(|profile| profile.selected.clone())
             .unwrap_or_default()
     };
@@ -891,7 +883,7 @@ async fn create_tray_menu(
             .collect::<HashMap<String, usize>>()
     });
 
-    let verge_settings = Config::verge().await.latest_ref().clone();
+    let verge_settings = Config::verge().await.latest_arc();
     let show_proxy_groups_inline = verge_settings.tray_inline_proxy_groups.unwrap_or(false);
 
     let version = env!("CARGO_PKG_VERSION");
@@ -980,7 +972,7 @@ async fn create_tray_menu(
         app_handle,
         MenuIds::TUN_MODE,
         &texts.tun_mode,
-        true,
+        tun_mode_available,
         tun_mode_enabled,
         hotkeys.get("toggle_tun_mode").map(|s| s.as_str()),
     )?;
@@ -1034,12 +1026,34 @@ async fn create_tray_menu(
         None::<&str>,
     )?;
 
+    let open_app_log = &MenuItem::with_id(
+        app_handle,
+        MenuIds::APP_LOG,
+        &texts.app_log,
+        true,
+        None::<&str>,
+    )?;
+
+    let open_core_log = &MenuItem::with_id(
+        app_handle,
+        MenuIds::CORE_LOG,
+        &texts.core_log,
+        true,
+        None::<&str>,
+    )?;
+
     let open_dir = &Submenu::with_id_and_items(
         app_handle,
         MenuIds::OPEN_DIR,
         &texts.open_dir,
         true,
-        &[open_app_dir, open_core_dir, open_logs_dir],
+        &[
+            open_app_dir,
+            open_core_dir,
+            open_logs_dir,
+            open_app_log,
+            open_core_log,
+        ],
     )?;
 
     let restart_clash = &MenuItem::with_id(
@@ -1138,7 +1152,7 @@ fn on_menu_event(_: &AppHandle, event: MenuEvent) {
                 feat::change_clash_mode(mode.into()).await;
             }
             MenuIds::DASHBOARD => {
-                log::info!(target: "app", "托盘菜单点击: 打开窗口");
+                logging!(info, Type::Tray, "托盘菜单点击: 打开窗口");
 
                 if !should_handle_tray_click() {
                     return;
@@ -1155,7 +1169,11 @@ fn on_menu_event(_: &AppHandle, event: MenuEvent) {
             }
             MenuIds::CLOSE_ALL_CONNECTIONS => {
                 if let Err(err) = handle::Handle::mihomo().await.close_all_connections().await {
-                    log::error!(target: "app", "Failed to close all connections from tray: {err}");
+                    logging!(
+                        error,
+                        Type::Tray,
+                        "Failed to close all connections from tray: {err}"
+                    );
                 }
             }
             MenuIds::COPY_ENV => feat::copy_clash_env().await,
@@ -1169,6 +1187,12 @@ fn on_menu_event(_: &AppHandle, event: MenuEvent) {
             MenuIds::LOGS_DIR => {
                 let _ = cmd::open_logs_dir().await;
             }
+            MenuIds::APP_LOG => {
+                let _ = cmd::open_app_log().await;
+            }
+            MenuIds::CORE_LOG => {
+                let _ = cmd::open_core_log().await;
+            }
             MenuIds::RESTART_CLASH => feat::restart_clash_core().await,
             MenuIds::RESTART_APP => feat::restart_app().await,
             MenuIds::LIGHTWEIGHT_MODE => {
@@ -1190,47 +1214,27 @@ fn on_menu_event(_: &AppHandle, event: MenuEvent) {
             }
             id if id.starts_with("proxy_") => {
                 // proxy_{group_name}_{proxy_name}
-                let parts: Vec<&str> = id.splitn(3, '_').collect();
-
-                if parts.len() == 3 && parts[0] == "proxy" {
-                    let group_name = parts[1];
-                    let proxy_name = parts[2];
-
-                    match handle::Handle::mihomo()
-                        .await
-                        .select_node_for_group(group_name, proxy_name)
-                        .await
-                    {
-                        Ok(_) => {
-                            log::info!(target: "app", "切换代理成功: {} -> {}", group_name, proxy_name);
-                            let _ = handle::Handle::app_handle()
-                                .emit("verge://refresh-proxy-config", ());
-                        }
-                        Err(e) => {
-                            log::error!(target: "app", "切换代理失败: {} -> {}, 错误: {:?}", group_name, proxy_name, e);
-
-                            // Fallback to IPC update
-                            if (handle::Handle::mihomo()
-                                .await
-                                .select_node_for_group(group_name, proxy_name)
-                                .await)
-                                .is_ok()
-                            {
-                                log::info!(target: "app", "代理切换回退成功: {} -> {}", group_name, proxy_name);
-
-                                let app_handle = handle::Handle::app_handle();
-                                let _ = app_handle.emit("verge://force-refresh-proxies", ());
-                            }
-                        }
-                    }
-                }
+                let rest = match id.strip_prefix("proxy_") {
+                    Some(r) => r,
+                    None => return,
+                };
+                let (group_name, proxy_name) = match rest.split_once('_') {
+                    Some((g, p)) => (g, p),
+                    None => return,
+                };
+                feat::switch_proxy_node(group_name, proxy_name).await;
+            }
+            _ => {
+                logging!(
+                    debug,
+                    Type::Tray,
+                    "Unhandled tray menu event: {:?}",
+                    event.id
+                );
             }
-            _ => {}
         }
 
-        // Ensure tray state update is awaited and properly handled
-        if let Err(e) = Tray::global().update_all_states().await {
-            log::warn!(target: "app", "更新托盘状态失败: {e}");
-        }
+        // We dont expected to refresh tray state here
+        // as the inner handle function (SHOULD) already takes care of it
     });
 }

src-tauri/src/core/validate.rs

@@ -1,9 +1,9 @@
 use anyhow::Result;
 use scopeguard::defer;
 use smartstring::alias::String;
-use std::path::Path;
 use std::sync::atomic::{AtomicBool, Ordering};
 use tauri_plugin_shell::ShellExt;
+use tokio::fs;
 
 use crate::config::{Config, ConfigType};
 use crate::core::handle;
@@ -16,7 +16,7 @@ pub struct CoreConfigValidator {
 }
 
 impl CoreConfigValidator {
-    pub fn new() -> Self {
+    pub const fn new() -> Self {
         Self {
             is_processing: AtomicBool::new(false),
         }
@@ -33,19 +33,16 @@ impl CoreConfigValidator {
 
 impl CoreConfigValidator {
     /// 检查文件是否为脚本文件
-    fn is_script_file<P>(path: P) -> Result<bool>
-    where
-        P: AsRef<Path> + std::fmt::Display,
-    {
+    async fn is_script_file(path: &str) -> Result<bool> {
         // 1. 先通过扩展名快速判断
-        if has_ext(&path, "yaml") || has_ext(&path, "yml") {
+        if has_ext(path, "yaml") || has_ext(path, "yml") {
             return Ok(false); // YAML文件不是脚本文件
-        } else if has_ext(&path, "js") {
+        } else if has_ext(path, "js") {
             return Ok(true); // JS文件是脚本文件
         }
 
         // 2. 读取文件内容
-        let content = match std::fs::read_to_string(&path) {
+        let content = match fs::read_to_string(path).await {
             Ok(content) => content,
             Err(err) => {
                 logging!(
@@ -115,11 +112,11 @@ impl CoreConfigValidator {
     }
 
     /// 只进行文件语法检查，不进行完整验证
-    fn validate_file_syntax(config_path: &str) -> Result<(bool, String)> {
+    async fn validate_file_syntax(config_path: &str) -> Result<(bool, String)> {
         logging!(info, Type::Validate, "开始检查文件: {}", config_path);
 
         // 读取文件内容
-        let content = match std::fs::read_to_string(config_path) {
+        let content = match fs::read_to_string(config_path).await {
             Ok(content) => content,
             Err(err) => {
                 let error_msg = format!("Failed to read file: {err}").into();
@@ -144,9 +141,9 @@ impl CoreConfigValidator {
     }
 
     /// 验证脚本文件语法
-    fn validate_script_file(path: &str) -> Result<(bool, String)> {
+    async fn validate_script_file(path: &str) -> Result<(bool, String)> {
         // 读取脚本内容
-        let content = match std::fs::read_to_string(path) {
+        let content = match fs::read_to_string(path).await {
             Ok(content) => content,
             Err(err) => {
                 let error_msg = format!("Failed to read script file: {err}").into();
@@ -216,14 +213,14 @@ impl CoreConfigValidator {
                 "检测到Merge文件，仅进行语法检查: {}",
                 config_path
             );
-            return Self::validate_file_syntax(config_path);
+            return Self::validate_file_syntax(config_path).await;
         }
 
         // 检查是否为脚本文件
         let is_script = if config_path.ends_with(".js") {
             true
         } else {
-            match Self::is_script_file(config_path) {
+            match Self::is_script_file(config_path).await {
                 Ok(result) => result,
                 Err(err) => {
                     // 如果无法确定文件类型，尝试使用Clash内核验证
@@ -246,7 +243,7 @@ impl CoreConfigValidator {
                 "检测到脚本文件，使用JavaScript验证: {}",
                 config_path
             );
-            return Self::validate_script_file(config_path);
+            return Self::validate_script_file(config_path).await;
         }
 
         // 对YAML配置文件使用Clash内核验证
@@ -269,7 +266,7 @@ impl CoreConfigValidator {
 
         logging!(info, Type::Validate, "开始验证配置文件: {}", config_path);
 
-        let clash_core = Config::verge().await.latest_ref().get_valid_clash_core();
+        let clash_core = Config::verge().await.latest_arc().get_valid_clash_core();
         logging!(info, Type::Validate, "使用内核: {}", clash_core);
 
         let app_handle = handle::Handle::app_handle();
@@ -278,41 +275,43 @@ impl CoreConfigValidator {
         logging!(info, Type::Validate, "验证目录: {}", app_dir_str);
 
         // 使用子进程运行clash验证配置
-        let output = app_handle
-            .shell()
-            .sidecar(clash_core.as_str())?
-            .args(["-t", "-d", app_dir_str, "-f", config_path])
-            .output()
-            .await?;
+        let command = app_handle.shell().sidecar(clash_core.as_str())?.args([
+            "-t",
+            "-d",
+            app_dir_str,
+            "-f",
+            config_path,
+        ]);
+        let output = command.output().await?;
 
-        let stderr = std::string::String::from_utf8_lossy(&output.stderr);
-        let stdout = std::string::String::from_utf8_lossy(&output.stdout);
+        let status = &output.status;
+        let stderr = &output.stderr;
+        let stdout = &output.stdout;
 
         // 检查进程退出状态和错误输出
         let error_keywords = ["FATA", "fatal", "Parse config error", "level=fatal"];
-        let has_error =
-            !output.status.success() || error_keywords.iter().any(|&kw| stderr.contains(kw));
+        let has_error = !status.success() || contains_any_keyword(stderr, &error_keywords);
 
         logging!(info, Type::Validate, "-------- 验证结果 --------");
 
         if !stderr.is_empty() {
-            logging!(info, Type::Validate, "stderr输出:\n{}", stderr);
+            logging!(info, Type::Validate, "stderr输出:\n{:?}", stderr);
         }
 
         if has_error {
             logging!(info, Type::Validate, "发现错误，开始处理错误信息");
-            let error_msg = if !stdout.is_empty() {
-                stdout.into()
+            let error_msg: String = if !stdout.is_empty() {
+                str::from_utf8(stdout).unwrap_or_default().into()
             } else if !stderr.is_empty() {
-                stderr.into()
-            } else if let Some(code) = output.status.code() {
-                format!("验证进程异常退出，退出码: {code}")
+                str::from_utf8(stderr).unwrap_or_default().into()
+            } else if let Some(code) = status.code() {
+                format!("验证进程异常退出，退出码: {code}").into()
             } else {
                 "验证进程被终止".into()
             };
 
             logging!(info, Type::Validate, "-------- 验证结束 --------");
-            Ok((false, error_msg.into())) // 返回错误消息给调用者处理
+            Ok((false, error_msg)) // 返回错误消息给调用者处理
         } else {
             logging!(info, Type::Validate, "验证成功");
             logging!(info, Type::Validate, "-------- 验证结束 --------");
@@ -345,6 +344,23 @@ fn has_ext<P: AsRef<std::path::Path>>(path: P, ext: &str) -> bool {
         .unwrap_or(false)
 }
 
+fn contains_any_keyword<'a>(buf: &'a [u8], keywords: &'a [&str]) -> bool {
+    for &kw in keywords {
+        let needle = kw.as_bytes();
+        if needle.is_empty() {
+            continue;
+        }
+        let mut i = 0;
+        while i + needle.len() <= buf.len() {
+            if &buf[i..i + needle.len()] == needle {
+                return true;
+            }
+            i += 1;
+        }
+    }
+    false
+}
+
 singleton_lazy!(
     CoreConfigValidator,
     CORECONFIGVALIDATOR,

src-tauri/src/enhance/chain.rs

@@ -5,7 +5,7 @@ use crate::{
 };
 use serde_yaml_ng::Mapping;
 use smartstring::alias::String;
-use std::fs;
+use tokio::fs;
 
 #[derive(Debug, Clone)]
 pub struct ChainItem {
@@ -70,7 +70,7 @@ pub trait AsyncChainItemFrom {
 }
 
 impl AsyncChainItemFrom for Option<ChainItem> {
-    async fn from_async(item: &PrfItem) -> Option<ChainItem> {
+    async fn from_async(item: &PrfItem) -> Self {
         let itype = item.itype.as_ref()?.as_str();
         let file = item.file.clone()?;
         let uid = item.uid.clone().unwrap_or_else(|| "".into());
@@ -83,7 +83,7 @@ impl AsyncChainItemFrom for Option<ChainItem> {
         match itype {
             "script" => Some(ChainItem {
                 uid,
-                data: ChainType::Script(fs::read_to_string(path).ok()?.into()),
+                data: ChainType::Script(fs::read_to_string(path).await.ok()?.into()),
             }),
             "merge" => Some(ChainItem {
                 uid,
@@ -116,22 +116,21 @@ impl AsyncChainItemFrom for Option<ChainItem> {
 }
 impl ChainItem {
     /// 内建支持一些脚本
-    pub fn builtin() -> Vec<(ChainSupport, ChainItem)> {
+    pub fn builtin() -> Vec<(ChainSupport, Self)> {
         // meta 的一些处理
         let meta_guard =
-            ChainItem::to_script("verge_meta_guard", include_str!("./builtin/meta_guard.js"));
+            Self::to_script("verge_meta_guard", include_str!("./builtin/meta_guard.js"));
 
         // meta 1.13.2 alpn string 转 数组
-        let hy_alpn =
-            ChainItem::to_script("verge_hy_alpn", include_str!("./builtin/meta_hy_alpn.js"));
+        let hy_alpn = Self::to_script("verge_hy_alpn", include_str!("./builtin/meta_hy_alpn.js"));
 
         // meta 的一些处理
         let meta_guard_alpha =
-            ChainItem::to_script("verge_meta_guard", include_str!("./builtin/meta_guard.js"));
+            Self::to_script("verge_meta_guard", include_str!("./builtin/meta_guard.js"));
 
         // meta 1.13.2 alpn string 转 数组
         let hy_alpn_alpha =
-            ChainItem::to_script("verge_hy_alpn", include_str!("./builtin/meta_hy_alpn.js"));
+            Self::to_script("verge_hy_alpn", include_str!("./builtin/meta_hy_alpn.js"));
 
         vec![
             (ChainSupport::ClashMeta, hy_alpn),
@@ -154,8 +153,7 @@ impl ChainSupport {
         match core {
             Some(core) => matches!(
                 (self, core.as_str()),
-                (ChainSupport::ClashMeta, "verge-mihomo")
-                    | (ChainSupport::ClashMetaAlpha, "verge-mihomo-alpha")
+                (Self::ClashMeta, "verge-mihomo") | (Self::ClashMetaAlpha, "verge-mihomo-alpha")
             ),
             None => true,
         }

src-tauri/src/enhance/merge.rs

@@ -1,3 +1,5 @@
+use crate::{logging, utils::logging::Type};
+
 use super::use_lowercase;
 use serde_yaml_ng::{self, Mapping, Value};
 
@@ -14,12 +16,16 @@ fn deep_merge(a: &mut Value, b: &Value) {
 
 pub fn use_merge(merge: Mapping, config: Mapping) -> Mapping {
     let mut config = Value::from(config);
-    let merge = use_lowercase(merge.clone());
+    let merge = use_lowercase(merge);
 
     deep_merge(&mut config, &Value::from(merge));
 
     config.as_mapping().cloned().unwrap_or_else(|| {
-        log::error!("Failed to convert merged config to mapping, using empty mapping");
+        logging!(
+            error,
+            Type::Core,
+            "Failed to convert merged config to mapping, using empty mapping"
+        );
         Mapping::new()
     })
 }

src-tauri/src/enhance/mod.rs

@@ -6,10 +6,14 @@ pub mod seq;
 mod tun;
 
 use self::{chain::*, field::*, merge::*, script::*, seq::*, tun::*};
+use crate::constants;
+use crate::utils::dirs;
 use crate::{config::Config, utils::tmpl};
+use crate::{logging, utils::logging::Type};
 use serde_yaml_ng::Mapping;
 use smartstring::alias::String;
 use std::collections::{HashMap, HashSet};
+use tokio::fs;
 
 type ResultLog = Vec<(String, String)>;
 #[derive(Debug)]
@@ -40,12 +44,49 @@ struct ProfileItems {
     profile_name: String,
 }
 
+impl Default for ProfileItems {
+    fn default() -> Self {
+        Self {
+            config: Default::default(),
+            profile_name: Default::default(),
+            merge_item: ChainItem {
+                uid: "".into(),
+                data: ChainType::Merge(Mapping::new()),
+            },
+            script_item: ChainItem {
+                uid: "".into(),
+                data: ChainType::Script(tmpl::ITEM_SCRIPT.into()),
+            },
+            rules_item: ChainItem {
+                uid: "".into(),
+                data: ChainType::Rules(SeqMap::default()),
+            },
+            proxies_item: ChainItem {
+                uid: "".into(),
+                data: ChainType::Proxies(SeqMap::default()),
+            },
+            groups_item: ChainItem {
+                uid: "".into(),
+                data: ChainType::Groups(SeqMap::default()),
+            },
+            global_merge: ChainItem {
+                uid: "Merge".into(),
+                data: ChainType::Merge(Mapping::new()),
+            },
+            global_script: ChainItem {
+                uid: "Script".into(),
+                data: ChainType::Script(tmpl::ITEM_SCRIPT.into()),
+            },
+        }
+    }
+}
+
 async fn get_config_values() -> ConfigValues {
-    let clash_config = { Config::clash().await.latest_ref().0.clone() };
+    let clash_config = { Config::clash().await.latest_arc().0.clone() };
 
     let (clash_core, enable_tun, enable_builtin, socks_enabled, http_enabled, enable_dns_settings) = {
         let verge = Config::verge().await;
-        let verge = verge.latest_ref();
+        let verge = verge.latest_arc();
         (
             Some(verge.get_valid_clash_core()),
             verge.enable_tun_mode.unwrap_or(false),
@@ -59,14 +100,14 @@ async fn get_config_values() -> ConfigValues {
     #[cfg(not(target_os = "windows"))]
     let redir_enabled = {
         let verge = Config::verge().await;
-        let verge = verge.latest_ref();
+        let verge = verge.latest_arc();
         verge.verge_redir_enabled.unwrap_or(false)
     };
 
     #[cfg(target_os = "linux")]
     let tproxy_enabled = {
         let verge = Config::verge().await;
-        let verge = verge.latest_ref();
+        let verge = verge.latest_arc();
         verge.verge_tproxy_enabled.unwrap_or(false)
     };
 
@@ -85,33 +126,43 @@ async fn get_config_values() -> ConfigValues {
     }
 }
 
+#[allow(clippy::cognitive_complexity)]
 async fn collect_profile_items() -> ProfileItems {
     // 从profiles里拿东西 - 先收集需要的数据，然后释放锁
-    let (
-        current,
-        merge_uid,
-        script_uid,
-        rules_uid,
-        proxies_uid,
-        groups_uid,
-        _current_profile_uid,
-        name,
-    ) = {
+    let (current, merge_uid, script_uid, rules_uid, proxies_uid, groups_uid, name) = {
         let current = {
             let profiles = Config::profiles().await;
-            let profiles_clone = profiles.latest_ref().clone();
+            let profiles_clone = profiles.latest_arc();
             profiles_clone.current_mapping().await.unwrap_or_default()
         };
 
         let profiles = Config::profiles().await;
-        let profiles_ref = profiles.latest_ref();
+        let profiles_ref = profiles.latest_arc();
+        let current_profile_uid = match profiles_ref.get_current() {
+            Some(uid) => uid.clone(),
+            None => return ProfileItems::default(),
+        };
 
-        let merge_uid = profiles_ref.current_merge().unwrap_or_default();
-        let script_uid = profiles_ref.current_script().unwrap_or_default();
-        let rules_uid = profiles_ref.current_rules().unwrap_or_default();
-        let proxies_uid = profiles_ref.current_proxies().unwrap_or_default();
-        let groups_uid = profiles_ref.current_groups().unwrap_or_default();
-        let current_profile_uid = profiles_ref.get_current().unwrap_or_default();
+        let current_item = match profiles_ref.get_item_arc(&current_profile_uid) {
+            Some(item) => item,
+            None => return ProfileItems::default(),
+        };
+
+        let merge_uid = current_item
+            .current_merge()
+            .unwrap_or_else(|| "Merge".into());
+        let script_uid = current_item
+            .current_script()
+            .unwrap_or_else(|| "Script".into());
+        let rules_uid = current_item
+            .current_rules()
+            .unwrap_or_else(|| "Rules".into());
+        let proxies_uid = current_item
+            .current_proxies()
+            .unwrap_or_else(|| "Proxies".into());
+        let groups_uid = current_item
+            .current_groups()
+            .unwrap_or_else(|| "Groups".into());
 
         let name = profiles_ref
             .get_item(&current_profile_uid)
@@ -126,7 +177,6 @@ async fn collect_profile_items() -> ProfileItems {
             rules_uid,
             proxies_uid,
             groups_uid,
-            current_profile_uid,
             name,
         )
     };
@@ -135,7 +185,7 @@ async fn collect_profile_items() -> ProfileItems {
     let merge_item = {
         let item = {
             let profiles = Config::profiles().await;
-            let profiles = profiles.latest_ref();
+            let profiles = profiles.latest_arc();
             profiles.get_item(&merge_uid).ok().cloned()
         };
         if let Some(item) = item {
@@ -152,7 +202,7 @@ async fn collect_profile_items() -> ProfileItems {
     let script_item = {
         let item = {
             let profiles = Config::profiles().await;
-            let profiles = profiles.latest_ref();
+            let profiles = profiles.latest_arc();
             profiles.get_item(&script_uid).ok().cloned()
         };
         if let Some(item) = item {
@@ -169,7 +219,7 @@ async fn collect_profile_items() -> ProfileItems {
     let rules_item = {
         let item = {
             let profiles = Config::profiles().await;
-            let profiles = profiles.latest_ref();
+            let profiles = profiles.latest_arc();
             profiles.get_item(&rules_uid).ok().cloned()
         };
         if let Some(item) = item {
@@ -186,7 +236,7 @@ async fn collect_profile_items() -> ProfileItems {
     let proxies_item = {
         let item = {
             let profiles = Config::profiles().await;
-            let profiles = profiles.latest_ref();
+            let profiles = profiles.latest_arc();
             profiles.get_item(&proxies_uid).ok().cloned()
         };
         if let Some(item) = item {
@@ -203,7 +253,7 @@ async fn collect_profile_items() -> ProfileItems {
     let groups_item = {
         let item = {
             let profiles = Config::profiles().await;
-            let profiles = profiles.latest_ref();
+            let profiles = profiles.latest_arc();
             profiles.get_item(&groups_uid).ok().cloned()
         };
         if let Some(item) = item {
@@ -220,8 +270,8 @@ async fn collect_profile_items() -> ProfileItems {
     let global_merge = {
         let item = {
             let profiles = Config::profiles().await;
-            let profiles = profiles.latest_ref();
-            profiles.get_item(&"Merge".into()).ok().cloned()
+            let profiles = profiles.latest_arc();
+            profiles.get_item("Merge").ok().cloned()
         };
         if let Some(item) = item {
             <Option<ChainItem>>::from_async(&item).await
@@ -237,8 +287,8 @@ async fn collect_profile_items() -> ProfileItems {
     let global_script = {
         let item = {
             let profiles = Config::profiles().await;
-            let profiles = profiles.latest_ref();
-            profiles.get_item(&"Script".into()).ok().cloned()
+            let profiles = profiles.latest_arc();
+            profiles.get_item("Script").ok().cloned()
         };
         if let Some(item) = item {
             <Option<ChainItem>>::from_async(&item).await
@@ -280,7 +330,7 @@ fn process_global_items(
 
     if let ChainType::Script(script) = global_script.data {
         let mut logs = vec![];
-        match use_script(script, config.to_owned(), profile_name.to_owned()) {
+        match use_script(script, config.to_owned(), profile_name) {
             Ok((res_config, res_logs)) => {
                 exists_keys.extend(use_keys(&res_config));
                 config = res_config;
@@ -390,7 +440,7 @@ async fn merge_default_config(
             if key.as_str() == Some("external-controller") {
                 let enable_external_controller = Config::verge()
                     .await
-                    .latest_ref()
+                    .latest_arc()
                     .enable_external_controller
                     .unwrap_or(false);
 
@@ -420,14 +470,14 @@ fn apply_builtin_scripts(
             .filter(|(s, _)| s.is_support(clash_core.as_ref()))
             .map(|(_, c)| c)
             .for_each(|item| {
-                log::debug!(target: "app", "run builtin script {}", item.uid);
+                logging!(debug, Type::Core, "run builtin script {}", item.uid);
                 if let ChainType::Script(script) = item.data {
                     match use_script(script, config.to_owned(), "".into()) {
                         Ok((res_config, _)) => {
                             config = res_config;
                         }
                         Err(err) => {
-                            log::error!(target: "app", "builtin script error `{err}`");
+                            logging!(error, Type::Core, "builtin script error `{err}`");
                         }
                     }
                 }
@@ -437,34 +487,29 @@ fn apply_builtin_scripts(
     config
 }
 
-fn apply_dns_settings(mut config: Mapping, enable_dns_settings: bool) -> Mapping {
-    if enable_dns_settings {
-        use crate::utils::dirs;
-        use std::fs;
+async fn apply_dns_settings(mut config: Mapping, enable_dns_settings: bool) -> Mapping {
+    if enable_dns_settings && let Ok(app_dir) = dirs::app_home_dir() {
+        let dns_path = app_dir.join(constants::files::DNS_CONFIG);
 
-        if let Ok(app_dir) = dirs::app_home_dir() {
-            let dns_path = app_dir.join("dns_config.yaml");
-
-            if dns_path.exists()
-                && let Ok(dns_yaml) = fs::read_to_string(&dns_path)
-                && let Ok(dns_config) = serde_yaml_ng::from_str::<serde_yaml_ng::Mapping>(&dns_yaml)
+        if dns_path.exists()
+            && let Ok(dns_yaml) = fs::read_to_string(&dns_path).await
+            && let Ok(dns_config) = serde_yaml_ng::from_str::<serde_yaml_ng::Mapping>(&dns_yaml)
+        {
+            if let Some(hosts_value) = dns_config.get("hosts")
+                && hosts_value.is_mapping()
             {
-                if let Some(hosts_value) = dns_config.get("hosts")
-                    && hosts_value.is_mapping()
-                {
-                    config.insert("hosts".into(), hosts_value.clone());
-                    log::info!(target: "app", "apply hosts configuration");
-                }
+                config.insert("hosts".into(), hosts_value.clone());
+                logging!(info, Type::Core, "apply hosts configuration");
+            }
 
-                if let Some(dns_value) = dns_config.get("dns") {
-                    if let Some(dns_mapping) = dns_value.as_mapping() {
-                        config.insert("dns".into(), dns_mapping.clone().into());
-                        log::info!(target: "app", "apply dns_config.yaml (dns section)");
-                    }
-                } else {
-                    config.insert("dns".into(), dns_config.into());
-                    log::info!(target: "app", "apply dns_config.yaml");
+            if let Some(dns_value) = dns_config.get("dns") {
+                if let Some(dns_mapping) = dns_value.as_mapping() {
+                    config.insert("dns".into(), dns_mapping.clone().into());
+                    logging!(info, Type::Core, "apply dns_config.yaml (dns section)");
                 }
+            } else {
+                config.insert("dns".into(), dns_config.into());
+                logging!(info, Type::Core, "apply dns_config.yaml");
             }
         }
     }
@@ -540,7 +585,7 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
     config = use_sort(config);
 
     // dns settings
-    config = apply_dns_settings(config, enable_dns_settings);
+    config = apply_dns_settings(config, enable_dns_settings).await;
 
     let mut exists_set = HashSet::new();
     exists_set.extend(exists_keys);

src-tauri/src/enhance/script.rs

@@ -62,7 +62,7 @@ pub fn use_script(
       });"#,
     ));
 
-    let config = use_lowercase(config.clone());
+    let config = use_lowercase(config);
     let config_str = serde_json::to_string(&config)?;
 
     // 仅处理 name 参数中的特殊字符

src-tauri/src/enhance/tun.rs

@@ -2,6 +2,8 @@ use serde_yaml_ng::{Mapping, Value};
 
 #[cfg(target_os = "macos")]
 use crate::process::AsyncHandler;
+#[cfg(target_os = "linux")]
+use crate::{logging, utils::logging::Type};
 
 macro_rules! revise {
     ($map: expr, $key: expr, $val: expr) => {
@@ -42,9 +44,10 @@ pub fn use_tun(mut config: Mapping, enable: bool) -> Mapping {
 
             if should_override {
                 revise!(tun_val, "stack", "mixed");
-                log::warn!(
-                    target: "app",
-                    "gVisor TUN stack detected on Linux; falling back to 'mixed' for compatibility"
+                logging!(
+                    warn,
+                    Type::Network,
+                    "Warning: gVisor TUN stack detected on Linux; falling back to 'mixed' for compatibility"
                 );
             }
         }

src-tauri/src/feat/backup.rs

@@ -2,6 +2,7 @@ use crate::{
     config::{Config, IVerge},
     core::backup,
     logging, logging_error,
+    process::AsyncHandler,
     utils::{
         dirs::{PathBufExec, app_home_dir, local_backup_dir},
         logging::Type,
@@ -12,7 +13,8 @@ use chrono::Utc;
 use reqwest_dav::list_cmd::ListFile;
 use serde::Serialize;
 use smartstring::alias::String;
-use std::{fs, path::PathBuf};
+use std::path::PathBuf;
+use tokio::fs;
 
 #[derive(Debug, Serialize)]
 pub struct LocalBackupFile {
@@ -24,7 +26,7 @@ pub struct LocalBackupFile {
 
 /// Create a backup and upload to WebDAV
 pub async fn create_backup_and_upload_webdav() -> Result<()> {
-    let (file_name, temp_file_path) = backup::create_backup().map_err(|err| {
+    let (file_name, temp_file_path) = backup::create_backup().await.map_err(|err| {
         logging!(error, Type::Backup, "Failed to create backup: {err:#?}");
         err
     })?;
@@ -76,7 +78,7 @@ pub async fn delete_webdav_backup(filename: String) -> Result<()> {
 /// Restore WebDAV backup
 pub async fn restore_webdav_backup(filename: String) -> Result<()> {
     let verge = Config::verge().await;
-    let verge_data = verge.latest_ref().clone();
+    let verge_data = verge.latest_arc();
     let webdav_url = verge_data.webdav_url.clone();
     let webdav_username = verge_data.webdav_username.clone();
     let webdav_password = verge_data.webdav_password.clone();
@@ -97,12 +99,14 @@ pub async fn restore_webdav_backup(filename: String) -> Result<()> {
         })?;
 
     // extract zip file
-    let mut zip = zip::ZipArchive::new(fs::File::open(backup_storage_path.clone())?)?;
+    let value = backup_storage_path.clone();
+    let file = AsyncHandler::spawn_blocking(move || std::fs::File::open(&value)).await??;
+    let mut zip = zip::ZipArchive::new(file)?;
     zip.extract(app_home_dir()?)?;
     logging_error!(
         Type::Backup,
         super::patch_verge(
-            IVerge {
+            &IVerge {
                 webdav_url,
                 webdav_username,
                 webdav_password,
@@ -119,7 +123,7 @@ pub async fn restore_webdav_backup(filename: String) -> Result<()> {
 
 /// Create a backup and save to local storage
 pub async fn create_local_backup() -> Result<()> {
-    let (file_name, temp_file_path) = backup::create_backup().map_err(|err| {
+    let (file_name, temp_file_path) = backup::create_backup().await.map_err(|err| {
         logging!(
             error,
             Type::Backup,
@@ -131,7 +135,7 @@ pub async fn create_local_backup() -> Result<()> {
     let backup_dir = local_backup_dir()?;
     let target_path = backup_dir.join(file_name.as_str());
 
-    if let Err(err) = move_file(temp_file_path.clone(), target_path.clone()) {
+    if let Err(err) = move_file(temp_file_path.clone(), target_path.clone()).await {
         logging!(
             error,
             Type::Backup,
@@ -151,12 +155,12 @@ pub async fn create_local_backup() -> Result<()> {
     Ok(())
 }
 
-fn move_file(from: PathBuf, to: PathBuf) -> Result<()> {
+async fn move_file(from: PathBuf, to: PathBuf) -> Result<()> {
     if let Some(parent) = to.parent() {
-        fs::create_dir_all(parent)?;
+        fs::create_dir_all(parent).await?;
     }
 
-    match fs::rename(&from, &to) {
+    match fs::rename(&from, &to).await {
         Ok(_) => Ok(()),
         Err(rename_err) => {
             // Attempt copy + remove as fallback, covering cross-device moves
@@ -165,8 +169,11 @@ fn move_file(from: PathBuf, to: PathBuf) -> Result<()> {
                 Type::Backup,
                 "Failed to rename backup file directly, fallback to copy/remove: {rename_err:#?}"
             );
-            fs::copy(&from, &to).map_err(|err| anyhow!("Failed to copy backup file: {err:#?}"))?;
+            fs::copy(&from, &to)
+                .await
+                .map_err(|err| anyhow!("Failed to copy backup file: {err:#?}"))?;
             fs::remove_file(&from)
+                .await
                 .map_err(|err| anyhow!("Failed to remove temp backup file: {err:#?}"))?;
             Ok(())
         }
@@ -174,24 +181,25 @@ fn move_file(from: PathBuf, to: PathBuf) -> Result<()> {
 }
 
 /// List local backups
-pub fn list_local_backup() -> Result<Vec<LocalBackupFile>> {
+pub async fn list_local_backup() -> Result<Vec<LocalBackupFile>> {
     let backup_dir = local_backup_dir()?;
     if !backup_dir.exists() {
         return Ok(vec![]);
     }
 
     let mut backups = Vec::new();
-    for entry in fs::read_dir(&backup_dir)? {
-        let entry = entry?;
+    let mut dir = fs::read_dir(&backup_dir).await?;
+    while let Some(entry) = dir.next_entry().await? {
         let path = entry.path();
-        if !path.is_file() {
+        let metadata = entry.metadata().await?;
+        if !metadata.is_file() {
             continue;
         }
 
-        let Some(file_name) = path.file_name().and_then(|name| name.to_str()) else {
-            continue;
+        let file_name = match path.file_name().and_then(|name| name.to_str()) {
+            Some(name) => name,
+            None => continue,
         };
-        let metadata = entry.metadata()?;
         let last_modified = metadata
             .modified()
             .map(|time| chrono::DateTime::<Utc>::from(time).to_rfc3339())
@@ -233,18 +241,23 @@ pub async fn restore_local_backup(filename: String) -> Result<()> {
         return Err(anyhow!("Backup file not found: {}", filename));
     }
 
-    let verge = Config::verge().await;
-    let verge_data = verge.latest_ref().clone();
-    let webdav_url = verge_data.webdav_url.clone();
-    let webdav_username = verge_data.webdav_username.clone();
-    let webdav_password = verge_data.webdav_password.clone();
+    let (webdav_url, webdav_username, webdav_password) = {
+        let verge = Config::verge().await;
+        let verge = verge.latest_arc();
+        (
+            verge.webdav_url.clone(),
+            verge.webdav_username.clone(),
+            verge.webdav_password.clone(),
+        )
+    };
 
-    let mut zip = zip::ZipArchive::new(fs::File::open(&target_path)?)?;
+    let file = AsyncHandler::spawn_blocking(move || std::fs::File::open(&target_path)).await??;
+    let mut zip = zip::ZipArchive::new(file)?;
     zip.extract(app_home_dir()?)?;
     logging_error!(
         Type::Backup,
         super::patch_verge(
-            IVerge {
+            &IVerge {
                 webdav_url,
                 webdav_username,
                 webdav_password,
@@ -258,7 +271,7 @@ pub async fn restore_local_backup(filename: String) -> Result<()> {
 }
 
 /// Export local backup file to user selected destination
-pub fn export_local_backup(filename: String, destination: String) -> Result<()> {
+pub async fn export_local_backup(filename: String, destination: String) -> Result<()> {
     let backup_dir = local_backup_dir()?;
     let source_path = backup_dir.join(filename.as_str());
     if !source_path.exists() {
@@ -267,10 +280,11 @@ pub fn export_local_backup(filename: String, destination: String) -> Result<()>
 
     let dest_path = PathBuf::from(destination.as_str());
     if let Some(parent) = dest_path.parent() {
-        fs::create_dir_all(parent)?;
+        fs::create_dir_all(parent).await?;
     }
 
     fs::copy(&source_path, &dest_path)
+        .await
         .map(|_| ())
         .map_err(|err| anyhow!("Failed to export backup file: {err:#?}"))?;
     Ok(())

src-tauri/src/feat/clash.rs

@@ -1,7 +1,7 @@
 use crate::{
     config::Config,
     core::{CoreManager, handle, tray},
-    logging_error,
+    logging, logging_error,
     process::AsyncHandler,
     utils::{self, logging::Type, resolve},
 };
@@ -17,7 +17,7 @@ pub async fn restart_clash_core() {
         }
         Err(err) => {
             handle::Handle::notice_message("set_config::error", format!("{err}"));
-            log::error!(target:"app", "{err}");
+            logging!(error, Type::Core, "{err}");
         }
     }
 }
@@ -30,7 +30,7 @@ pub async fn restart_app() {
             "restart_app::error",
             format!("Failed to cleanup resources: {err}"),
         );
-        log::error!(target:"app", "Restart failed during cleanup: {err}");
+        logging!(error, Type::Core, "Restart failed during cleanup: {err}");
         return;
     }
 
@@ -47,10 +47,11 @@ fn after_change_clash_mode() {
                     for connection in connections_array {
                         let _ = mihomo.close_connection(&connection.id).await;
                     }
+                    drop(mihomo);
                 }
             }
             Err(err) => {
-                log::error!(target: "app", "Failed to get connections: {err}");
+                logging!(error, Type::Core, "Failed to get connections: {err}");
             }
         }
     });
@@ -64,7 +65,7 @@ pub async fn change_clash_mode(mode: String) {
     let json_value = serde_json::json!({
         "mode": mode
     });
-    log::debug!(target: "app", "change clash mode to {mode}");
+    logging!(debug, Type::Core, "change clash mode to {mode}");
     match handle::Handle::mihomo()
         .await
         .patch_base_config(&json_value)
@@ -72,10 +73,12 @@ pub async fn change_clash_mode(mode: String) {
     {
         Ok(_) => {
             // 更新订阅
-            Config::clash().await.data_mut().patch_config(mapping);
+            Config::clash()
+                .await
+                .edit_draft(|d| d.patch_config(mapping));
 
             // 分离数据获取和异步调用
-            let clash_data = Config::clash().await.data_mut().clone();
+            let clash_data = Config::clash().await.data_arc();
             if clash_data.save_config().await.is_ok() {
                 handle::Handle::refresh_clash();
                 logging_error!(Type::Tray, tray::Tray::global().update_menu().await);
@@ -84,14 +87,14 @@ pub async fn change_clash_mode(mode: String) {
 
             let is_auto_close_connection = Config::verge()
                 .await
-                .data_mut()
+                .data_arc()
                 .auto_close_connection
                 .unwrap_or(false);
             if is_auto_close_connection {
                 after_change_clash_mode();
             }
         }
-        Err(err) => log::error!(target: "app", "{err}"),
+        Err(err) => logging!(error, Type::Core, "{err}"),
     }
 }
 
@@ -102,7 +105,7 @@ pub async fn test_delay(url: String) -> anyhow::Result<u32> {
 
     let tun_mode = Config::verge()
         .await
-        .latest_ref()
+        .latest_arc()
         .enable_tun_mode
         .unwrap_or(false);
 
@@ -123,7 +126,7 @@ pub async fn test_delay(url: String) -> anyhow::Result<u32> {
 
     match response {
         Ok(response) => {
-            log::trace!(target: "app", "test_delay response: {response:#?}");
+            logging!(trace, Type::Network, "test_delay response: {response:#?}");
             if response.status().is_success() {
                 Ok(start.elapsed().as_millis() as u32)
             } else {
@@ -131,7 +134,7 @@ pub async fn test_delay(url: String) -> anyhow::Result<u32> {
             }
         }
         Err(err) => {
-            log::trace!(target: "app", "test_delay error: {err:#?}");
+            logging!(trace, Type::Network, "test_delay error: {err:#?}");
             Err(err)
         }
     }

src-tauri/src/feat/config.rs

@@ -3,7 +3,7 @@ use crate::{
     core::{CoreManager, handle, hotkey, sysopt, tray},
     logging_error,
     module::lightweight,
-    utils::logging::Type,
+    utils::{draft::SharedBox, logging::Type},
 };
 use anyhow::Result;
 use serde_yaml_ng::Mapping;
@@ -12,8 +12,7 @@ use serde_yaml_ng::Mapping;
 pub async fn patch_clash(patch: Mapping) -> Result<()> {
     Config::clash()
         .await
-        .draft_mut()
-        .patch_config(patch.clone());
+        .edit_draft(|d| d.patch_config(patch.clone()));
 
     let res = {
         // 激活订阅
@@ -25,7 +24,9 @@ pub async fn patch_clash(patch: Mapping) -> Result<()> {
                 logging_error!(Type::Tray, tray::Tray::global().update_menu().await);
                 logging_error!(Type::Tray, tray::Tray::global().update_icon().await);
             }
-            Config::runtime().await.draft_mut().patch_config(patch);
+            Config::runtime()
+                .await
+                .edit_draft(|d| d.patch_config(patch));
             CoreManager::global().update_config().await?;
         }
         handle::Handle::refresh_clash();
@@ -35,7 +36,7 @@ pub async fn patch_clash(patch: Mapping) -> Result<()> {
         Ok(()) => {
             Config::clash().await.apply();
             // 分离数据获取和异步调用
-            let clash_data = Config::clash().await.data_mut().clone();
+            let clash_data = Config::clash().await.data_arc();
             clash_data.save_config().await?;
             Ok(())
         }
@@ -190,7 +191,9 @@ async fn process_terminated_flags(update_flags: i32, patch: &IVerge) -> Result<(
         handle::Handle::refresh_clash();
     }
     if (update_flags & (UpdateFlags::VergeConfig as i32)) != 0 {
-        Config::verge().await.draft_mut().enable_global_hotkey = patch.enable_global_hotkey;
+        Config::verge()
+            .await
+            .edit_draft(|d| d.enable_global_hotkey = patch.enable_global_hotkey);
         handle::Handle::refresh_verge();
     }
     if (update_flags & (UpdateFlags::Launch as i32)) != 0 {
@@ -226,15 +229,12 @@ async fn process_terminated_flags(update_flags: i32, patch: &IVerge) -> Result<(
     Ok(())
 }
 
-pub async fn patch_verge(patch: IVerge, not_save_file: bool) -> Result<()> {
-    Config::verge()
-        .await
-        .draft_mut()
-        .patch_config(patch.clone());
+pub async fn patch_verge(patch: &IVerge, not_save_file: bool) -> Result<()> {
+    Config::verge().await.edit_draft(|d| d.patch_config(patch));
 
-    let update_flags = determine_update_flags(&patch);
+    let update_flags = determine_update_flags(patch);
     let process_flag_result: std::result::Result<(), anyhow::Error> = {
-        process_terminated_flags(update_flags, &patch).await?;
+        process_terminated_flags(update_flags, patch).await?;
         Ok(())
     };
 
@@ -245,8 +245,14 @@ pub async fn patch_verge(patch: IVerge, not_save_file: bool) -> Result<()> {
     Config::verge().await.apply();
     if !not_save_file {
         // 分离数据获取和异步调用
-        let verge_data = Config::verge().await.data_mut().clone();
+        let verge_data = Config::verge().await.data_arc();
         verge_data.save_file().await?;
     }
     Ok(())
 }
+
+pub async fn fetch_verge_config() -> Result<SharedBox<IVerge>> {
+    let draft = Config::verge().await;
+    let data = draft.data_arc();
+    Ok(data)
+}

src-tauri/src/feat/profile.rs

@@ -2,52 +2,125 @@ use crate::{
     cmd,
     config::{Config, PrfItem, PrfOption, profiles::profiles_draft_update_item_safe},
     core::{CoreManager, handle, tray},
-    logging,
+    logging, logging_error,
     utils::logging::Type,
 };
 use anyhow::{Result, bail};
 use smartstring::alias::String;
+use tauri::Emitter;
 
 /// Toggle proxy profile
 pub async fn toggle_proxy_profile(profile_index: String) {
-    match cmd::patch_profiles_config_by_profile_index(profile_index).await {
+    logging_error!(
+        Type::Config,
+        cmd::patch_profiles_config_by_profile_index(profile_index).await
+    );
+}
+
+pub async fn switch_proxy_node(group_name: &str, proxy_name: &str) {
+    match handle::Handle::mihomo()
+        .await
+        .select_node_for_group(group_name, proxy_name)
+        .await
+    {
         Ok(_) => {
-            let result = tray::Tray::global().update_menu().await;
-            if let Err(err) = result {
-                logging!(error, Type::Tray, "更新菜单失败: {}", err);
-            }
+            logging!(
+                info,
+                Type::Tray,
+                "切换代理成功: {} -> {}",
+                group_name,
+                proxy_name
+            );
+            let _ = handle::Handle::app_handle().emit("verge://refresh-proxy-config", ());
+            let _ = tray::Tray::global().update_menu().await;
+            return;
         }
         Err(err) => {
-            log::error!(target: "app", "{err}");
+            logging!(
+                error,
+                Type::Tray,
+                "切换代理失败: {} -> {}, 错误: {:?}",
+                group_name,
+                proxy_name,
+                err
+            );
+        }
+    }
+
+    match handle::Handle::mihomo()
+        .await
+        .select_node_for_group(group_name, proxy_name)
+        .await
+    {
+        Ok(_) => {
+            logging!(
+                info,
+                Type::Tray,
+                "代理切换回退成功: {} -> {}",
+                group_name,
+                proxy_name
+            );
+            let _ = tray::Tray::global().update_menu().await;
+        }
+        Err(err) => {
+            logging!(
+                error,
+                Type::Tray,
+                "代理切换最终失败: {} -> {}, 错误: {:?}",
+                group_name,
+                proxy_name,
+                err
+            );
         }
     }
 }
 
-async fn should_update_profile(uid: String) -> Result<Option<(String, Option<PrfOption>)>> {
+async fn should_update_profile(
+    uid: &String,
+    ignore_auto_update: bool,
+) -> Result<Option<(String, Option<PrfOption>)>> {
     let profiles = Config::profiles().await;
-    let profiles = profiles.latest_ref();
-    let item = profiles.get_item(&uid)?;
+    let profiles = profiles.latest_arc();
+    let item = profiles.get_item(uid)?;
     let is_remote = item.itype.as_ref().is_some_and(|s| s == "remote");
 
     if !is_remote {
-        log::info!(target: "app", "[订阅更新] {uid} 不是远程订阅，跳过更新");
+        logging!(
+            info,
+            Type::Config,
+            "[订阅更新] {uid} 不是远程订阅，跳过更新"
+        );
         Ok(None)
     } else if item.url.is_none() {
-        log::warn!(target: "app", "[订阅更新] {uid} 缺少URL，无法更新");
+        logging!(
+            warn,
+            Type::Config,
+            "Warning: [订阅更新] {uid} 缺少URL，无法更新"
+        );
         bail!("failed to get the profile item url");
-    } else if !item
-        .option
-        .as_ref()
-        .and_then(|o| o.allow_auto_update)
-        .unwrap_or(true)
+    } else if !ignore_auto_update
+        && !item
+            .option
+            .as_ref()
+            .and_then(|o| o.allow_auto_update)
+            .unwrap_or(true)
     {
-        log::info!(target: "app", "[订阅更新] {} 禁止自动更新，跳过更新", uid);
+        logging!(
+            info,
+            Type::Config,
+            "[订阅更新] {} 禁止自动更新，跳过更新",
+            uid
+        );
         Ok(None)
     } else {
-        log::info!(target: "app",
+        logging!(
+            info,
+            Type::Config,
             "[订阅更新] {} 是远程订阅，URL: {}",
             uid,
-            item.url.clone().ok_or_else(|| anyhow::anyhow!("Profile URL is None"))?
+            item.url
+                .clone()
+                .ok_or_else(|| anyhow::anyhow!("Profile URL is None"))?
         );
         Ok(Some((
             item.url
@@ -59,79 +132,111 @@ async fn should_update_profile(uid: String) -> Result<Option<(String, Option<Prf
 }
 
 async fn perform_profile_update(
-    uid: String,
-    url: String,
-    opt: Option<PrfOption>,
-    option: Option<PrfOption>,
+    uid: &String,
+    url: &String,
+    opt: Option<&PrfOption>,
+    option: Option<&PrfOption>,
 ) -> Result<bool> {
-    log::info!(target: "app", "[订阅更新] 开始下载新的订阅内容");
-    let merged_opt = PrfOption::merge(opt.clone(), option.clone());
+    logging!(info, Type::Config, "[订阅更新] 开始下载新的订阅内容");
+    let mut merged_opt = PrfOption::merge(opt, option);
+    let is_current = {
+        let profiles = Config::profiles().await;
+        profiles.latest_arc().is_current_profile_index(uid)
+    };
+    let profiles = Config::profiles().await;
+    let profiles_arc = profiles.latest_arc();
+    let profile_name = profiles_arc
+        .get_name_by_uid(uid)
+        .cloned()
+        .unwrap_or_else(|| String::from("UnKown Profile"));
 
-    match PrfItem::from_url(&url, None, None, merged_opt.clone()).await {
-        Ok(item) => {
-            log::info!(target: "app", "[订阅更新] 更新订阅配置成功");
-            let profiles = Config::profiles().await;
-            profiles_draft_update_item_safe(uid.clone(), item).await?;
-            let is_current = Some(uid.clone()) == profiles.latest_ref().get_current();
-            log::info!(target: "app", "[订阅更新] 是否为当前使用的订阅: {is_current}");
-            Ok(is_current)
+    let mut last_err;
+
+    match PrfItem::from_url(url, None, None, merged_opt.as_ref()).await {
+        Ok(mut item) => {
+            logging!(info, Type::Config, "[订阅更新] 更新订阅配置成功");
+            profiles_draft_update_item_safe(uid, &mut item).await?;
+            return Ok(is_current);
         }
         Err(err) => {
-            log::warn!(target: "app", "[订阅更新] 正常更新失败: {err}，尝试使用Clash代理更新");
-            handle::Handle::notice_message("update_retry_with_clash", uid.clone());
-
-            let original_with_proxy = merged_opt.as_ref().and_then(|o| o.with_proxy);
-            let original_self_proxy = merged_opt.as_ref().and_then(|o| o.self_proxy);
-
-            let mut fallback_opt = merged_opt.unwrap_or_default();
-            fallback_opt.with_proxy = Some(false);
-            fallback_opt.self_proxy = Some(true);
-
-            match PrfItem::from_url(&url, None, None, Some(fallback_opt)).await {
-                Ok(mut item) => {
-                    log::info!(target: "app", "[订阅更新] 使用Clash代理更新成功");
-
-                    if let Some(option) = item.option.as_mut() {
-                        option.with_proxy = original_with_proxy;
-                        option.self_proxy = original_self_proxy;
-                    }
-
-                    let profiles = Config::profiles().await;
-                    profiles_draft_update_item_safe(uid.clone(), item.clone()).await?;
-
-                    let profile_name = item.name.clone().unwrap_or_else(|| uid.clone());
-                    handle::Handle::notice_message("update_with_clash_proxy", profile_name);
-
-                    let is_current = Some(uid.clone()) == profiles.data_ref().get_current();
-                    log::info!(target: "app", "[订阅更新] 是否为当前使用的订阅: {is_current}");
-                    Ok(is_current)
-                }
-                Err(retry_err) => {
-                    log::error!(target: "app", "[订阅更新] 使用Clash代理更新仍然失败: {retry_err}");
-                    handle::Handle::notice_message(
-                        "update_failed_even_with_clash",
-                        format!("{retry_err}"),
-                    );
-                    Err(retry_err)
-                }
-            }
+            logging!(
+                warn,
+                Type::Config,
+                "Warning: [订阅更新] 正常更新失败: {err}，尝试使用Clash代理更新"
+            );
+            last_err = err;
         }
     }
+
+    merged_opt.get_or_insert_with(PrfOption::default).self_proxy = Some(true);
+    merged_opt.get_or_insert_with(PrfOption::default).with_proxy = Some(false);
+
+    match PrfItem::from_url(url, None, None, merged_opt.as_ref()).await {
+        Ok(mut item) => {
+            logging!(
+                info,
+                Type::Config,
+                "[订阅更新] 使用 Clash代理 更新订阅配置成功"
+            );
+            profiles_draft_update_item_safe(uid, &mut item).await?;
+            handle::Handle::notice_message("update_with_clash_proxy", profile_name);
+            drop(last_err);
+            return Ok(is_current);
+        }
+        Err(err) => {
+            logging!(
+                warn,
+                Type::Config,
+                "Warning: [订阅更新] 正常更新失败: {err}，尝试使用Clash代理更新"
+            );
+            last_err = err;
+        }
+    }
+
+    merged_opt.get_or_insert_with(PrfOption::default).self_proxy = Some(false);
+    merged_opt.get_or_insert_with(PrfOption::default).with_proxy = Some(true);
+
+    match PrfItem::from_url(url, None, None, merged_opt.as_ref()).await {
+        Ok(mut item) => {
+            logging!(
+                info,
+                Type::Config,
+                "[订阅更新] 使用 系统代理 更新订阅配置成功"
+            );
+            profiles_draft_update_item_safe(uid, &mut item).await?;
+            handle::Handle::notice_message("update_with_clash_proxy", profile_name);
+            drop(last_err);
+            return Ok(is_current);
+        }
+        Err(err) => {
+            logging!(
+                warn,
+                Type::Config,
+                "Warning: [订阅更新] 正常更新失败: {err}，尝试使用系统代理更新"
+            );
+            last_err = err;
+        }
+    }
+
+    handle::Handle::notice_message(
+        "update_failed_even_with_clash",
+        format!("{profile_name} - {last_err}"),
+    );
+    Ok(is_current)
 }
 
 pub async fn update_profile(
-    uid: String,
-    option: Option<PrfOption>,
-    auto_refresh: Option<bool>,
+    uid: &String,
+    option: Option<&PrfOption>,
+    auto_refresh: bool,
+    ignore_auto_update: bool,
 ) -> Result<()> {
     logging!(info, Type::Config, "[订阅更新] 开始更新订阅 {}", uid);
-    let auto_refresh = auto_refresh.unwrap_or(true);
-
-    let url_opt = should_update_profile(uid.clone()).await?;
+    let url_opt = should_update_profile(uid, ignore_auto_update).await?;
 
     let should_refresh = match url_opt {
         Some((url, opt)) => {
-            perform_profile_update(uid.clone(), url, opt, option).await? && auto_refresh
+            perform_profile_update(uid, &url, opt.as_ref(), option).await? && auto_refresh
         }
         None => auto_refresh,
     };
@@ -146,7 +251,7 @@ pub async fn update_profile(
             Err(err) => {
                 logging!(error, Type::Config, "[订阅更新] 更新失败: {}", err);
                 handle::Handle::notice_message("update_failed", format!("{err}"));
-                log::error!(target: "app", "{err}");
+                logging!(error, Type::Config, "{err}");
             }
         }
     }

src-tauri/src/feat/proxy.rs

@@ -1,6 +1,8 @@
 use crate::{
     config::{Config, IVerge},
     core::handle,
+    logging,
+    utils::logging::Type,
 };
 use std::env;
 use tauri_plugin_clipboard_manager::ClipboardExt;
@@ -8,19 +10,23 @@ use tauri_plugin_clipboard_manager::ClipboardExt;
 /// Toggle system proxy on/off
 pub async fn toggle_system_proxy() {
     let verge = Config::verge().await;
-    let enable = verge.latest_ref().enable_system_proxy.unwrap_or(false);
-    let auto_close_connection = verge.latest_ref().auto_close_connection.unwrap_or(false);
+    let enable = verge.latest_arc().enable_system_proxy.unwrap_or(false);
+    let auto_close_connection = verge.latest_arc().auto_close_connection.unwrap_or(false);
 
     // 如果当前系统代理即将关闭，且自动关闭连接设置为true，则关闭所有连接
     if enable
         && auto_close_connection
         && let Err(err) = handle::Handle::mihomo().await.close_all_connections().await
     {
-        log::error!(target: "app", "Failed to close all connections: {err}");
+        logging!(
+            error,
+            Type::ProxyMode,
+            "Failed to close all connections: {err}"
+        );
     }
 
     let patch_result = super::patch_verge(
-        IVerge {
+        &IVerge {
             enable_system_proxy: Some(!enable),
             ..IVerge::default()
         },
@@ -30,17 +36,17 @@ pub async fn toggle_system_proxy() {
 
     match patch_result {
         Ok(_) => handle::Handle::refresh_verge(),
-        Err(err) => log::error!(target: "app", "{err}"),
+        Err(err) => logging!(error, Type::ProxyMode, "{err}"),
     }
 }
 
 /// Toggle TUN mode on/off
 pub async fn toggle_tun_mode(not_save_file: Option<bool>) {
-    let enable = Config::verge().await.data_mut().enable_tun_mode;
+    let enable = Config::verge().await.latest_arc().enable_tun_mode;
     let enable = enable.unwrap_or(false);
 
     match super::patch_verge(
-        IVerge {
+        &IVerge {
             enable_tun_mode: Some(!enable),
             ..IVerge::default()
         },
@@ -49,7 +55,7 @@ pub async fn toggle_tun_mode(not_save_file: Option<bool>) {
     .await
     {
         Ok(_) => handle::Handle::refresh_verge(),
-        Err(err) => log::error!(target: "app", "{err}"),
+        Err(err) => logging!(error, Type::ProxyMode, "{err}"),
     }
 }
 
@@ -60,7 +66,7 @@ pub async fn copy_clash_env() {
         Ok(ip) => ip.into(),
         Err(_) => Config::verge()
             .await
-            .latest_ref()
+            .latest_arc()
             .proxy_host
             .clone()
             .unwrap_or_else(|| "127.0.0.1".into()),
@@ -70,7 +76,7 @@ pub async fn copy_clash_env() {
     let port = {
         Config::verge()
             .await
-            .latest_ref()
+            .latest_arc()
             .verge_mixed_port
             .unwrap_or(7897)
     };
@@ -78,7 +84,7 @@ pub async fn copy_clash_env() {
     let socks5_proxy = format!("socks5://{clash_verge_rev_ip}:{port}");
 
     let cliboard = app_handle.clipboard();
-    let env_type = { Config::verge().await.latest_ref().env_type.clone() };
+    let env_type = { Config::verge().await.latest_arc().env_type.clone() };
     let env_type = match env_type {
         Some(env_type) => env_type,
         None => {
@@ -104,12 +110,16 @@ pub async fn copy_clash_env() {
         }
         "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}");
+            logging!(
+                error,
+                Type::ProxyMode,
+                "copy_clash_env: Invalid env type! {env_type}"
+            );
             return;
         }
     };
 
     if cliboard.write_text(export_text).is_err() {
-        log::error!(target: "app", "Failed to write to clipboard");
+        logging!(error, Type::ProxyMode, "Failed to write to clipboard");
     }
 }

src-tauri/src/feat/window.rs

@@ -14,7 +14,7 @@ pub async fn open_or_close_dashboard() {
 async fn open_or_close_dashboard_internal() {
     let _ = lightweight::exit_lightweight_mode().await;
     let result = WindowManager::toggle_main_window().await;
-    log::info!(target: "app", "Window toggle result: {result:?}");
+    logging!(info, Type::Window, "Window toggle result: {result:?}");
 }
 
 pub async fn quit() {
@@ -47,7 +47,7 @@ pub async fn clean_async() -> bool {
     let tun_task = async {
         let tun_enabled = Config::verge()
             .await
-            .data_ref()
+            .latest_arc()
             .enable_tun_mode
             .unwrap_or(false);
 
@@ -71,16 +71,20 @@ pub async fn clean_async() -> bool {
         .await
         {
             Ok(Ok(_)) => {
-                log::info!(target: "app", "TUN模式已禁用");
+                logging!(info, Type::Window, "TUN模式已禁用");
                 true
             }
             Ok(Err(e)) => {
-                log::warn!(target: "app", "禁用TUN模式失败: {e}");
+                logging!(warn, Type::Window, "Warning: 禁用TUN模式失败: {e}");
                 // 超时不阻塞退出
                 true
             }
             Err(_) => {
-                log::warn!(target: "app", "禁用TUN模式超时（可能系统正在关机），继续退出流程");
+                logging!(
+                    warn,
+                    Type::Window,
+                    "Warning: 禁用TUN模式超时（可能系统正在关机），继续退出流程"
+                );
                 true
             }
         }
@@ -96,12 +100,12 @@ pub async fn clean_async() -> bool {
             // 检查系统代理是否开启
             let sys_proxy_enabled = Config::verge()
                 .await
-                .latest_ref()
+                .latest_arc()
                 .enable_system_proxy
                 .unwrap_or(false);
 
             if !sys_proxy_enabled {
-                log::info!(target: "app", "系统代理未启用，跳过重置");
+                logging!(info, Type::Window, "系统代理未启用，跳过重置");
                 return true;
             }
 
@@ -110,19 +114,23 @@ pub async fn clean_async() -> bool {
 
             if is_shutting_down {
                 // sysproxy-rs 操作注册表(避免.exe的dll错误)
-                log::info!(target: "app", "检测到正在关机，syspro-rs操作注册表关闭系统代理");
+                logging!(
+                    info,
+                    Type::Window,
+                    "检测到正在关机，syspro-rs操作注册表关闭系统代理"
+                );
 
                 match Sysproxy::get_system_proxy() {
                     Ok(mut sysproxy) => {
                         sysproxy.enable = false;
                         if let Err(e) = sysproxy.set_system_proxy() {
-                            log::warn!(target: "app", "关机时关闭系统代理失败: {e}");
+                            logging!(warn, Type::Window, "Warning: 关机时关闭系统代理失败: {e}");
                         } else {
-                            log::info!(target: "app", "系统代理已关闭（通过注册表）");
+                            logging!(info, Type::Window, "系统代理已关闭（通过注册表）");
                         }
                     }
                     Err(e) => {
-                        log::warn!(target: "app", "关机时获取代理设置失败: {e}");
+                        logging!(warn, Type::Window, "Warning: 关机时获取代理设置失败: {e}");
                     }
                 }
 
@@ -136,7 +144,7 @@ pub async fn clean_async() -> bool {
             }
 
             // 正常退出：使用 sysproxy.exe 重置代理
-            log::info!(target: "app", "sysproxy.exe重置系统代理");
+            logging!(info, Type::Window, "sysproxy.exe重置系统代理");
 
             match timeout(
                 Duration::from_secs(2),
@@ -145,15 +153,19 @@ pub async fn clean_async() -> bool {
             .await
             {
                 Ok(Ok(_)) => {
-                    log::info!(target: "app", "系统代理已重置");
+                    logging!(info, Type::Window, "系统代理已重置");
                     true
                 }
                 Ok(Err(e)) => {
-                    log::warn!(target: "app", "重置系统代理失败: {e}");
+                    logging!(warn, Type::Window, "Warning: 重置系统代理失败: {e}");
                     true
                 }
                 Err(_) => {
-                    log::warn!(target: "app", "重置系统代理超时，继续退出流程");
+                    logging!(
+                        warn,
+                        Type::Window,
+                        "Warning: 重置系统代理超时，继续退出流程"
+                    );
                     true
                 }
             }
@@ -164,16 +176,16 @@ pub async fn clean_async() -> bool {
         {
             let sys_proxy_enabled = Config::verge()
                 .await
-                .latest_ref()
+                .latest_arc()
                 .enable_system_proxy
                 .unwrap_or(false);
 
             if !sys_proxy_enabled {
-                log::info!(target: "app", "系统代理未启用，跳过重置");
+                logging!(info, Type::Window, "系统代理未启用，跳过重置");
                 return true;
             }
 
-            log::info!(target: "app", "开始重置系统代理...");
+            logging!(info, Type::Window, "开始重置系统代理...");
 
             match timeout(
                 Duration::from_millis(1500),
@@ -182,15 +194,15 @@ pub async fn clean_async() -> bool {
             .await
             {
                 Ok(Ok(_)) => {
-                    log::info!(target: "app", "系统代理已重置");
+                    logging!(info, Type::Window, "系统代理已重置");
                     true
                 }
                 Ok(Err(e)) => {
-                    log::warn!(target: "app", "重置系统代理失败: {e}");
+                    logging!(warn, Type::Window, "Warning: 重置系统代理失败: {e}");
                     true
                 }
                 Err(_) => {
-                    log::warn!(target: "app", "重置系统代理超时，继续退出");
+                    logging!(warn, Type::Window, "Warning: 重置系统代理超时，继续退出");
                     true
                 }
             }
@@ -206,11 +218,15 @@ pub async fn clean_async() -> bool {
 
         match timeout(stop_timeout, CoreManager::global().stop_core()).await {
             Ok(_) => {
-                log::info!(target: "app", "core已停止");
+                logging!(info, Type::Window, "core已停止");
                 true
             }
             Err(_) => {
-                log::warn!(target: "app", "停止core超时（可能系统正在关机），继续退出");
+                logging!(
+                    warn,
+                    Type::Window,
+                    "Warning: 停止core超时（可能系统正在关机），继续退出"
+                );
                 true
             }
         }
@@ -226,11 +242,11 @@ pub async fn clean_async() -> bool {
         .await
         {
             Ok(_) => {
-                log::info!(target: "app", "DNS设置已恢复");
+                logging!(info, Type::Window, "DNS设置已恢复");
                 true
             }
             Err(_) => {
-                log::warn!(target: "app", "恢复DNS设置超时");
+                logging!(warn, Type::Window, "Warning: 恢复DNS设置超时");
                 false
             }
         }
@@ -300,7 +316,7 @@ pub async fn hide() {
 
     let enable_auto_light_weight_mode = Config::verge()
         .await
-        .data_mut()
+        .latest_arc()
         .enable_auto_light_weight_mode
         .unwrap_or(false);
 

src-tauri/src/lib.rs

@@ -10,6 +10,9 @@ mod feat;
 mod module;
 mod process;
 pub mod utils;
+use crate::constants::files;
+#[cfg(target_os = "macos")]
+use crate::module::lightweight;
 #[cfg(target_os = "linux")]
 use crate::utils::linux;
 #[cfg(target_os = "macos")]
@@ -19,6 +22,7 @@ use crate::{
     process::AsyncHandler,
     utils::{resolve, server},
 };
+use anyhow::Result;
 use config::Config;
 use once_cell::sync::OnceCell;
 use tauri::{AppHandle, Manager};
@@ -28,11 +32,8 @@ use tauri_plugin_deep_link::DeepLinkExt;
 use utils::logging::Type;
 
 pub static APP_HANDLE: OnceCell<AppHandle> = OnceCell::new();
-
 /// Application initialization helper functions
 mod app_init {
-    use anyhow::Result;
-
     use super::*;
 
     /// Initialize singleton monitoring for other instances
@@ -91,14 +92,14 @@ mod app_init {
         }
 
         app.deep_link().on_open_url(|event| {
-            let url = event.urls().first().map(|u| u.to_string());
-            if let Some(url) = url {
-                AsyncHandler::spawn(|| async {
-                    if let Err(e) = resolve::resolve_scheme(url.into()).await {
-                        logging!(error, Type::Setup, "Failed to resolve scheme: {}", e);
-                    }
-                });
-            }
+            let urls = event.urls();
+            AsyncHandler::spawn(move || async move {
+                if let Some(url) = urls.first()
+                    && let Err(e) = resolve::resolve_scheme(url.as_ref()).await
+                {
+                    logging!(error, Type::Setup, "Failed to resolve scheme: {}", e);
+                }
+            });
         });
 
         Ok(())
@@ -115,7 +116,7 @@ mod app_init {
         {
             auto_start_plugin_builder = auto_start_plugin_builder
                 .macos_launcher(MacosLauncher::LaunchAgent)
-                .app_name(app.config().identifier.clone());
+                .app_name(&app.config().identifier);
         }
         app.handle().plugin(auto_start_plugin_builder.build())?;
         Ok(())
@@ -125,7 +126,7 @@ mod app_init {
     pub fn setup_window_state(app: &tauri::App) -> Result<(), Box<dyn std::error::Error>> {
         logging!(info, Type::Setup, "初始化窗口状态管理...");
         let window_state_plugin = tauri_plugin_window_state::Builder::new()
-            .with_filename("window_state.json")
+            .with_filename(files::WINDOW_STATE)
             .with_state_flags(tauri_plugin_window_state::StateFlags::default())
             .build();
         app.handle().plugin(window_state_plugin)?;
@@ -141,6 +142,8 @@ mod app_init {
             cmd::open_logs_dir,
             cmd::open_web_url,
             cmd::open_core_dir,
+            cmd::open_app_log,
+            cmd::open_core_log,
             cmd::get_portable_flag,
             cmd::get_network_interfaces,
             cmd::get_system_hostname,
@@ -285,6 +288,11 @@ pub fn run() {
         pub async fn handle_reopen(has_visible_windows: bool) {
             handle::Handle::global().init();
 
+            if lightweight::is_in_lightweight_mode() {
+                lightweight::exit_lightweight_mode().await;
+                return;
+            }
+
             if !has_visible_windows {
                 handle::Handle::global().set_activation_policy_regular();
                 let _ = WindowManager::show_main_window().await;
@@ -311,7 +319,7 @@ pub fn run() {
             AsyncHandler::spawn(move || async move {
                 let is_enable_global_hotkey = Config::verge()
                     .await
-                    .latest_ref()
+                    .latest_arc()
                     .enable_global_hotkey
                     .unwrap_or(true);
 
@@ -326,10 +334,7 @@ pub fn run() {
                             .register_system_hotkey(SystemHotkey::CmdW)
                             .await;
                     }
-
-                    if !is_enable_global_hotkey {
-                        let _ = hotkey::Hotkey::global().init().await;
-                    }
+                    let _ = hotkey::Hotkey::global().init(true).await;
                     return;
                 }
 
@@ -346,13 +351,21 @@ pub fn run() {
             });
         }
 
+        #[cfg(target_os = "macos")]
         pub fn handle_window_destroyed() {
-            #[cfg(target_os = "macos")]
-            {
-                use crate::core::hotkey::SystemHotkey;
+            use crate::core::hotkey::SystemHotkey;
+            AsyncHandler::spawn(move || async move {
                 let _ = hotkey::Hotkey::global().unregister_system_hotkey(SystemHotkey::CmdQ);
                 let _ = hotkey::Hotkey::global().unregister_system_hotkey(SystemHotkey::CmdW);
-            }
+                let is_enable_global_hotkey = Config::verge()
+                    .await
+                    .latest_arc()
+                    .enable_global_hotkey
+                    .unwrap_or(true);
+                if !is_enable_global_hotkey {
+                    let _ = hotkey::Hotkey::global().reset();
+                }
+            });
         }
     }
 
@@ -432,6 +445,7 @@ pub fn run() {
             tauri::WindowEvent::Focused(focused) => {
                 event_handlers::handle_window_focus(focused);
             }
+            #[cfg(target_os = "macos")]
             tauri::WindowEvent::Destroyed => {
                 event_handlers::handle_window_destroyed();
             }

src-tauri/src/main.rs

@@ -4,12 +4,11 @@ fn main() {
     console_subscriber::init();
 
     // Check for --no-tray command line argument
-    let args: Vec<String> = std::env::args().collect();
-    if args.contains(&"--no-tray".into()) {
+    #[cfg(target_os = "linux")]
+    if std::env::args().any(|x| x == "--no-tray") {
         unsafe {
             std::env::set_var("CLASH_VERGE_DISABLE_TRAY", "1");
         }
     }
-
     app_lib::run();
 }

src-tauri/src/module/lightweight.rs

@@ -28,108 +28,75 @@ enum LightweightState {
 impl From<u8> for LightweightState {
     fn from(v: u8) -> Self {
         match v {
-            1 => LightweightState::In,
-            2 => LightweightState::Exiting,
-            _ => LightweightState::Normal,
+            1 => Self::In,
+            2 => Self::Exiting,
+            _ => Self::Normal,
         }
     }
 }
 
 impl LightweightState {
-    fn as_u8(self) -> u8 {
+    const fn as_u8(self) -> u8 {
         self as u8
     }
 }
 
 static LIGHTWEIGHT_STATE: AtomicU8 = AtomicU8::new(LightweightState::Normal as u8);
 
-static WINDOW_CLOSE_HANDLER: AtomicU32 = AtomicU32::new(0);
-static WEBVIEW_FOCUS_HANDLER: AtomicU32 = AtomicU32::new(0);
-
-fn set_state(new: LightweightState) {
-    LIGHTWEIGHT_STATE.store(new.as_u8(), Ordering::Release);
-    match new {
-        LightweightState::Normal => {
-            logging!(info, Type::Lightweight, "轻量模式已关闭");
-        }
-        LightweightState::In => {
-            logging!(info, Type::Lightweight, "轻量模式已开启");
-        }
-        LightweightState::Exiting => {
-            logging!(info, Type::Lightweight, "正在退出轻量模式");
-        }
-    }
-}
+static WINDOW_CLOSE_HANDLER_ID: AtomicU32 = AtomicU32::new(0);
+static WEBVIEW_FOCUS_HANDLER_ID: AtomicU32 = AtomicU32::new(0);
 
+#[inline]
 fn get_state() -> LightweightState {
     LIGHTWEIGHT_STATE.load(Ordering::Acquire).into()
 }
 
-// 检查是否处于轻量模式
+#[inline]
+fn try_transition(from: LightweightState, to: LightweightState) -> bool {
+    LIGHTWEIGHT_STATE
+        .compare_exchange(
+            from.as_u8(),
+            to.as_u8(),
+            Ordering::AcqRel,
+            Ordering::Relaxed,
+        )
+        .is_ok()
+}
+
+#[inline]
+fn record_state_and_log(state: LightweightState) {
+    LIGHTWEIGHT_STATE.store(state.as_u8(), Ordering::Release);
+    match state {
+        LightweightState::Normal => logging!(info, Type::Lightweight, "轻量模式已关闭"),
+        LightweightState::In => logging!(info, Type::Lightweight, "轻量模式已开启"),
+        LightweightState::Exiting => logging!(info, Type::Lightweight, "正在退出轻量模式"),
+    }
+}
+
+#[inline]
 pub fn is_in_lightweight_mode() -> bool {
     get_state() == LightweightState::In
 }
 
-// 设置轻量模式状态（仅 Normal <-> In）
-async fn set_lightweight_mode(value: bool) {
-    let current = get_state();
-    if value && current != LightweightState::In {
-        set_state(LightweightState::In);
-    } else if !value && current != LightweightState::Normal {
-        set_state(LightweightState::Normal);
-    }
-
-    // 只有在状态可用时才触发托盘更新
-    if let Err(e) = Tray::global().update_part().await {
-        log::warn!("Failed to update tray: {e}");
+async fn refresh_lightweight_tray_state() {
+    if let Err(err) = Tray::global().update_menu().await {
+        logging!(warn, Type::Lightweight, "更新托盘轻量模式状态失败: {err}");
     }
 }
 
-pub async fn run_once_auto_lightweight() {
+pub async fn auto_lightweight_boot() -> Result<()> {
     let verge_config = Config::verge().await;
-    let enable_auto = verge_config
-        .data_mut()
+    let is_enable_auto = verge_config
+        .data_arc()
         .enable_auto_light_weight_mode
         .unwrap_or(false);
-    let is_silent_start = verge_config
-        .latest_ref()
-        .enable_silent_start
-        .unwrap_or(false);
-
-    if !(enable_auto && is_silent_start) {
-        logging!(
-            info,
-            Type::Lightweight,
-            "不满足静默启动且自动进入轻量模式的条件，跳过自动进入轻量模式"
-        );
-        return;
-    }
-
-    set_lightweight_mode(true).await;
-    enable_auto_light_weight_mode().await;
-}
-
-pub async fn auto_lightweight_mode_init() -> Result<()> {
-    let is_silent_start =
-        { Config::verge().await.latest_ref().enable_silent_start }.unwrap_or(false);
-    let enable_auto = {
-        Config::verge()
-            .await
-            .latest_ref()
-            .enable_auto_light_weight_mode
-    }
-    .unwrap_or(false);
-
-    if enable_auto && !is_silent_start {
-        logging!(
-            info,
-            Type::Lightweight,
-            "非静默启动直接挂载自动进入轻量模式监听器！"
-        );
-        set_state(LightweightState::Normal);
+    let is_silent_start = verge_config.data_arc().enable_silent_start.unwrap_or(false);
+    if is_enable_auto {
         enable_auto_light_weight_mode().await;
     }
-
+    if is_silent_start {
+        entry_lightweight_mode().await;
+    }
     Ok(())
 }
 
@@ -151,60 +118,33 @@ pub fn disable_auto_light_weight_mode() {
 }
 
 pub async fn entry_lightweight_mode() -> bool {
-    // 尝试从 Normal -> In
-    if LIGHTWEIGHT_STATE
-        .compare_exchange(
-            LightweightState::Normal as u8,
-            LightweightState::In as u8,
-            Ordering::Acquire,
-            Ordering::Relaxed,
-        )
-        .is_err()
-    {
-        logging!(info, Type::Lightweight, "无需进入轻量模式，跳过调用");
+    if !try_transition(LightweightState::Normal, LightweightState::In) {
+        logging!(debug, Type::Lightweight, "无需进入轻量模式，跳过调用");
+        refresh_lightweight_tray_state().await;
         return false;
     }
-
+    record_state_and_log(LightweightState::In);
     WindowManager::destroy_main_window();
-
-    set_lightweight_mode(true).await;
     let _ = cancel_light_weight_timer();
-
-    // 回到 In
-    set_state(LightweightState::In);
-
+    refresh_lightweight_tray_state().await;
     true
 }
 
-// 添加从轻量模式恢复的函数
 pub async fn exit_lightweight_mode() -> bool {
-    // 尝试从 In -> Exiting
-    if LIGHTWEIGHT_STATE
-        .compare_exchange(
-            LightweightState::In as u8,
-            LightweightState::Exiting as u8,
-            Ordering::Acquire,
-            Ordering::Relaxed,
-        )
-        .is_err()
-    {
+    if !try_transition(LightweightState::In, LightweightState::Exiting) {
         logging!(
-            info,
+            debug,
             Type::Lightweight,
             "轻量模式不在退出条件（可能已退出或正在退出），跳过调用"
         );
+        refresh_lightweight_tray_state().await;
         return false;
     }
-
+    record_state_and_log(LightweightState::Exiting);
     WindowManager::show_main_window().await;
-
-    set_lightweight_mode(false).await;
     let _ = cancel_light_weight_timer();
-
-    // 回到 Normal
-    set_state(LightweightState::Normal);
-
-    logging!(info, Type::Lightweight, "轻量模式退出完成");
+    record_state_and_log(LightweightState::Normal);
+    refresh_lightweight_tray_state().await;
     true
 }
 
@@ -215,70 +155,81 @@ pub async fn add_light_weight_timer() {
 
 fn setup_window_close_listener() {
     if let Some(window) = handle::Handle::get_window() {
-        let handler = window.listen("tauri://close-requested", move |_event| {
+        let handler_id = window.listen("tauri://close-requested", move |_event| {
             std::mem::drop(AsyncHandler::spawn(|| async {
                 if let Err(e) = setup_light_weight_timer().await {
-                    log::warn!("Failed to setup light weight timer: {e}");
+                    logging!(
+                        warn,
+                        Type::Lightweight,
+                        "Warning: Failed to setup light weight timer: {e}"
+                    );
                 }
             }));
             logging!(info, Type::Lightweight, "监听到关闭请求，开始轻量模式计时");
         });
-
-        WINDOW_CLOSE_HANDLER.store(handler, Ordering::Release);
+        WINDOW_CLOSE_HANDLER_ID.store(handler_id, Ordering::Release);
     }
 }
 
 fn cancel_window_close_listener() {
     if let Some(window) = handle::Handle::get_window() {
-        let handler = WINDOW_CLOSE_HANDLER.swap(0, Ordering::AcqRel);
-        if handler != 0 {
-            window.unlisten(handler);
-            logging!(info, Type::Lightweight, "取消了窗口关闭监听");
+        let id = WINDOW_CLOSE_HANDLER_ID.swap(0, Ordering::AcqRel);
+        if id != 0 {
+            window.unlisten(id);
+            logging!(debug, Type::Lightweight, "取消了窗口关闭监听");
         }
     }
 }
 
 fn setup_webview_focus_listener() {
     if let Some(window) = handle::Handle::get_window() {
-        let handler = window.listen("tauri://focus", move |_event| {
+        let handler_id = window.listen("tauri://focus", move |_event| {
             log_err!(cancel_light_weight_timer());
             logging!(
-                info,
+                debug,
                 Type::Lightweight,
                 "监听到窗口获得焦点，取消轻量模式计时"
             );
         });
-
-        WEBVIEW_FOCUS_HANDLER.store(handler, Ordering::Release);
+        WEBVIEW_FOCUS_HANDLER_ID.store(handler_id, Ordering::Release);
     }
 }
 
 fn cancel_webview_focus_listener() {
     if let Some(window) = handle::Handle::get_window() {
-        let handler = WEBVIEW_FOCUS_HANDLER.swap(0, Ordering::AcqRel);
-        if handler != 0 {
-            window.unlisten(handler);
-            logging!(info, Type::Lightweight, "取消了窗口焦点监听");
+        let id = WEBVIEW_FOCUS_HANDLER_ID.swap(0, Ordering::AcqRel);
+        if id != 0 {
+            window.unlisten(id);
+            logging!(debug, Type::Lightweight, "取消了窗口焦点监听");
         }
     }
 }
 
 async fn setup_light_weight_timer() -> Result<()> {
-    Timer::global().init().await?;
+    if let Err(e) = Timer::global().init().await {
+        return Err(e).context("failed to initialize timer");
+    }
+
     let once_by_minutes = Config::verge()
         .await
-        .latest_ref()
+        .data_arc()
         .auto_light_weight_minutes
         .unwrap_or(10);
 
-    // 获取task_id
+    {
+        let timer_map = Timer::global().timer_map.read();
+        if timer_map.contains_key(LIGHT_WEIGHT_TASK_UID) {
+            logging!(debug, Type::Timer, "轻量模式计时器已存在，跳过创建");
+            return Ok(());
+        }
+    }
+
     let task_id = {
         Timer::global()
             .timer_count
             .fetch_add(1, std::sync::atomic::Ordering::Relaxed)
     };
 
-    // 创建任务
     let task = TaskBuilder::default()
         .set_task_id(task_id)
         .set_maximum_parallel_runnable_num(1)
@@ -289,7 +240,6 @@ async fn setup_light_weight_timer() -> Result<()> {
         })
         .context("failed to create timer task")?;
 
-    // 添加任务到定时器
     {
         let delay_timer = Timer::global().delay_timer.write();
         delay_timer
@@ -297,7 +247,6 @@ async fn setup_light_weight_timer() -> Result<()> {
             .context("failed to add timer task")?;
     }
 
-    // 更新任务映射
     {
         let mut timer_map = Timer::global().timer_map.write();
         let timer_task = crate::core::timer::TimerTask {
@@ -319,14 +268,17 @@ async fn setup_light_weight_timer() -> Result<()> {
 }
 
 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
+    let value = Timer::global()
+        .timer_map
+        .write()
+        .remove(LIGHT_WEIGHT_TASK_UID);
+    if let Some(task) = value {
+        Timer::global()
+            .delay_timer
+            .write()
             .remove_task(task.task_id)
             .context("failed to remove timer task")?;
-        logging!(info, Type::Timer, "计时器已取消");
+        logging!(debug, Type::Timer, "计时器已取消");
     }
 
     Ok(())

src-tauri/src/process/guard.rs

@@ -1,19 +1,26 @@
 use anyhow::Result;
 use tauri_plugin_shell::process::CommandChild;
 
+use crate::{logging, utils::logging::Type};
+
 #[derive(Debug)]
 pub struct CommandChildGuard(Option<CommandChild>);
 
 impl Drop for CommandChildGuard {
     fn drop(&mut self) {
         if let Err(err) = self.kill() {
-            log::error!(target: "app", "Failed to kill child process: {}", err);
+            logging!(
+                error,
+                Type::Service,
+                "Failed to kill child process: {}",
+                err
+            );
         }
     }
 }
 
 impl CommandChildGuard {
-    pub fn new(child: CommandChild) -> Self {
+    pub const fn new(child: CommandChild) -> Self {
         Self(Some(child))
     }
 

src-tauri/src/utils/autostart.rs

@@ -1,7 +1,7 @@
 #[cfg(target_os = "windows")]
+use crate::{logging, utils::logging::Type};
+#[cfg(target_os = "windows")]
 use anyhow::{Result, anyhow};
-#[cfg(target_os = "windows")]
-use log::info;
 
 #[cfg(target_os = "windows")]
 use std::{os::windows::process::CommandExt, path::Path, path::PathBuf};
@@ -49,15 +49,15 @@ pub async fn create_shortcut() -> Result<()> {
         .remove_if_exists()
         .await
         .inspect(|_| {
-            info!(target: "app", "成功移除旧启动快捷方式");
+            logging!(info, Type::Setup, "成功移除旧启动快捷方式");
         })
         .inspect_err(|err| {
-            log::error!(target: "app", "移除旧启动快捷方式失败: {err}");
+            logging!(error, Type::Setup, "移除旧启动快捷方式失败: {err}");
         });
 
     // 如果新快捷方式已存在，直接返回成功
     if new_shortcut_path.exists() {
-        info!(target: "app", "启动快捷方式已存在");
+        logging!(info, Type::Setup, "启动快捷方式已存在");
         return Ok(());
     }
 
@@ -83,7 +83,7 @@ pub async fn create_shortcut() -> Result<()> {
         return Err(anyhow!("创建快捷方式失败: {}", error_msg));
     }
 
-    info!(target: "app", "成功创建启动快捷方式");
+    logging!(info, Type::Setup, "成功创建启动快捷方式");
     Ok(())
 }
 
@@ -102,22 +102,22 @@ pub async fn remove_shortcut() -> Result<()> {
         .remove_if_exists()
         .await
         .inspect(|_| {
-            info!(target: "app", "成功删除旧启动快捷方式");
+            logging!(info, Type::Setup, "成功删除旧启动快捷方式");
             removed_any = true;
         })
         .inspect_err(|err| {
-            log::error!(target: "app", "删除旧启动快捷方式失败: {err}");
+            logging!(error, Type::Setup, "删除旧启动快捷方式失败: {err}");
         });
 
     let _ = new_shortcut_path
         .remove_if_exists()
         .await
         .inspect(|_| {
-            info!(target: "app", "成功删除启动快捷方式");
+            logging!(info, Type::Setup, "成功删除启动快捷方式");
             removed_any = true;
         })
         .inspect_err(|err| {
-            log::error!(target: "app", "删除启动快捷方式失败: {err}");
+            logging!(error, Type::Setup, "删除启动快捷方式失败: {err}");
         });
 
     Ok(())

src-tauri/src/utils/dirs.rs

@@ -1,7 +1,13 @@
-use crate::{core::handle, logging, utils::logging::Type};
+use crate::{
+    core::{CoreManager, handle, manager::RunningMode},
+    logging,
+    utils::logging::Type,
+};
 use anyhow::Result;
 use async_trait::async_trait;
 use once_cell::sync::OnceCell;
+#[cfg(unix)]
+use std::iter;
 use std::{fs, path::PathBuf};
 use tauri::Manager;
 
@@ -20,7 +26,6 @@ pub static PORTABLE_FLAG: OnceCell<bool> = OnceCell::new();
 pub static CLASH_CONFIG: &str = "config.yaml";
 pub static VERGE_CONFIG: &str = "verge.yaml";
 pub static PROFILE_YAML: &str = "profiles.yaml";
-pub static DNS_CONFIG: &str = "dns_config.yaml";
 
 /// init portable flag
 pub fn init_portable_flag() -> Result<()> {
@@ -58,7 +63,11 @@ pub fn app_home_dir() -> Result<PathBuf> {
     match app_handle.path().data_dir() {
         Ok(dir) => Ok(dir.join(APP_ID)),
         Err(e) => {
-            log::error!(target: "app", "Failed to get the app home directory: {e}");
+            logging!(
+                error,
+                Type::File,
+                "Failed to get the app home directory: {e}"
+            );
             Err(anyhow::anyhow!("Failed to get the app homedirectory"))
         }
     }
@@ -72,7 +81,11 @@ pub fn app_resources_dir() -> Result<PathBuf> {
     match app_handle.path().resource_dir() {
         Ok(dir) => Ok(dir.join("resources")),
         Err(e) => {
-            log::error!(target: "app", "Failed to get the resource directory: {e}");
+            logging!(
+                error,
+                Type::File,
+                "Failed to get the resource directory: {e}"
+            );
             Err(anyhow::anyhow!("Failed to get the resource directory"))
         }
     }
@@ -122,6 +135,11 @@ pub fn app_logs_dir() -> Result<PathBuf> {
     Ok(app_home_dir()?.join("logs"))
 }
 
+// latest verge log
+pub fn app_latest_log() -> Result<PathBuf> {
+    Ok(app_logs_dir()?.join("latest.log"))
+}
+
 /// local backups dir
 pub fn local_backup_dir() -> Result<PathBuf> {
     let dir = app_home_dir()?.join(BACKUP_DIR);
@@ -167,6 +185,15 @@ pub fn service_log_dir() -> Result<PathBuf> {
     Ok(log_dir)
 }
 
+pub fn clash_latest_log() -> Result<PathBuf> {
+    match *CoreManager::global().get_running_mode() {
+        RunningMode::Service => Ok(service_log_dir()?.join("service_latest.log")),
+        RunningMode::Sidecar | RunningMode::NotRunning => {
+            Ok(sidecar_log_dir()?.join("sidecar_latest.log"))
+        }
+    }
+}
+
 pub fn path_to_str(path: &PathBuf) -> Result<&str> {
     let path_str = path
         .as_os_str()
@@ -201,8 +228,7 @@ pub fn get_encryption_key() -> Result<Vec<u8>> {
 
 #[cfg(unix)]
 pub fn ensure_mihomo_safe_dir() -> Option<PathBuf> {
-    ["/tmp"]
-        .iter()
+    iter::once("/tmp")
         .map(PathBuf::from)
         .find(|path| path.exists())
         .or_else(|| {
@@ -211,7 +237,11 @@ pub fn ensure_mihomo_safe_dir() -> Option<PathBuf> {
                 if home_config.exists() || fs::create_dir_all(&home_config).is_ok() {
                     Some(home_config)
                 } else {
-                    log::error!(target: "app", "Failed to create safe directory: {home_config:?}");
+                    logging!(
+                        error,
+                        Type::File,
+                        "Failed to create safe directory: {home_config:?}"
+                    );
                     None
                 }
             })

src-tauri/src/utils/draft.rs

@@ -1,178 +1,369 @@
+use parking_lot::RwLock;
 use std::sync::Arc;
 
-use parking_lot::{
-    MappedRwLockReadGuard, MappedRwLockWriteGuard, RwLock, RwLockReadGuard,
-    RwLockUpgradableReadGuard, RwLockWriteGuard,
-};
+pub type SharedBox<T> = Arc<Box<T>>;
+type DraftInner<T> = (SharedBox<T>, Option<SharedBox<T>>);
 
+/// Draft 管理：committed 与 optional draft 都以 Arc<Box<T>> 存储，
+// (committed_snapshot, optional_draft_snapshot)
 #[derive(Debug, Clone)]
-pub struct Draft<T: Clone + ToOwned> {
-    inner: Arc<RwLock<(T, Option<T>)>>,
+pub struct Draft<T: Clone> {
+    inner: Arc<RwLock<DraftInner<T>>>,
 }
 
-impl<T: Clone + ToOwned> From<T> for Draft<T> {
-    fn from(data: T) -> Self {
+impl<T: Clone> Draft<T> {
+    pub fn new(data: T) -> Self {
         Self {
-            inner: Arc::new(RwLock::new((data, None))),
+            inner: Arc::new(RwLock::new((Arc::new(Box::new(data)), None))),
         }
     }
-}
-
-/// Implements draft management for `Box<T>`, allowing for safe concurrent editing and committing of draft data.
-/// # Type Parameters
-/// - `T`: The underlying data type, which must implement `Clone` and `ToOwned`.
-///
-/// # Methods
-/// - `data_mut`: Returns a mutable reference to the committed data.
-/// - `data_ref`: Returns an immutable reference to the committed data.
-/// - `draft_mut`: Creates or retrieves a mutable reference to the draft data, cloning the committed data if no draft exists.
-/// - `latest_ref`: Returns an immutable reference to the draft data if it exists, otherwise to the committed data.
-/// - `apply`: Commits the draft data, replacing the committed data and returning the old committed value if a draft existed.
-/// - `discard`: Discards the draft data and returns it if it existed.
-impl<T: Clone + ToOwned> Draft<Box<T>> {
-    /// 可写正式数据
-    pub fn data_mut(&self) -> MappedRwLockWriteGuard<'_, Box<T>> {
-        RwLockWriteGuard::map(self.inner.write(), |inner| &mut inner.0)
+    /// 以 Arc<Box<T>> 的形式获取当前“已提交（正式）”数据的快照（零拷贝，仅 clone Arc）
+    pub fn data_arc(&self) -> SharedBox<T> {
+        let guard = self.inner.read();
+        Arc::clone(&guard.0)
     }
 
-    /// 返回正式数据的只读视图（不包含草稿）
-    pub fn data_ref(&self) -> MappedRwLockReadGuard<'_, Box<T>> {
-        RwLockReadGuard::map(self.inner.read(), |inner| &inner.0)
-    }
-
-    /// 创建或获取草稿并返回可写引用
-    pub fn draft_mut(&self) -> MappedRwLockWriteGuard<'_, Box<T>> {
-        let guard = self.inner.upgradable_read();
-        if guard.1.is_none() {
-            let mut guard = RwLockUpgradableReadGuard::upgrade(guard);
-            guard.1 = Some(guard.0.clone());
-            return RwLockWriteGuard::map(guard, |inner| {
-                inner.1.as_mut().unwrap_or_else(|| {
-                    unreachable!("Draft was just created above, this should never fail")
-                })
-            });
-        }
-        // 已存在草稿，升级为写锁映射
-        RwLockWriteGuard::map(RwLockUpgradableReadGuard::upgrade(guard), |inner| {
-            inner
-                .1
-                .as_mut()
-                .unwrap_or_else(|| unreachable!("Draft should exist when guard.1.is_some()"))
-        })
-    }
-
-    /// 零拷贝只读视图：返回草稿(若存在)或正式值
-    pub fn latest_ref(&self) -> MappedRwLockReadGuard<'_, Box<T>> {
-        RwLockReadGuard::map(self.inner.read(), |inner| {
-            inner.1.as_ref().unwrap_or(&inner.0)
-        })
-    }
-
-    /// 提交草稿，返回旧正式数据
-    pub fn apply(&self) -> Option<Box<T>> {
-        let mut inner = self.inner.write();
-        inner
+    /// 获取当前（草稿若存在则返回草稿，否则返回已提交）的快照
+    /// 这也是零拷贝：只 clone Arc，不 clone T
+    pub fn latest_arc(&self) -> SharedBox<T> {
+        let guard = self.inner.read();
+        guard
             .1
-            .take()
-            .map(|draft| std::mem::replace(&mut inner.0, draft))
+            .as_ref()
+            .cloned()
+            .unwrap_or_else(|| Arc::clone(&guard.0))
     }
 
-    /// 丢弃草稿，返回被丢弃的草稿
-    pub fn discard(&self) -> Option<Box<T>> {
-        self.inner.write().1.take()
+    /// 通过闭包以可变方式编辑草稿（在闭包中我们给出 &mut T）
+    /// - 延迟拷贝：如果只有这一个 Arc 引用，则直接修改，不会克隆 T；
+    /// - 若草稿被其他读者共享，Arc::make_mut 会做一次 T.clone（最小必要拷贝）。
+    pub fn edit_draft<F, R>(&self, f: F) -> R
+    where
+        F: FnOnce(&mut T) -> R,
+    {
+        // 先获得写锁以创建或取出草稿 Arc 的可变引用位置
+        let mut guard = self.inner.write();
+        let mut draft_arc = if guard.1.is_none() {
+            Arc::clone(&guard.0)
+        } else {
+            #[allow(clippy::unwrap_used)]
+            guard.1.take().unwrap()
+        };
+        drop(guard);
+        // Arc::make_mut: 如果只有一个引用则返回可变引用；否则会克隆底层 Box<T>（要求 T: Clone）
+        let boxed = Arc::make_mut(&mut draft_arc); // &mut Box<T>
+        // 对 Box<T> 解引用得到 &mut T
+        let result = f(&mut **boxed);
+        // 恢复修改后的草稿 Arc
+        self.inner.write().1 = Some(draft_arc);
+        result
     }
 
-    /// 异步修改正式数据，闭包直接获得 Box<T> 所有权
-    pub async fn with_data_modify<F, Fut, R, E>(&self, f: F) -> Result<R, E>
+    /// 将草稿提交到已提交位置（替换），并清除草稿
+    pub fn apply(&self) {
+        let mut guard = self.inner.write();
+        if let Some(d) = guard.1.take() {
+            guard.0 = d;
+        }
+    }
+
+    /// 丢弃草稿（如果存在）
+    pub fn discard(&self) {
+        let mut guard = self.inner.write();
+        guard.1 = None;
+    }
+
+    /// 异步地以拥有 Box<T> 的方式修改已提交数据：将克隆一次已提交数据到本地，
+    /// 异步闭包返回新的 Box<T>（替换已提交数据）和业务返回值 R。
+    pub async fn with_data_modify<F, Fut, R>(&self, f: F) -> Result<R, anyhow::Error>
     where
         T: Send + Sync + 'static,
         F: FnOnce(Box<T>) -> Fut + Send,
-        Fut: std::future::Future<Output = Result<(Box<T>, R), E>> + Send,
-        E: From<anyhow::Error>,
+        Fut: std::future::Future<Output = Result<(Box<T>, R), anyhow::Error>> + Send,
     {
-        // 克隆正式数据
-        let local = {
+        // 读取已提交快照（cheap Arc clone, 然后得到 Box<T> 所有权 via clone）
+        // 注意：为了让闭包接收 Box<T> 所有权，我们需要 clone 底层 T（不可避免）
+        let local: Box<T> = {
             let guard = self.inner.read();
-            guard.0.clone()
+            // 将 Arc<Box<T>> 的 Box<T> clone 出来（会调用 T: Clone）
+            (*guard.0).clone()
         };
 
-        // 异步闭包执行，返回修改后的 Box<T> 和业务结果 R
         let (new_local, res) = f(local).await?;
 
-        // 写回正式数据
-        let mut guard = self.inner.write();
-        guard.0 = new_local;
+        // 将新的 Box<T> 放到已提交位置（包进 Arc）
+        self.inner.write().0 = Arc::new(new_local);
 
         Ok(res)
     }
 }
 
-#[test]
-fn test_draft_box() {
-    use crate::config::IVerge;
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use anyhow::anyhow;
+    use std::future::Future;
+    use std::pin::Pin;
+    use std::task::{Context, Poll, RawWaker, RawWakerVTable, Waker};
 
-    // 1. 创建 Draft<Box<IVerge>>
-    let verge = Box::new(IVerge {
-        enable_auto_launch: Some(true),
-        enable_tun_mode: Some(false),
-        ..IVerge::default()
-    });
-    let draft = Draft::from(verge);
-
-    // 2. 读取正式数据（data_mut）
-    {
-        let data = draft.data_mut();
-        assert_eq!(data.enable_auto_launch, Some(true));
-        assert_eq!(data.enable_tun_mode, Some(false));
+    #[derive(Clone, Debug, Default, PartialEq)]
+    struct IVerge {
+        enable_auto_launch: Option<bool>,
+        enable_tun_mode: Option<bool>,
     }
 
-    // 3. 初次获取草稿（draft_mut 会自动 clone 一份）
-    {
-        let draft_view = draft.draft_mut();
-        assert_eq!(draft_view.enable_auto_launch, Some(true));
-        assert_eq!(draft_view.enable_tun_mode, Some(false));
+    // Minimal single-threaded executor for immediately-ready futures
+    fn block_on_ready<F: Future>(fut: F) -> F::Output {
+        fn no_op_raw_waker() -> RawWaker {
+            fn clone(_: *const ()) -> RawWaker {
+                no_op_raw_waker()
+            }
+            fn wake(_: *const ()) {}
+            fn wake_by_ref(_: *const ()) {}
+            fn drop(_: *const ()) {}
+            static VTABLE: RawWakerVTable = RawWakerVTable::new(clone, wake, wake_by_ref, drop);
+            RawWaker::new(std::ptr::null(), &VTABLE)
+        }
+
+        let waker = unsafe { Waker::from_raw(no_op_raw_waker()) };
+        let mut cx = Context::from_waker(&waker);
+        let mut fut = Box::pin(fut);
+        loop {
+            match Pin::as_mut(&mut fut).poll(&mut cx) {
+                Poll::Ready(v) => return v,
+                Poll::Pending => std::thread::yield_now(),
+            }
+        }
     }
 
-    // 4. 修改草稿
-    {
-        let mut d = draft.draft_mut();
-        d.enable_auto_launch = Some(false);
-        d.enable_tun_mode = Some(true);
+    #[test]
+    fn test_draft_basic_flow() {
+        let verge = IVerge {
+            enable_auto_launch: Some(true),
+            enable_tun_mode: Some(false),
+        };
+        let draft = Draft::new(verge);
+
+        // 读取正式数据（data_arc）
+        {
+            let data = draft.data_arc();
+            assert_eq!(data.enable_auto_launch, Some(true));
+            assert_eq!(data.enable_tun_mode, Some(false));
+        }
+
+        // 修改草稿（使用 edit_draft）
+        draft.edit_draft(|d| {
+            d.enable_auto_launch = Some(false);
+            d.enable_tun_mode = Some(true);
+        });
+
+        // 正式数据未变
+        {
+            let data = draft.data_arc();
+            assert_eq!(data.enable_auto_launch, Some(true));
+            assert_eq!(data.enable_tun_mode, Some(false));
+        }
+
+        // 草稿已变
+        {
+            let latest = draft.latest_arc();
+            assert_eq!(latest.enable_auto_launch, Some(false));
+            assert_eq!(latest.enable_tun_mode, Some(true));
+        }
+
+        // 提交草稿
+        draft.apply();
+
+        // 正式数据已更新
+        {
+            let data = draft.data_arc();
+            assert_eq!(data.enable_auto_launch, Some(false));
+            assert_eq!(data.enable_tun_mode, Some(true));
+        }
+
+        // 新一轮草稿并修改
+        draft.edit_draft(|d| {
+            d.enable_auto_launch = Some(true);
+        });
+        {
+            let latest = draft.latest_arc();
+            assert_eq!(latest.enable_auto_launch, Some(true));
+            assert_eq!(latest.enable_tun_mode, Some(true));
+        }
+
+        // 丢弃草稿
+        draft.discard();
+
+        // 丢弃后再次创建草稿，会从已提交重新 clone
+        {
+            draft.edit_draft(|d| {
+                // 原 committed 是 enable_auto_launch = Some(false)
+                assert_eq!(d.enable_auto_launch, Some(false));
+                // 再修改一下
+                d.enable_tun_mode = Some(false);
+            });
+            // 草稿中值已修改，但正式数据仍是 apply 后的值
+            let data = draft.data_arc();
+            assert_eq!(data.enable_auto_launch, Some(false));
+            assert_eq!(data.enable_tun_mode, Some(true));
+        }
     }
 
-    // 正式数据未变
-    assert_eq!(draft.data_mut().enable_auto_launch, Some(true));
-    assert_eq!(draft.data_mut().enable_tun_mode, Some(false));
+    #[test]
+    fn test_arc_pointer_behavior_on_edit_and_apply() {
+        let draft = Draft::new(IVerge {
+            enable_auto_launch: Some(true),
+            enable_tun_mode: Some(false),
+        });
 
-    // 草稿已变
-    {
-        let latest = draft.latest_ref();
-        assert_eq!(latest.enable_auto_launch, Some(false));
+        // 初始 latest == committed
+        let committed = draft.data_arc();
+        let latest = draft.latest_arc();
+        assert!(std::sync::Arc::ptr_eq(&committed, &latest));
+
+        // 第一次 edit：由于与 committed 共享，Arc::make_mut 会克隆
+        draft.edit_draft(|d| d.enable_tun_mode = Some(true));
+        let committed_after_first_edit = draft.data_arc();
+        let draft_after_first_edit = draft.latest_arc();
+        assert!(!std::sync::Arc::ptr_eq(
+            &committed_after_first_edit,
+            &draft_after_first_edit
+        ));
+        // 提交会把 committed 指向草稿的 Arc
+        let prev_draft_ptr = std::sync::Arc::as_ptr(&draft_after_first_edit);
+        draft.apply();
+        let committed_after_apply = draft.data_arc();
+        assert_eq!(
+            std::sync::Arc::as_ptr(&committed_after_apply),
+            prev_draft_ptr
+        );
+
+        // 第二次编辑：此时草稿唯一持有（无其它引用），不应再克隆
+        // 获取草稿 Arc 的指针并立即丢弃本地引用，避免增加 strong_count
+        draft.edit_draft(|d| d.enable_auto_launch = Some(false));
+        let latest1 = draft.latest_arc();
+        let latest1_ptr = std::sync::Arc::as_ptr(&latest1);
+        drop(latest1); // 确保只有 Draft 内部持有草稿 Arc
+
+        // 再次编辑（unique，Arc::make_mut 不应克隆）
+        draft.edit_draft(|d| d.enable_tun_mode = Some(false));
+        let latest2 = draft.latest_arc();
+        let latest2_ptr = std::sync::Arc::as_ptr(&latest2);
+
+        assert_eq!(latest1_ptr, latest2_ptr, "Unique edit should not clone Arc");
+        assert_eq!(latest2.enable_auto_launch, Some(false));
+        assert_eq!(latest2.enable_tun_mode, Some(false));
+    }
+
+    #[test]
+    fn test_discard_restores_latest_to_committed() {
+        let draft = Draft::new(IVerge {
+            enable_auto_launch: Some(false),
+            enable_tun_mode: Some(false),
+        });
+
+        // 创建草稿并修改
+        draft.edit_draft(|d| d.enable_auto_launch = Some(true));
+        let committed = draft.data_arc();
+        let latest = draft.latest_arc();
+        assert!(!std::sync::Arc::ptr_eq(&committed, &latest));
+
+        // 丢弃草稿后 latest 应回到 committed
+        draft.discard();
+        let committed2 = draft.data_arc();
+        let latest2 = draft.latest_arc();
+        assert!(std::sync::Arc::ptr_eq(&committed2, &latest2));
+        assert_eq!(latest2.enable_auto_launch, Some(false));
+    }
+
+    #[test]
+    fn test_edit_draft_returns_closure_result() {
+        let draft = Draft::new(IVerge::default());
+        let ret = draft.edit_draft(|d| {
+            d.enable_tun_mode = Some(true);
+            123usize
+        });
+        assert_eq!(ret, 123);
+        let latest = draft.latest_arc();
         assert_eq!(latest.enable_tun_mode, Some(true));
     }
 
-    // 5. 提交草稿
-    assert!(draft.apply().is_some()); // 第一次提交应有返回
-    assert!(draft.apply().is_none()); // 第二次提交返回 None
+    #[test]
+    fn test_with_data_modify_ok_and_replaces_committed() {
+        let draft = Draft::new(IVerge {
+            enable_auto_launch: Some(false),
+            enable_tun_mode: Some(false),
+        });
 
-    // 正式数据已更新
-    {
-        let data = draft.data_mut();
-        assert_eq!(data.enable_auto_launch, Some(false));
-        assert_eq!(data.enable_tun_mode, Some(true));
+        // 使用 with_data_modify 异步（立即就绪）地更新 committed
+        let res = block_on_ready(draft.with_data_modify(|mut v| async move {
+            v.enable_auto_launch = Some(true);
+            Ok((Box::new(*v), "done")) // Dereference v to get Box<T>
+        }));
+        assert_eq!(
+            {
+                #[allow(clippy::unwrap_used)]
+                res.unwrap()
+            },
+            "done"
+        );
+
+        let committed = draft.data_arc();
+        assert_eq!(committed.enable_auto_launch, Some(true));
+        assert_eq!(committed.enable_tun_mode, Some(false));
     }
 
-    // 6. 新建并修改下一轮草稿
-    {
-        let mut d = draft.draft_mut();
-        d.enable_auto_launch = Some(true);
+    #[test]
+    fn test_with_data_modify_error_propagation() {
+        let draft = Draft::new(IVerge::default());
+
+        #[allow(clippy::unwrap_used)]
+        let err = block_on_ready(draft.with_data_modify(|v| async move {
+            drop(v);
+            Err::<(Box<IVerge>, ()), _>(anyhow!("boom"))
+        }))
+        .unwrap_err();
+
+        assert_eq!(format!("{err}"), "boom");
     }
-    assert_eq!(draft.draft_mut().enable_auto_launch, Some(true));
 
-    // 7. 丢弃草稿
-    assert!(draft.discard().is_some()); // 第一次丢弃返回 Some
-    assert!(draft.discard().is_none()); // 再次丢弃返回 None
+    #[test]
+    fn test_with_data_modify_does_not_touch_existing_draft() {
+        let draft = Draft::new(IVerge {
+            enable_auto_launch: Some(false),
+            enable_tun_mode: Some(false),
+        });
 
-    // 8. 草稿已被丢弃，新的 draft_mut() 会重新 clone
-    assert_eq!(draft.draft_mut().enable_auto_launch, Some(false));
+        // 创建草稿并修改
+        draft.edit_draft(|d| {
+            d.enable_auto_launch = Some(true);
+            d.enable_tun_mode = Some(true);
+        });
+        let draft_before = draft.latest_arc();
+        let draft_before_ptr = std::sync::Arc::as_ptr(&draft_before);
+
+        // 同时通过 with_data_modify 修改 committed
+        #[allow(clippy::unwrap_used)]
+        block_on_ready(draft.with_data_modify(|mut v| async move {
+            v.enable_auto_launch = Some(false); // 与草稿不同
+            Ok((Box::new(*v), ())) // Dereference v to get Box<T>
+        }))
+        .unwrap();
+
+        // 草稿应保持不变
+        let draft_after = draft.latest_arc();
+        assert_eq!(
+            std::sync::Arc::as_ptr(&draft_after),
+            draft_before_ptr,
+            "Existing draft should not be replaced by with_data_modify"
+        );
+        assert_eq!(draft_after.enable_auto_launch, Some(true));
+        assert_eq!(draft_after.enable_tun_mode, Some(true));
+
+        // 丢弃草稿后 latest == committed，且 committed 为异步修改结果
+        draft.discard();
+        let latest = draft.latest_arc();
+        assert_eq!(latest.enable_auto_launch, Some(false));
+        assert_eq!(latest.enable_tun_mode, Some(false));
+    }
 }

src-tauri/src/utils/help.rs

@@ -1,4 +1,4 @@
-use crate::{enhance::seq::SeqMap, logging, utils::logging::Type};
+use crate::{config::with_encryption, enhance::seq::SeqMap, logging, utils::logging::Type};
 use anyhow::{Context, Result, anyhow, bail};
 use nanoid::nanoid;
 use serde::{Serialize, de::DeserializeOwned};
@@ -13,7 +13,7 @@ pub async fn read_yaml<T: DeserializeOwned>(path: &PathBuf) -> Result<T> {
 
     let yaml_str = tokio::fs::read_to_string(path).await?;
 
-    Ok(serde_yaml_ng::from_str::<T>(&yaml_str)?)
+    Ok(with_encryption(|| async { serde_yaml_ng::from_str::<T>(&yaml_str) }).await?)
 }
 
 /// read mapping from yaml
@@ -65,7 +65,7 @@ pub async fn save_yaml<T: Serialize + Sync>(
     data: &T,
     prefix: Option<&str>,
 ) -> Result<()> {
-    let data_str = serde_yaml_ng::to_string(data)?;
+    let data_str = with_encryption(|| async { serde_yaml_ng::to_string(data) }).await?;
 
     let yaml_str = match prefix {
         Some(prefix) => format!("{prefix}\n\n{data_str}"),

src-tauri/src/utils/i18n.rs

@@ -43,7 +43,7 @@ pub fn get_supported_languages() -> Vec<String> {
 pub async fn current_language() -> String {
     Config::verge()
         .await
-        .latest_ref()
+        .latest_arc()
         .language
         .as_deref()
         .map(String::from)

src-tauri/src/utils/init.rs

@@ -1,8 +1,9 @@
-#[cfg(not(feature = "tracing"))]
+// #[cfg(not(feature = "tracing"))]
 #[cfg(not(feature = "tauri-dev"))]
 use crate::utils::logging::NoModuleFilter;
 use crate::{
     config::*,
+    constants,
     core::handle,
     logging,
     process::AsyncHandler,
@@ -30,7 +31,7 @@ pub async fn init_logger() -> Result<()> {
     // TODO 提供 runtime 级别实时修改
     let (log_level, log_max_size, log_max_count) = {
         let verge_guard = Config::verge().await;
-        let verge = verge_guard.latest_ref();
+        let verge = verge_guard.latest_arc();
         (
             verge.get_log_level(),
             verge.app_log_max_size.unwrap_or(128),
@@ -48,7 +49,9 @@ pub async fn init_logger() -> Result<()> {
     #[cfg(feature = "tracing")]
     spec.module("tauri", log::LevelFilter::Debug);
     #[cfg(feature = "tracing")]
-    spec.module("wry", log::LevelFilter::Debug);
+    spec.module("wry", log::LevelFilter::Off);
+    #[cfg(feature = "tracing")]
+    spec.module("tauri_plugin_mihomo", log::LevelFilter::Off);
     let spec = spec.build();
 
     let logger = Logger::with(spec)
@@ -66,6 +69,12 @@ pub async fn init_logger() -> Result<()> {
         );
     #[cfg(not(feature = "tracing"))]
     let logger = logger.filter(Box::new(NoModuleFilter(&["wry", "tauri"])));
+    #[cfg(feature = "tracing")]
+    let logger = logger.filter(Box::new(NoModuleFilter(&[
+        "wry",
+        "tauri_plugin_mihomo",
+        "kode_bridge",
+    ])));
 
     let _handle = logger.start()?;
 
@@ -80,7 +89,7 @@ pub async fn init_logger() -> Result<()> {
 pub async fn sidecar_writer() -> Result<FileLogWriter> {
     let (log_max_size, log_max_count) = {
         let verge_guard = Config::verge().await;
-        let verge = verge_guard.latest_ref();
+        let verge = verge_guard.latest_arc();
         (
             verge.app_log_max_size.unwrap_or(128),
             verge.app_log_max_count.unwrap_or(8),
@@ -108,7 +117,7 @@ pub async fn sidecar_writer() -> Result<FileLogWriter> {
 pub async fn service_writer_config() -> Result<WriterConfig> {
     let (log_max_size, log_max_count) = {
         let verge_guard = Config::verge().await;
-        let verge = verge_guard.latest_ref();
+        let verge = verge_guard.latest_arc();
         (
             verge.app_log_max_size.unwrap_or(128),
             verge.app_log_max_count.unwrap_or(8),
@@ -133,7 +142,7 @@ pub async fn delete_log() -> Result<()> {
 
     let auto_log_clean = {
         let verge = Config::verge().await;
-        let verge = verge.latest_ref();
+        let verge = verge.latest_arc();
         verge.auto_log_clean.unwrap_or(0)
     };
 
@@ -304,7 +313,7 @@ async fn init_dns_config() -> Result<()> {
 
     // 检查DNS配置文件是否存在
     let app_dir = dirs::app_home_dir()?;
-    let dns_path = app_dir.join("dns_config.yaml");
+    let dns_path = app_dir.join(constants::files::DNS_CONFIG);
 
     if !dns_path.exists() {
         logging!(info, Type::Setup, "Creating default DNS config file");
@@ -364,7 +373,7 @@ async fn initialize_config_files() -> Result<()> {
     if let Ok(path) = dirs::profiles_path()
         && !path.exists()
     {
-        let template = IProfiles::template();
+        let template = IProfiles::default();
         help::save_yaml(&path, &template, Some("# Clash Verge"))
             .await
             .map_err(|e| anyhow::anyhow!("Failed to create profiles config: {}", e))?;
@@ -429,26 +438,8 @@ pub async fn init_resources() -> Result<()> {
         let src_path = res_dir.join(file);
         let dest_path = app_dir.join(file);
 
-        let handle_copy = |src: PathBuf, dest: PathBuf, file: String| async move {
-            match fs::copy(&src, &dest).await {
-                Ok(_) => {
-                    logging!(debug, Type::Setup, "resources copied '{}'", file);
-                }
-                Err(err) => {
-                    logging!(
-                        error,
-                        Type::Setup,
-                        "failed to copy resources '{}' to '{:?}', {}",
-                        file,
-                        dest,
-                        err
-                    );
-                }
-            };
-        };
-
         if src_path.exists() && !dest_path.exists() {
-            handle_copy(src_path.clone(), dest_path.clone(), (*file).into()).await;
+            handle_copy(&src_path, &dest_path, file).await;
             continue;
         }
 
@@ -458,12 +449,12 @@ pub async fn init_resources() -> Result<()> {
         match (src_modified, dest_modified) {
             (Ok(src_modified), Ok(dest_modified)) => {
                 if src_modified > dest_modified {
-                    handle_copy(src_path.clone(), dest_path.clone(), (*file).into()).await;
+                    handle_copy(&src_path, &dest_path, file).await;
                 }
             }
             _ => {
                 logging!(debug, Type::Setup, "failed to get modified '{}'", file);
-                handle_copy(src_path.clone(), dest_path.clone(), (*file).into()).await;
+                handle_copy(&src_path, &dest_path, file).await;
             }
         };
     }
@@ -515,7 +506,7 @@ pub fn init_scheme() -> Result<()> {
     Ok(())
 }
 #[cfg(target_os = "macos")]
-pub fn init_scheme() -> Result<()> {
+pub const fn init_scheme() -> Result<()> {
     Ok(())
 }
 
@@ -526,7 +517,7 @@ pub async fn startup_script() -> Result<()> {
     let app_handle = handle::Handle::app_handle();
     let script_path = {
         let verge = Config::verge().await;
-        let verge = verge.latest_ref();
+        let verge = verge.latest_arc();
         verge.startup_script.clone().unwrap_or_else(|| "".into())
     };
 
@@ -563,3 +554,21 @@ pub async fn startup_script() -> Result<()> {
 
     Ok(())
 }
+
+async fn handle_copy(src: &PathBuf, dest: &PathBuf, file: &str) {
+    match fs::copy(src, dest).await {
+        Ok(_) => {
+            logging!(debug, Type::Setup, "resources copied '{}'", file);
+        }
+        Err(err) => {
+            logging!(
+                error,
+                Type::Setup,
+                "failed to copy resources '{}' to '{:?}', {}",
+                file,
+                dest,
+                err
+            );
+        }
+    };
+}

src-tauri/src/utils/linux.rs

@@ -19,7 +19,7 @@ struct IntelGpuDetection {
 }
 
 impl IntelGpuDetection {
-    fn should_disable_dmabuf(&self) -> bool {
+    const fn should_disable_dmabuf(&self) -> bool {
         self.intel_is_primary || self.inconclusive
     }
 }
@@ -41,7 +41,7 @@ enum NvidiaDmabufDisableReason {
 }
 
 impl NvidiaGpuDetection {
-    fn disable_reason(&self, session: &SessionEnv) -> Option<NvidiaDmabufDisableReason> {
+    const fn disable_reason(&self, session: &SessionEnv) -> Option<NvidiaDmabufDisableReason> {
         if !session.is_wayland {
             return None;
         }
@@ -144,11 +144,11 @@ impl DmabufOverrides {
         }
     }
 
-    fn has_env_override(&self) -> bool {
+    const fn has_env_override(&self) -> bool {
         self.dmabuf_override.is_some()
     }
 
-    fn should_override_env(&self, decision: &DmabufDecision) -> bool {
+    const fn should_override_env(&self, decision: &DmabufDecision) -> bool {
         if self.user_preference.is_some() {
             return true;
         }

src-tauri/src/utils/logging.rs

@@ -29,7 +29,6 @@ pub enum Type {
     Lightweight,
     Network,
     ProxyMode,
-    // Cache,
     Validate,
     ClashVergeRev,
 }
@@ -37,25 +36,24 @@ pub enum Type {
 impl fmt::Display for Type {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Type::Cmd => write!(f, "[Cmd]"),
-            Type::Core => write!(f, "[Core]"),
-            Type::Config => write!(f, "[Config]"),
-            Type::Setup => write!(f, "[Setup]"),
-            Type::System => write!(f, "[System]"),
-            Type::Service => write!(f, "[Service]"),
-            Type::Hotkey => write!(f, "[Hotkey]"),
-            Type::Window => write!(f, "[Window]"),
-            Type::Tray => write!(f, "[Tray]"),
-            Type::Timer => write!(f, "[Timer]"),
-            Type::Frontend => write!(f, "[Frontend]"),
-            Type::Backup => write!(f, "[Backup]"),
-            Type::File => write!(f, "[File]"),
-            Type::Lightweight => write!(f, "[Lightweight]"),
-            Type::Network => write!(f, "[Network]"),
-            Type::ProxyMode => write!(f, "[ProxMode]"),
-            // Type::Cache => write!(f, "[Cache]"),
-            Type::Validate => write!(f, "[Validate]"),
-            Type::ClashVergeRev => write!(f, "[ClashVergeRev]"),
+            Self::Cmd => write!(f, "[Cmd]"),
+            Self::Core => write!(f, "[Core]"),
+            Self::Config => write!(f, "[Config]"),
+            Self::Setup => write!(f, "[Setup]"),
+            Self::System => write!(f, "[System]"),
+            Self::Service => write!(f, "[Service]"),
+            Self::Hotkey => write!(f, "[Hotkey]"),
+            Self::Window => write!(f, "[Window]"),
+            Self::Tray => write!(f, "[Tray]"),
+            Self::Timer => write!(f, "[Timer]"),
+            Self::Frontend => write!(f, "[Frontend]"),
+            Self::Backup => write!(f, "[Backup]"),
+            Self::File => write!(f, "[File]"),
+            Self::Lightweight => write!(f, "[Lightweight]"),
+            Self::Network => write!(f, "[Network]"),
+            Self::ProxyMode => write!(f, "[ProxMode]"),
+            Self::Validate => write!(f, "[Validate]"),
+            Self::ClashVergeRev => write!(f, "[ClashVergeRev]"),
         }
     }
 }
@@ -82,15 +80,6 @@ macro_rules! log_err {
     };
 }
 
-#[macro_export]
-macro_rules! trace_err {
-    ($result: expr, $err_str: expr) => {
-        if let Err(err) = $result {
-            log::trace!(target: "app", "{}, err {}", $err_str, err);
-        }
-    }
-}
-
 /// wrap the anyhow error
 /// transform the error to String
 #[macro_export]

src-tauri/src/utils/network.rs

@@ -1,6 +1,7 @@
 use crate::config::Config;
 use anyhow::Result;
 use base64::{Engine as _, engine::general_purpose};
+use isahc::config::DnsCache;
 use isahc::prelude::*;
 use isahc::{HttpClient, config::SslOption};
 use isahc::{
@@ -25,7 +26,7 @@ pub struct HttpResponse {
 }
 
 impl HttpResponse {
-    pub fn new(status: StatusCode, headers: HeaderMap, body: String) -> Self {
+    pub const fn new(status: StatusCode, headers: HeaderMap, body: String) -> Self {
         Self {
             status,
             headers,
@@ -33,11 +34,11 @@ impl HttpResponse {
         }
     }
 
-    pub fn status(&self) -> StatusCode {
+    pub const fn status(&self) -> StatusCode {
         self.status
     }
 
-    pub fn headers(&self) -> &HeaderMap {
+    pub const fn headers(&self) -> &HeaderMap {
         &self.headers
     }
 
@@ -79,8 +80,7 @@ impl NetworkManager {
     }
 
     async fn record_connection_error(&self, error: &str) {
-        let mut last_error = self.last_connection_error.lock().await;
-        *last_error = Some((Instant::now(), error.into()));
+        *self.last_connection_error.lock().await = Some((Instant::now(), error.into()));
 
         let mut count = self.connection_error_count.lock().await;
         *count += 1;
@@ -88,13 +88,11 @@ impl NetworkManager {
 
     async fn should_reset_clients(&self) -> bool {
         let count = *self.connection_error_count.lock().await;
-        let last_error_guard = self.last_connection_error.lock().await;
-
         if count > 5 {
             return true;
         }
 
-        if let Some((time, _)) = &*last_error_guard
+        if let Some((time, _)) = &*self.last_connection_error.lock().await
             && time.elapsed() < Duration::from_secs(30)
             && count > 2
         {
@@ -118,18 +116,15 @@ impl NetworkManager {
         accept_invalid_certs: bool,
         timeout_secs: Option<u64>,
     ) -> Result<HttpClient> {
-        let proxy_uri_clone = proxy_uri.clone();
-        let headers_clone = default_headers.clone();
-
         {
             let mut builder = HttpClient::builder();
 
-            builder = match proxy_uri_clone {
+            builder = match proxy_uri {
                 Some(uri) => builder.proxy(Some(uri)),
                 None => builder.proxy(None),
             };
 
-            for (name, value) in headers_clone.iter() {
+            for (name, value) in default_headers.iter() {
                 builder = builder.default_header(name, value);
             }
 
@@ -143,6 +138,12 @@ impl NetworkManager {
 
             builder = builder.redirect_policy(RedirectPolicy::Follow);
 
+            // 禁用缓存，不关心连接复用
+            builder = builder.connection_cache_size(0);
+
+            // 禁用 DNS 缓存，避免因 DNS 变化导致的问题
+            builder = builder.dns_cache(DnsCache::Disable);
+
             Ok(builder.build()?)
         }
     }
@@ -158,10 +159,10 @@ impl NetworkManager {
             ProxyType::None => None,
             ProxyType::Localhost => {
                 let port = {
-                    let verge_port = Config::verge().await.latest_ref().verge_mixed_port;
+                    let verge_port = Config::verge().await.latest_arc().verge_mixed_port;
                     match verge_port {
                         Some(port) => port,
-                        None => Config::clash().await.latest_ref().get_mixed_port(),
+                        None => Config::clash().await.latest_arc().get_mixed_port(),
                     }
                 };
                 let proxy_scheme = format!("http://127.0.0.1:{port}");

src-tauri/src/utils/notification.rs

@@ -1,6 +1,5 @@
-use crate::utils::i18n::t;
+use crate::{core::handle, utils::i18n::t};
 
-use tauri::AppHandle;
 use tauri_plugin_notification::NotificationExt;
 
 pub enum NotificationEvent<'a> {
@@ -16,8 +15,10 @@ pub enum NotificationEvent<'a> {
     AppHidden,
 }
 
-fn notify(app: &AppHandle, title: &str, body: &str) {
-    app.notification()
+fn notify(title: &str, body: &str) {
+    let app_handle = handle::Handle::app_handle();
+    app_handle
+        .notification()
         .builder()
         .title(title)
         .body(body)
@@ -25,49 +26,44 @@ fn notify(app: &AppHandle, title: &str, body: &str) {
         .ok();
 }
 
-pub async fn notify_event<'a>(app: AppHandle, event: NotificationEvent<'a>) {
+pub async fn notify_event<'a>(event: NotificationEvent<'a>) {
     match event {
         NotificationEvent::DashboardToggled => {
             notify(
-                &app,
                 &t("DashboardToggledTitle").await,
                 &t("DashboardToggledBody").await,
             );
         }
         NotificationEvent::ClashModeChanged { mode } => {
             notify(
-                &app,
                 &t("ClashModeChangedTitle").await,
                 &t_with_args("ClashModeChangedBody", mode).await,
             );
         }
         NotificationEvent::SystemProxyToggled => {
             notify(
-                &app,
                 &t("SystemProxyToggledTitle").await,
                 &t("SystemProxyToggledBody").await,
             );
         }
         NotificationEvent::TunModeToggled => {
             notify(
-                &app,
                 &t("TunModeToggledTitle").await,
                 &t("TunModeToggledBody").await,
             );
         }
         NotificationEvent::LightweightModeEntered => {
             notify(
-                &app,
                 &t("LightweightModeEnteredTitle").await,
                 &t("LightweightModeEnteredBody").await,
             );
         }
         NotificationEvent::AppQuit => {
-            notify(&app, &t("AppQuitTitle").await, &t("AppQuitBody").await);
+            notify(&t("AppQuitTitle").await, &t("AppQuitBody").await);
         }
         #[cfg(target_os = "macos")]
         NotificationEvent::AppHidden => {
-            notify(&app, &t("AppHiddenTitle").await, &t("AppHiddenBody").await);
+            notify(&t("AppHiddenTitle").await, &t("AppHiddenBody").await);
         }
     }
 }

src-tauri/src/utils/resolve/dns.rs

@@ -1,20 +1,27 @@
 #[cfg(target_os = "macos")]
+use crate::{logging, utils::logging::Type};
 pub async fn set_public_dns(dns_server: String) {
-    use crate::{core::handle, utils::dirs};
+    use crate::utils::logging::Type;
+    use crate::{core::handle, logging, utils::dirs};
     use tauri_plugin_shell::ShellExt;
     let app_handle = handle::Handle::app_handle();
 
-    log::info!(target: "app", "try to set system dns");
+    logging!(info, Type::Config, "try to set system dns");
     let resource_dir = match dirs::app_resources_dir() {
         Ok(dir) => dir,
         Err(e) => {
-            log::error!(target: "app", "Failed to get resource directory: {}", e);
+            logging!(
+                error,
+                Type::Config,
+                "Failed to get resource directory: {}",
+                e
+            );
             return;
         }
     };
     let script = resource_dir.join("set_dns.sh");
     if !script.exists() {
-        log::error!(target: "app", "set_dns.sh not found");
+        logging!(error, Type::Config, "set_dns.sh not found");
         return;
     }
     let script = script.to_string_lossy().into_owned();
@@ -28,14 +35,14 @@ pub async fn set_public_dns(dns_server: String) {
     {
         Ok(status) => {
             if status.success() {
-                log::info!(target: "app", "set system dns successfully");
+                logging!(info, Type::Config, "set system dns successfully");
             } else {
                 let code = status.code().unwrap_or(-1);
-                log::error!(target: "app", "set system dns failed: {code}");
+                logging!(error, Type::Config, "set system dns failed: {code}");
             }
         }
         Err(err) => {
-            log::error!(target: "app", "set system dns failed: {err}");
+            logging!(error, Type::Config, "set system dns failed: {err}");
         }
     }
 }
@@ -45,17 +52,22 @@ pub async fn restore_public_dns() {
     use crate::{core::handle, utils::dirs};
     use tauri_plugin_shell::ShellExt;
     let app_handle = handle::Handle::app_handle();
-    log::info!(target: "app", "try to unset system dns");
+    logging!(info, Type::Config, "try to unset system dns");
     let resource_dir = match dirs::app_resources_dir() {
         Ok(dir) => dir,
         Err(e) => {
-            log::error!(target: "app", "Failed to get resource directory: {}", e);
+            logging!(
+                error,
+                Type::Config,
+                "Failed to get resource directory: {}",
+                e
+            );
             return;
         }
     };
     let script = resource_dir.join("unset_dns.sh");
     if !script.exists() {
-        log::error!(target: "app", "unset_dns.sh not found");
+        logging!(error, Type::Config, "unset_dns.sh not found");
         return;
     }
     let script = script.to_string_lossy().into_owned();
@@ -69,14 +81,14 @@ pub async fn restore_public_dns() {
     {
         Ok(status) => {
             if status.success() {
-                log::info!(target: "app", "unset system dns successfully");
+                logging!(info, Type::Config, "unset system dns successfully");
             } else {
                 let code = status.code().unwrap_or(-1);
-                log::error!(target: "app", "unset system dns failed: {code}");
+                logging!(error, Type::Config, "unset system dns failed: {code}");
             }
         }
         Err(err) => {
-            log::error!(target: "app", "unset system dns failed: {err}");
+            logging!(error, Type::Config, "unset system dns failed: {err}");
         }
     }
 }

src-tauri/src/utils/resolve/mod.rs

@@ -1,5 +1,4 @@
 use anyhow::Result;
-use smartstring::alias::String;
 
 use crate::{
     config::Config,
@@ -11,10 +10,7 @@ use crate::{
         tray::Tray,
     },
     logging, logging_error,
-    module::{
-        lightweight::{auto_lightweight_mode_init, run_once_auto_lightweight},
-        signal,
-    },
+    module::{lightweight::auto_lightweight_boot, signal},
     process::AsyncHandler,
     utils::{init, logging::Type, server, window_manager::WindowManager},
 };
@@ -71,8 +67,7 @@ pub fn resolve_setup_async() {
             tray_init,
             init_timer(),
             init_hotkey(),
-            init_auto_lightweight_mode(),
-            init_once_auto_lightweight(),
+            init_auto_lightweight_boot(),
         );
     });
 }
@@ -103,7 +98,7 @@ pub(super) async fn resolve_setup_logger() {
     logging_error!(Type::Setup, init::init_logger().await);
 }
 
-pub async fn resolve_scheme(param: String) -> Result<()> {
+pub async fn resolve_scheme(param: &str) -> Result<()> {
     logging_error!(Type::Setup, scheme::resolve_scheme(param).await);
     Ok(())
 }
@@ -125,15 +120,11 @@ pub(super) async fn init_timer() {
 }
 
 pub(super) async fn init_hotkey() {
-    logging_error!(Type::Setup, Hotkey::global().init().await);
+    logging_error!(Type::Setup, Hotkey::global().init(false).await);
 }
 
-pub(super) async fn init_once_auto_lightweight() {
-    run_once_auto_lightweight().await;
-}
-
-pub(super) async fn init_auto_lightweight_mode() {
-    logging_error!(Type::Setup, auto_lightweight_mode_init().await);
+pub(super) async fn init_auto_lightweight_boot() {
+    logging_error!(Type::Setup, auto_lightweight_boot().await);
 }
 
 pub(super) fn init_signal() {
@@ -188,7 +179,7 @@ pub(super) async fn refresh_tray_menu() {
 pub(super) async fn init_window() {
     let is_silent_start = Config::verge()
         .await
-        .latest_ref()
+        .latest_arc()
         .enable_silent_start
         .unwrap_or(false);
     #[cfg(target_os = "macos")]

src-tauri/src/utils/resolve/scheme.rs

@@ -1,19 +1,26 @@
+use std::time::Duration;
+
 use anyhow::{Result, bail};
 use percent_encoding::percent_decode_str;
 use smartstring::alias::String;
 use tauri::Url;
 
-use crate::{config::PrfItem, core::handle, logging, logging_error, utils::logging::Type};
+use crate::{
+    config::{Config, PrfItem, profiles},
+    core::handle,
+    logging,
+    utils::logging::Type,
+};
 
-pub(super) async fn resolve_scheme(param: String) -> Result<()> {
-    log::info!(target:"app", "received deep link: {param}");
+pub(super) async fn resolve_scheme(param: &str) -> Result<()> {
+    logging!(info, Type::Config, "received deep link: {param}");
 
     let param_str = if param.starts_with("[") && param.len() > 4 {
         param
             .get(2..param.len() - 2)
             .ok_or_else(|| anyhow::anyhow!("Invalid string slice boundaries"))?
     } else {
-        param.as_str()
+        param
     };
 
     // 解析 URL
@@ -24,54 +31,79 @@ pub(super) async fn resolve_scheme(param: String) -> Result<()> {
         }
     };
 
-    if link_parsed.scheme() == "clash" || link_parsed.scheme() == "clash-verge" {
-        let name = link_parsed
-            .query_pairs()
-            .find(|(key, _)| key == "name")
-            .map(|(_, value)| value.into());
+    let (url_param, name) =
+        if link_parsed.scheme() == "clash" || link_parsed.scheme() == "clash-verge" {
+            let name_owned: Option<String> = link_parsed
+                .query_pairs()
+                .find(|(key, _)| key == "name")
+                .map(|(_, value)| value.into_owned().into());
 
-        let url_param = if let Some(query) = link_parsed.query() {
-            let prefix = "url=";
-            if let Some(pos) = query.find(prefix) {
-                let raw_url = &query[pos + prefix.len()..];
-                Some(percent_decode_str(raw_url).decode_utf8_lossy().to_string())
+            let url_param = if let Some(query) = link_parsed.query() {
+                let prefix = "url=";
+                if let Some(pos) = query.find(prefix) {
+                    let raw_url = &query[pos + prefix.len()..];
+                    Some(percent_decode_str(raw_url).decode_utf8_lossy().to_string())
+                } else {
+                    None
+                }
             } else {
                 None
-            }
+            };
+            (url_param, name_owned)
         } else {
-            None
+            (None, None)
         };
 
-        match url_param {
-            Some(url) => {
-                log::info!(target:"app", "decoded subscription url: {url}");
-                match PrfItem::from_url(url.as_ref(), name, None, None).await {
-                    Ok(item) => {
-                        let uid = match item.uid.clone() {
-                            Some(uid) => uid,
-                            None => {
-                                logging!(error, Type::Config, "Profile item missing UID");
-                                handle::Handle::notice_message(
-                                    "import_sub_url::error",
-                                    "Profile item missing UID".to_string(),
-                                );
-                                return Ok(());
-                            }
-                        };
-                        let result = crate::config::profiles::profiles_append_item_safe(item).await;
-                        logging_error!(
-                            Type::Config,
-                            "failed to import subscription url: {:?}",
-                            result
-                        );
-                        handle::Handle::notice_message("import_sub_url::ok", uid);
-                    }
-                    Err(e) => {
-                        handle::Handle::notice_message("import_sub_url::error", e.to_string());
-                    }
-                }
-            }
-            None => bail!("failed to get profile url"),
+    let url = if let Some(ref url) = url_param {
+        url
+    } else {
+        logging!(
+            error,
+            Type::Config,
+            "missing url parameter in deep link: {}",
+            param_str
+        );
+        return Ok(());
+    };
+
+    let mut item = match PrfItem::from_url(url, name.as_ref(), None, None).await {
+        Ok(item) => item,
+        Err(e) => {
+            logging!(
+                error,
+                Type::Config,
+                "failed to parse profile from url: {:?}",
+                e
+            );
+            handle::Handle::notice_message("import_sub_url::error", e.to_string());
+            return Ok(());
+        }
+    };
+
+    let uid = item.uid.clone().unwrap_or_default();
+    match profiles::profiles_append_item_safe(&mut item).await {
+        Ok(_) => {
+            Config::profiles().await.apply();
+            let _ = Config::profiles().await.data_arc().save_file().await;
+            handle::Handle::notice_message(
+                "import_sub_url::ok",
+                "", // 空 msg 传入，我们不希望导致 后端-前端-后端 死循环，这里只做提醒。
+            );
+            handle::Handle::refresh_verge();
+            handle::Handle::notify_profile_changed(uid.clone());
+            tokio::time::sleep(Duration::from_millis(100)).await;
+            handle::Handle::notify_profile_changed(uid);
+        }
+        Err(e) => {
+            logging!(
+                error,
+                Type::Config,
+                "failed to import subscription url: {:?}",
+                e
+            );
+            Config::profiles().await.discard();
+            handle::Handle::notice_message("import_sub_url::error", e.to_string());
+            return Ok(());
         }
     }
 

src-tauri/src/utils/resolve/ui.rs

@@ -54,9 +54,7 @@ fn get_ui_ready_notify() -> &'static Arc<Notify> {
 // 更新UI准备阶段
 pub fn update_ui_ready_stage(stage: UiReadyStage) {
     let state = get_ui_ready_state();
-    let mut stage_lock = state.stage.write();
-
-    *stage_lock = stage;
+    *state.stage.write() = stage;
     // 如果是最终阶段，标记UI完全就绪
     if stage == UiReadyStage::Ready {
         mark_ui_ready();

src-tauri/src/utils/resolve/window.rs

@@ -21,16 +21,14 @@ const MINIMAL_HEIGHT: f64 = 520.0;
 pub async fn build_new_window() -> Result<WebviewWindow, String> {
     let app_handle = handle::Handle::app_handle();
 
-    let start_page = Config::verge()
-        .await
-        .latest_ref()
-        .start_page
-        .clone()
-        .unwrap_or_else(|| "/".into());
+    let config = Config::verge().await;
+    let latest = config.latest_arc();
+    let start_page = latest.start_page.as_deref().unwrap_or("/");
+
     match tauri::WebviewWindowBuilder::new(
         app_handle,
         "main", /* the unique window label */
-        tauri::WebviewUrl::App(start_page.as_str().into()),
+        tauri::WebviewUrl::App(start_page.into()),
     )
     .title("Clash Verge")
     .center()

src-tauri/src/utils/server.rs

@@ -31,6 +31,8 @@ pub async fn check_singleton() -> Result<()> {
         let client = ClientBuilder::new()
             .timeout(Duration::from_millis(500))
             .build()?;
+        // 需要确保 Send
+        #[allow(clippy::needless_collect)]
         let argvs: Vec<std::string::String> = std::env::args().collect();
         if argvs.len() > 1 {
             #[cfg(not(target_os = "macos"))]
@@ -51,7 +53,11 @@ pub async fn check_singleton() -> Result<()> {
                 .send()
                 .await?;
         }
-        log::error!("failed to setup singleton listen server");
+        logging!(
+            error,
+            Type::Window,
+            "failed to setup singleton listen server"
+        );
         bail!("app exists");
     }
     Ok(())
@@ -85,15 +91,15 @@ pub fn embed_server() {
         let clash_config = Config::clash().await;
 
         let pac_content = verge_config
-            .latest_ref()
+            .latest_arc()
             .pac_file_content
             .clone()
             .unwrap_or_else(|| DEFAULT_PAC.into());
 
         let pac_port = verge_config
-            .latest_ref()
+            .latest_arc()
             .verge_mixed_port
-            .unwrap_or_else(|| clash_config.latest_ref().get_mixed_port());
+            .unwrap_or_else(|| clash_config.latest_arc().get_mixed_port());
 
         let pac = warp::path!("commands" / "pac").map(move || {
             let processed_content = pac_content.replace("%mixed-port%", &format!("{pac_port}"));
@@ -107,9 +113,8 @@ pub fn embed_server() {
         let scheme = warp::path!("commands" / "scheme")
             .and(warp::query::<QueryParam>())
             .map(|query: QueryParam| {
-                let param = query.param.clone();
                 tokio::task::spawn_local(async move {
-                    logging_error!(Type::Setup, resolve::resolve_scheme(param).await);
+                    logging_error!(Type::Setup, resolve::resolve_scheme(&query.param).await);
                 });
                 warp::reply::with_status::<std::string::String>(
                     "ok".to_string(),
@@ -130,7 +135,7 @@ pub fn embed_server() {
 }
 
 pub fn shutdown_embedded_server() {
-    log::info!("shutting down embedded server");
+    logging!(info, Type::Window, "shutting down embedded server");
     if let Some(sender) = SHUTDOWN_SENDER.get()
         && let Some(sender) = sender.lock().take()
     {

src-tauri/src/utils/window_manager.rs

@@ -58,7 +58,11 @@ fn get_window_operation_debounce() -> &'static Mutex<Instant> {
 
 fn should_handle_window_operation() -> bool {
     if WINDOW_OPERATION_IN_PROGRESS.load(Ordering::Acquire) {
-        log::warn!(target: "app", "[防抖] 窗口操作已在进行中，跳过重复调用");
+        logging!(
+            warn,
+            Type::Window,
+            "Warning: [防抖] 窗口操作已在进行中，跳过重复调用"
+        );
         return false;
     }
 
@@ -67,17 +71,28 @@ fn should_handle_window_operation() -> bool {
     let now = Instant::now();
     let elapsed = now.duration_since(*last_operation);
 
-    log::debug!(target: "app", "[防抖] 检查窗口操作间隔: {}ms (需要>={}ms)",
-              elapsed.as_millis(), WINDOW_OPERATION_DEBOUNCE_MS);
+    logging!(
+        debug,
+        Type::Window,
+        "[防抖] 检查窗口操作间隔: {}ms (需要>={}ms)",
+        elapsed.as_millis(),
+        WINDOW_OPERATION_DEBOUNCE_MS
+    );
 
     if elapsed >= Duration::from_millis(WINDOW_OPERATION_DEBOUNCE_MS) {
         *last_operation = now;
+        drop(last_operation);
         WINDOW_OPERATION_IN_PROGRESS.store(true, Ordering::Release);
-        log::info!(target: "app", "[防抖] 窗口操作被允许执行");
+        logging!(info, Type::Window, "[防抖] 窗口操作被允许执行");
         true
     } else {
-        log::warn!(target: "app", "[防抖] 窗口操作被防抖机制忽略，距离上次操作 {}ms < {}ms",
-                  elapsed.as_millis(), WINDOW_OPERATION_DEBOUNCE_MS);
+        logging!(
+            warn,
+            Type::Window,
+            "Warning: [防抖] 窗口操作被防抖机制忽略，距离上次操作 {}ms < {}ms",
+            elapsed.as_millis(),
+            WINDOW_OPERATION_DEBOUNCE_MS
+        );
         false
     }
 }
@@ -359,7 +374,6 @@ impl WindowManager {
             }
             return WindowOperationResult::Destroyed;
         }
-        logging!(warn, Type::Window, "窗口摧毁失败");
         WindowOperationResult::Failed
     }
 

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

@@ -506,7 +506,7 @@ export const CurrentProxyCard = () => {
 
   // 导航到代理页面
   const goToProxies = useCallback(() => {
-    navigate("/");
+    navigate("/proxies");
   }, [navigate]);
 
   // 获取要显示的代理节点

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

@@ -187,7 +187,7 @@ export const EnhancedTrafficStats = () => {
       uploadTotalUnit,
       downloadTotal,
       downloadTotalUnit,
-      connectionsCount: connections?.activeConnections.length,
+      connectionsCount: connections?.connections.length,
     };
   }, [traffic, memory, connections]);
 

src/components/layout/use-custom-theme.ts

@@ -53,10 +53,13 @@ export const useCustomTheme = () => {
       return;
     }
 
-    if (
+    const preferBrowserMatchMedia =
       typeof window !== "undefined" &&
-      typeof window.matchMedia === "function"
-    ) {
+      typeof window.matchMedia === "function" &&
+      // Skip Tauri flow when running purely in browser.
+      !("__TAURI__" in window);
+
+    if (preferBrowserMatchMedia) {
       return;
     }
 

src/components/profile/profile-item.tsx

@@ -341,7 +341,8 @@ export const ProfileItem = (props: Props) => {
 
     try {
       // 调用后端更新（后端会自动处理回退逻辑）
-      await updateProfile(itemData.uid, option);
+      const payload = Object.keys(option).length > 0 ? option : undefined;
+      await updateProfile(itemData.uid, payload);
 
       // 更新成功，刷新列表
       mutate("getProfiles");

src/components/setting/mods/clash-port-viewer.tsx

@@ -71,8 +71,9 @@ export const ClashPortViewer = forwardRef<ClashPortViewerRef>((_, ref) => {
         setOpen(false);
         showNotice("success", t("Port settings saved"));
       },
-      onError: () => {
-        showNotice("error", t("Failed to save port settings"));
+      onError: (e) => {
+        showNotice("error", e.message || t("Failed to save port settings"));
+        // showNotice("error", t("Failed to save port settings"));
       },
     },
   );

src/components/shared/ProxyControlSwitches.tsx

@@ -117,13 +117,8 @@ const ProxyControlSwitches = ({
   const { uninstallServiceAndRestartCore } = useServiceUninstaller();
   const { actualState: systemProxyActualState, toggleSystemProxy } =
     useSystemProxyState();
-  const {
-    isServiceMode,
-    isTunModeAvailable,
-    mutateRunningMode,
-    mutateServiceOk,
-    mutateTunModeAvailable,
-  } = useSystemState();
+  const { isServiceOk, isTunModeAvailable, mutateSystemState } =
+    useSystemState();
 
   const sysproxyRef = useRef<DialogRef>(null);
   const tunRef = useRef<DialogRef>(null);
@@ -148,9 +143,7 @@ const ProxyControlSwitches = ({
   const onInstallService = useLockFn(async () => {
     try {
       await installServiceAndRestartCore();
-      await mutateRunningMode();
-      await mutateServiceOk();
-      await mutateTunModeAvailable();
+      await mutateSystemState();
     } catch (err) {
       showNotice("error", (err as Error).message || String(err));
     }
@@ -158,11 +151,11 @@ const ProxyControlSwitches = ({
 
   const onUninstallService = useLockFn(async () => {
     try {
-      await handleTunToggle(false);
+      if (verge?.enable_tun_mode) {
+        await handleTunToggle(false);
+      }
       await uninstallServiceAndRestartCore();
-      await mutateRunningMode();
-      await mutateServiceOk();
-      await mutateTunModeAvailable();
+      await mutateSystemState();
     } catch (err) {
       showNotice("error", (err as Error).message || String(err));
     }
@@ -198,22 +191,22 @@ const ProxyControlSwitches = ({
           extraIcons={
             <>
               {!isTunModeAvailable && (
-                <TooltipIcon
-                  title={t("TUN requires Service Mode or Admin Mode")}
-                  icon={WarningRounded}
-                  sx={{ color: "warning.main", ml: 1 }}
-                />
+                <>
+                  <TooltipIcon
+                    title={t("TUN requires Service Mode or Admin Mode")}
+                    icon={WarningRounded}
+                    sx={{ color: "warning.main", ml: 1 }}
+                  />
+                  <TooltipIcon
+                    title={t("Install Service")}
+                    icon={BuildRounded}
+                    color="primary"
+                    onClick={onInstallService}
+                    sx={{ ml: 1 }}
+                  />
+                </>
               )}
-              {!isTunModeAvailable && (
-                <TooltipIcon
-                  title={t("Install Service")}
-                  icon={BuildRounded}
-                  color="primary"
-                  onClick={onInstallService}
-                  sx={{ ml: 1 }}
-                />
-              )}
-              {isServiceMode && (
+              {isServiceOk && (
                 <TooltipIcon
                   title={t("Uninstall Service")}
                   icon={DeleteForeverRounded}

src/hooks/use-clash.ts

@@ -70,8 +70,8 @@ export const useClashInfo = () => {
 
     if (patch["redir-port"]) {
       const port = patch["redir-port"];
-      if (port < 1111) {
-        throw new Error("The port should not < 1111");
+      if (port < 1000) {
+        throw new Error("The port should not < 1000");
       }
       if (port > 65536) {
         throw new Error("The port should not > 65536");
@@ -80,8 +80,8 @@ export const useClashInfo = () => {
 
     if (patch["tproxy-port"]) {
       const port = patch["tproxy-port"];
-      if (port < 1111) {
-        throw new Error("The port should not < 1111");
+      if (port < 1000) {
+        throw new Error("The port should not < 1000");
       }
       if (port > 65536) {
         throw new Error("The port should not > 65536");
@@ -90,8 +90,8 @@ export const useClashInfo = () => {
 
     if (patch["mixed-port"]) {
       const port = patch["mixed-port"];
-      if (port < 1111) {
-        throw new Error("The port should not < 1111");
+      if (port < 1000) {
+        throw new Error("The port should not < 1000");
       }
       if (port > 65536) {
         throw new Error("The port should not > 65536");
@@ -100,8 +100,8 @@ export const useClashInfo = () => {
 
     if (patch["socks-port"]) {
       const port = patch["socks-port"];
-      if (port < 1111) {
-        throw new Error("The port should not < 1111");
+      if (port < 1000) {
+        throw new Error("The port should not < 1000");
       }
       if (port > 65536) {
         throw new Error("The port should not > 65536");
@@ -110,8 +110,8 @@ export const useClashInfo = () => {
 
     if (patch["port"]) {
       const port = patch["port"];
-      if (port < 1111) {
-        throw new Error("The port should not < 1111");
+      if (port < 1000) {
+        throw new Error("The port should not < 1000");
       }
       if (port > 65536) {
         throw new Error("The port should not > 65536");

src/hooks/use-connection-data.ts

@@ -4,22 +4,12 @@ import { mutate } from "swr";
 import useSWRSubscription from "swr/subscription";
 import { MihomoWebSocket } from "tauri-plugin-mihomo-api";
 
-export const initConnData: ConnectionMonitorData = {
+export const initConnData: IConnections = {
   uploadTotal: 0,
   downloadTotal: 0,
-  activeConnections: [],
-  closedConnections: [],
+  connections: [],
 };
 
-export interface ConnectionMonitorData {
-  uploadTotal: 0;
-  downloadTotal: 0;
-  activeConnections: IConnectionsItem[];
-  closedConnections: IConnectionsItem[];
-}
-
-const MAX_CLOSED_CONNS_NUM = 500;
-
 export const useConnectionData = () => {
   const [date, setDate] = useLocalStorage("mihomo_connection_date", Date.now());
   const subscriptKey = `getClashConnection-${date}`;
@@ -28,11 +18,7 @@ export const useConnectionData = () => {
   const wsFirstConnection = useRef<boolean>(true);
   const timeoutRef = useRef<ReturnType<typeof setTimeout>>(null);
 
-  const response = useSWRSubscription<
-    ConnectionMonitorData,
-    any,
-    string | null
-  >(
+  const response = useSWRSubscription<IConnections, any, string | null>(
     subscriptKey,
     (_key, { next }) => {
       const reconnect = async () => {
@@ -55,44 +41,28 @@ export const useConnectionData = () => {
                 } else {
                   const data = JSON.parse(msg.data) as IConnections;
                   next(null, (old = initConnData) => {
-                    const oldConn = old.activeConnections;
+                    const oldConn = old.connections;
                     const maxLen = data.connections?.length;
-                    const activeConns: IConnectionsItem[] = [];
+                    const connections: IConnectionsItem[] = [];
                     const rest = (data.connections || []).filter((each) => {
                       const index = oldConn.findIndex((o) => o.id === each.id);
                       if (index >= 0 && index < maxLen) {
                         const old = oldConn[index];
                         each.curUpload = each.upload - old.upload;
                         each.curDownload = each.download - old.download;
-                        activeConns[index] = each;
+                        connections[index] = each;
                         return false;
                       }
                       return true;
                     });
                     for (let i = 0; i < maxLen; ++i) {
-                      if (!activeConns[i] && rest.length > 0) {
-                        activeConns[i] = rest.shift()!;
-                        activeConns[i].curUpload = 0;
-                        activeConns[i].curDownload = 0;
+                      if (!connections[i] && rest.length > 0) {
+                        connections[i] = rest.shift()!;
+                        connections[i].curUpload = 0;
+                        connections[i].curDownload = 0;
                       }
                     }
-                    const currentClosedConns = oldConn.filter((each) => {
-                      const index = activeConns.findIndex(
-                        (o) => o.id === each.id,
-                      );
-                      return index < 0;
-                    });
-                    let closedConns =
-                      old.closedConnections.concat(currentClosedConns);
-                    if (closedConns.length > 500) {
-                      closedConns = closedConns.slice(-MAX_CLOSED_CONNS_NUM);
-                    }
-                    return {
-                      uploadTotal: data.uploadTotal,
-                      downloadTotal: data.downloadTotal,
-                      activeConnections: activeConns,
-                      closedConnections: closedConns,
-                    } as ConnectionMonitorData;
+                    return { ...data, connections };
                   });
                 }
               }
@@ -139,14 +109,5 @@ export const useConnectionData = () => {
     setDate(Date.now());
   };
 
-  const clearClosedConnections = () => {
-    mutate(`$sub$${subscriptKey}`, {
-      uploadTotal: response.data?.uploadTotal ?? 0,
-      downloadTotal: response.data?.downloadTotal ?? 0,
-      activeConnections: response.data?.activeConnections ?? [],
-      closedConnections: [],
-    } as ConnectionMonitorData);
-  };
-
-  return { response, refreshGetClashConnection, clearClosedConnections };
+  return { response, refreshGetClashConnection };
 };

src/hooks/use-profiles.ts

@@ -62,7 +62,9 @@ export const useProfiles = () => {
   const patchCurrent = async (value: Partial<IProfileItem>) => {
     if (profiles?.current) {
       await patchProfile(profiles.current, value);
-      mutateProfiles();
+      if (!value.selected) {
+        mutateProfiles();
+      }
     }
   };
 

src/hooks/use-system-state.ts

@@ -1,73 +1,99 @@
+import { useEffect } from "react";
+import { useTranslation } from "react-i18next";
 import useSWR from "swr";
 
 import { getRunningMode, isAdmin, isServiceAvailable } from "@/services/cmds";
+import { showNotice } from "@/services/noticeService";
+
+import { useVerge } from "./use-verge";
+
+export interface SystemState {
+  runningMode: "Sidecar" | "Service";
+  isAdminMode: boolean;
+  isServiceOk: boolean;
+}
+
+const defaultSystemState = {
+  runningMode: "Sidecar",
+  isAdminMode: false,
+  isServiceOk: false,
+} as SystemState;
+
+let disablingTunMode = false;
 
 /**
  * 自定义 hook 用于获取系统运行状态
  * 包括运行模式、管理员状态、系统服务是否可用
  */
 export function useSystemState() {
-  // 获取运行模式
-  const {
-    data: runningMode = "Sidecar",
-    mutate: mutateRunningMode,
-    isLoading: runningModeLoading,
-  } = useSWR("getRunningMode", getRunningMode, {
-    suspense: false,
-    revalidateOnFocus: false,
-  });
-  const isSidecarMode = runningMode === "Sidecar";
-  const isServiceMode = runningMode === "Service";
+  const { t } = useTranslation();
+  const { verge, patchVerge } = useVerge();
 
-  // 获取管理员状态
-  const { data: isAdminMode = false, isLoading: isAdminLoading } = useSWR(
-    "isAdmin",
-    isAdmin,
+  const {
+    data: systemState,
+    mutate: mutateSystemState,
+    isLoading,
+  } = useSWR(
+    "getSystemState",
+    async () => {
+      const [runningMode, isAdminMode, isServiceOk] = await Promise.all([
+        getRunningMode(),
+        isAdmin(),
+        isServiceAvailable(),
+      ]);
+      return { runningMode, isAdminMode, isServiceOk } as SystemState;
+    },
     {
-      suspense: false,
-      revalidateOnFocus: false,
+      suspense: true,
+      refreshInterval: 30000,
+      fallback: defaultSystemState,
     },
   );
 
-  const {
-    data: isServiceOk = false,
-    mutate: mutateServiceOk,
-    isLoading: isServiceLoading,
-  } = useSWR(isServiceMode ? "isServiceAvailable" : null, isServiceAvailable, {
-    suspense: false,
-    revalidateOnFocus: false,
-    onSuccess: (data) => {
-      console.log("[useSystemState] 服务状态更新:", data);
-    },
-    onError: (error) => {
-      console.error("[useSystemState] 服务状态检查失败:", error);
-    },
-    // isPaused: () => !isServiceMode, // 仅在非 Service 模式下暂停请求
-  });
+  const isSidecarMode = systemState.runningMode === "Sidecar";
+  const isServiceMode = systemState.runningMode === "Service";
+  const isTunModeAvailable = systemState.isAdminMode || systemState.isServiceOk;
 
-  const isLoading =
-    runningModeLoading || isAdminLoading || (isServiceMode && isServiceLoading);
+  const enable_tun_mode = verge?.enable_tun_mode;
+  useEffect(() => {
+    if (enable_tun_mode === undefined) return;
 
-  const { data: isTunModeAvailable = false, mutate: mutateTunModeAvailable } =
-    useSWR(
-      ["isTunModeAvailable", isAdminMode, isServiceOk],
-      () => isAdminMode || isServiceOk,
-      {
-        suspense: false,
-        revalidateOnFocus: false,
-      },
-    );
+    if (
+      !disablingTunMode &&
+      enable_tun_mode &&
+      !isTunModeAvailable &&
+      !isLoading
+    ) {
+      disablingTunMode = true;
+      patchVerge({ enable_tun_mode: false })
+        .then(() => {
+          showNotice(
+            "info",
+            t("TUN Mode automatically disabled due to service unavailable"),
+          );
+        })
+        .catch((err) => {
+          console.error("[useVerge] 自动关闭TUN模式失败:", err);
+          showNotice("error", t("Failed to disable TUN Mode automatically"));
+        })
+        .finally(() => {
+          const tid = setTimeout(() => {
+            // 避免 verge 数据更新不及时导致重复执行关闭 Tun 模式
+            disablingTunMode = false;
+            clearTimeout(tid);
+          }, 1000);
+        });
+    }
+  }, [enable_tun_mode, isTunModeAvailable, patchVerge, isLoading, t]);
 
   return {
-    runningMode,
-    isAdminMode,
+    runningMode: systemState.runningMode,
+    isAdminMode: systemState.isAdminMode,
+    isServiceOk: systemState.isServiceOk,
     isSidecarMode,
     isServiceMode,
-    isServiceOk,
     isTunModeAvailable,
-    mutateRunningMode,
-    mutateServiceOk,
-    mutateTunModeAvailable,
+    mutateSystemState,
     isLoading,
   };
 }

src/hooks/use-verge.ts

@@ -1,16 +1,8 @@
-import { useCallback, useEffect, useRef } from "react";
-import { useTranslation } from "react-i18next";
 import useSWR from "swr";
 
-import { useSystemState } from "@/hooks/use-system-state";
 import { getVergeConfig, patchVergeConfig } from "@/services/cmds";
-import { showNotice } from "@/services/noticeService";
 
 export const useVerge = () => {
-  const { t } = useTranslation();
-  const { isTunModeAvailable, isServiceMode, isLoading } = useSystemState();
-  const disablingRef = useRef(false);
-
   const { data: verge, mutate: mutateVerge } = useSWR(
     "getVergeConfig",
     async () => {
@@ -24,53 +16,6 @@ export const useVerge = () => {
     mutateVerge();
   };
 
-  const { enable_tun_mode } = verge ?? {};
-
-  const mutateVergeRef = useRef(mutateVerge);
-  const tRef = useRef(t);
-  const enableTunRef = useRef(enable_tun_mode);
-  const isLoadingRef = useRef(isLoading);
-  const isServiceModeRef = useRef(isServiceMode);
-
-  mutateVergeRef.current = mutateVerge;
-  tRef.current = t;
-  enableTunRef.current = enable_tun_mode;
-  isLoadingRef.current = isLoading;
-  isServiceModeRef.current = isServiceMode;
-
-  const doDisable = useCallback(async () => {
-    try {
-      if (isServiceModeRef.current === true) return;
-      await patchVergeConfig({ enable_tun_mode: false });
-      await mutateVergeRef.current?.();
-      showNotice(
-        "info",
-        tRef.current(
-          "TUN Mode automatically disabled due to service unavailable",
-        ),
-      );
-    } catch (err) {
-      console.error("[useVerge] 自动关闭TUN模式失败:", err);
-      showNotice(
-        "error",
-        tRef.current("Failed to disable TUN Mode automatically"),
-      );
-    } finally {
-      disablingRef.current = false;
-    }
-  }, []);
-
-  useEffect(() => {
-    if (isTunModeAvailable === true) return;
-    if (isLoadingRef.current === true) return;
-    if (enableTunRef.current !== true) return;
-    if (isServiceModeRef.current === true) return;
-    if (disablingRef.current) return;
-
-    disablingRef.current = true;
-    void doDisable();
-  }, [isTunModeAvailable, doDisable]);
-
   return {
     verge,
     mutateVerge,

src/hooks/useServiceInstaller.ts

@@ -25,7 +25,7 @@ const executeWithErrorHandling = async (
 };
 
 export const useServiceInstaller = () => {
-  const { mutateRunningMode, mutateServiceOk } = useSystemState();
+  const { mutateSystemState } = useSystemState();
 
   const installServiceAndRestartCore = useCallback(async () => {
     await executeWithErrorHandling(
@@ -34,9 +34,13 @@ export const useServiceInstaller = () => {
       "Service Installed Successfully",
     );
 
-    await executeWithErrorHandling(() => restartCore(), "Restarting Core...");
-    await mutateRunningMode();
-    await mutateServiceOk();
-  }, [mutateRunningMode, mutateServiceOk]);
+    await executeWithErrorHandling(
+      () => restartCore(),
+      "Restarting Core...",
+      "Clash Core Restarted",
+    );
+
+    await mutateSystemState();
+  }, [mutateSystemState]);
   return { installServiceAndRestartCore };
 };

src/hooks/useServiceUninstaller.ts

@@ -25,21 +25,26 @@ const executeWithErrorHandling = async (
 };
 
 export const useServiceUninstaller = () => {
-  const { mutateRunningMode, mutateServiceOk } = useSystemState();
+  const { mutateSystemState } = useSystemState();
 
   const uninstallServiceAndRestartCore = useCallback(async () => {
-    await executeWithErrorHandling(() => stopCore(), "Stopping Core...");
-
-    await executeWithErrorHandling(
-      () => uninstallService(),
-      "Uninstalling Service...",
-      "Service Uninstalled Successfully",
-    );
-
-    await executeWithErrorHandling(() => restartCore(), "Restarting Core...");
-    await mutateRunningMode();
-    await mutateServiceOk();
-  }, [mutateRunningMode, mutateServiceOk]);
+    try {
+      await executeWithErrorHandling(() => stopCore(), "Stopping Core...");
+      await executeWithErrorHandling(
+        () => uninstallService(),
+        "Uninstalling Service...",
+        "Service Uninstalled Successfully",
+      );
+    } catch (ignore) {
+    } finally {
+      await executeWithErrorHandling(
+        () => restartCore(),
+        "Restarting Core...",
+        "Clash Core Restarted",
+      );
+      await mutateSystemState();
+    }
+  }, [mutateSystemState]);
 
   return { uninstallServiceAndRestartCore };
 };

src/locales/ar.json

@@ -21,7 +21,6 @@
   "Label-Connections": "الاتصالات",
   "Label-Rules": "القواعد",
   "Label-Logs": "السجلات",
-  "Label-Test": "اختبار",
   "Label-Settings": "الإعدادات",
   "Proxies": "الوكلاء",
   "Proxy Groups": "مجموعات الوكلاء",
@@ -166,7 +165,6 @@
   "Table View": "عرض الجدول",
   "List View": "عرض القائمة",
   "Close All": "إغلاق الكل",
-  "Default": "افتراضي",
   "Download Speed": "سرعة التنزيل",
   "Upload Speed": "سرعة الرفع",
   "Host": "المضيف",
@@ -197,6 +195,8 @@
   "Settings": "الإعدادات",
   "System Setting": "إعدادات النظام",
   "Tun Mode": "وضع TUN",
+  "TUN requires Service Mode": "يتطلب وضع TUN خدمة",
+  "Install Service": "تثبيت الخدمة ",
   "Reset to Default": "إعادة تعيين إلى الافتراضي",
   "Tun Mode Info": "وضع TUN (بطاقة شبكة افتراضية): يلتقط كل حركة المرور في النظام. عند تمكينه، لا حاجة لتفعيل وكيل النظام.",
   "Stack": "مكدس TUN",
@@ -279,7 +279,8 @@
   "Open UWP tool": "فتح أداة UWP",
   "Open UWP tool Info": "منذ نظام ويندوز 8، يتم تقييد تطبيقات UWP من الوصول المباشر إلى المضيف المحلي. هذه الأداة تتيح تجاوز هذا التقييد",
   "Update GeoData": "تحديث البيانات الجغرافية",
-  "Verge Setting": "إعدادات Verge",
+  "Verge Basic Setting": "الإعدادات الأساسية  Verge",
+  "Verge Advanced Setting": "الإعدادات الأساسية  Verge",
   "Language": "اللغة",
   "Theme Mode": "وضع السمة",
   "theme.light": "سمة فاتحة",
@@ -365,6 +366,7 @@
   "Profile Reactivated": "تم إعادة تنشيط الملف الشخصي",
   "Only YAML Files Supported": "لا يتم دعم سوى ملفات YAML",
   "Settings Applied": "تم تطبيق الإعدادات",
+  "Installing Service...": "جاري تثبيت الخدمة...",
   "Service Installed Successfully": "تم تثبيت الخدمة بنجاح",
   "Service Uninstalled Successfully": "تم إلغاء تثبيت الخدمة بنجاح",
   "Proxy Daemon Duration Cannot be Less than 1 Second": "لا يمكن أن تقل مدة خادم الوكيل عن ثانية واحدة",
@@ -407,19 +409,12 @@
   "Help": "مساعدة",
   "About": "حول",
   "Theme": "السمة",
-  "TUN Mode": "وضع TUN",
   "Main Window": "النافذة الرئيسية",
   "Group Icon": "أيقونة المجموعة",
   "Menu Icon": "أيقونة القائمة",
-  "System Proxy Bypass": "تخطي وكيل النظام",
   "PAC File": "ملف PAC",
   "Web UI": "واجهة الويب",
   "Hotkeys": "اختصارات لوحة المفاتيح",
-  "Auto Close Connection": "إغلاق الاتصال تلقائيًا",
-  "Enable Built-in Enhanced": "تفعيل التحسين المدمج",
-  "Proxy Layout Column": "عمود عرض الوكيل",
-  "Test List": "قائمة الاختبارات",
-  "Enable Random Port": "تفعيل المنفذ العشوائي",
   "Verge Mixed Port": "منفذ Verge المختلط",
   "Verge Socks Port": "منفذ Verge SOCKS",
   "Verge Redir Port": "منفذ إعادة التوجيه لـ Verge",
@@ -429,15 +424,16 @@
   "WebDAV URL": "رابط WebDAV",
   "WebDAV Username": "اسم المستخدم لـ WebDAV",
   "WebDAV Password": "كلمة مرور WebDAV",
+  "Dashboard": "لوحة التحكم",
+  "Restart App": "إعادة تشغيل التطبيق",
+  "Restart Clash Core": "إعادة تشغيل نواة Clash",
+  "TUN Mode": "وضع TUN",
   "Copy Env": "نسخ البيئة",
   "Conf Dir": "مجلد الإعدادات",
   "Core Dir": "مجلد النواة",
   "Logs Dir": "مجلد السجلات",
   "Open Dir": "فتح المجلد",
-  "Restart Clash Core": "إعادة تشغيل نواة Clash",
-  "Restart App": "إعادة تشغيل التطبيق",
   "More": "المزيد",
-  "Dashboard": "لوحة التحكم",
   "Rule Mode": "وضع القواعد",
   "Global Mode": "الوضع العالمي",
   "Direct Mode": "الوضع المباشر",
@@ -454,10 +450,14 @@
   "Script File Error": "خطأ في ملف السكريبت، تم التراجع عن التغييرات",
   "Core Changed Successfully": "تم تغيير النواة بنجاح",
   "Failed to Change Core": "فشل تغيير النواة",
-  "Verge Basic Setting": "الإعدادات الأساسية  Verge",
-  "Verge Advanced Setting": "الإعدادات الأساسية  Verge",
-  "TUN requires Service Mode": "يتطلب وضع TUN خدمة",
-  "Install Service": "تثبيت الخدمة ",
-  "Installing Service...": "جاري تثبيت الخدمة...",
-  "Service Administrator Prompt": "يتطلب Clash Verge امتيازات المسؤول لإعادة تثبيت خدمة النظام"
+  "Service Administrator Prompt": "يتطلب Clash Verge امتيازات المسؤول لإعادة تثبيت خدمة النظام",
+  "Auto Close Connection": "إغلاق الاتصال تلقائيًا",
+  "Default": "افتراضي",
+  "Enable Built-in Enhanced": "تفعيل التحسين المدمج",
+  "Enable Random Port": "تفعيل المنفذ العشوائي",
+  "Label-Test": "اختبار",
+  "Proxy Layout Column": "عمود عرض الوكيل",
+  "System Proxy Bypass": "تخطي وكيل النظام",
+  "Test List": "قائمة الاختبارات",
+  "Verge Setting": "إعدادات Verge"
 }

src/locales/de.json

@@ -195,10 +195,11 @@
   "Settings": "Einstellungen",
   "System Setting": "Systemeinstellungen",
   "Tun Mode": "Virtual Network Interface-Modus",
-  "TUN requires Service Mode or Admin Mode": "TUN-Modus erfordert Service-Modus oder Administrator-Modus",
   "Install Service": "Service installieren",
+  "Uninstall Service": "Dienst deinstallieren",
   "Reset to Default": "Auf Standardwerte zurücksetzen",
   "Tun Mode Info": "Der TUN-Modus (Virtual Network Interface) übernimmt den gesamten Systemverkehr. Wenn dieser Modus aktiviert ist, muss der Systemproxy nicht geöffnet werden.",
+  "TUN requires Service Mode or Admin Mode": "TUN-Modus erfordert Service-Modus oder Administrator-Modus",
   "System Proxy Enabled": "Der Systemproxy ist aktiviert. Ihre Anwendungen werden über den Proxy auf das Netzwerk zugreifen.",
   "System Proxy Disabled": "Der Systemproxy ist deaktiviert. Es wird empfohlen, diesen Eintrag für die meisten Benutzer zu aktivieren.",
   "TUN Mode Enabled": "Der TUN-Modus ist aktiviert. Die Anwendungen werden über die virtuelle Netzwerkschnittstelle auf das Netzwerk zugreifen.",
@@ -254,6 +255,7 @@
   "Unified Delay Info": "Wenn die einheitliche Latenz aktiviert ist, werden zwei Latenztests durchgeführt, um die Latenzunterschiede zwischen verschiedenen Knotentypen aufgrund von Verbindungsaufbau und anderen Faktoren zu eliminieren.",
   "Log Level": "Protokolliergrad",
   "Log Level Info": "Dies wirkt sich nur auf die Kernprotokolldateien im Verzeichnis Service im Protokollverzeichnis aus.",
+  "Port Config": "Port-Konfiguration",
   "Random Port": "Zufälliger Port",
   "Mixed Port": "Mischter Proxy-Port",
   "Socks Port": "SOCKS-Proxy-Port",
@@ -367,17 +369,16 @@
   "Stopping Core...": "Kern wird gestoppt...",
   "Restarting Core...": "Kern wird neu gestartet...",
   "Installing Service...": "Service wird installiert...",
-  "Uninstall Service": "Dienst deinstallieren",
-  "Service Installed Successfully": "Service erfolgreich installiert",
-  "Service is ready and core restarted": "Service ist bereit und Kern wurde neu gestartet",
-  "Core restarted. Service is now available.": "Kern wurde neu gestartet. Service ist jetzt verfügbar",
-  "Service was ready, but core restart might have issues or service became unavailable. Please check.": "Der Dienst war bereit, aber beim Neustart des Kerns könnten Probleme aufgetreten sein oder der Dienst ist möglicherweise nicht verfügbar. Bitte überprüfen Sie dies.",
-  "Service installation or core restart encountered issues. Service might not be available. Please check system logs.": "Bei der Dienstinstallation oder dem Neustart des Kerns sind Probleme aufgetreten. Der Dienst ist möglicherweise nicht verfügbar. Bitte prüfen Sie die Systemprotokolle.",
   "Uninstalling Service...": "Service wird deinstalliert...",
-  "Waiting for service to be ready...": "Auf Service-Bereitschaft gewartet...",
+  "Service Installed Successfully": "Service erfolgreich installiert",
   "Service Uninstalled Successfully": "Service erfolgreich deinstalliert",
   "Proxy Daemon Duration Cannot be Less than 1 Second": "Das Intervall des Proxy-Daemons darf nicht weniger als 1 Sekunde betragen.",
   "Invalid Bypass Format": "Ungültiges Format für die Proxy-Umgehung",
+  "Waiting for service to be ready...": "Auf Service-Bereitschaft gewartet...",
+  "Service was ready, but core restart might have issues or service became unavailable. Please check.": "Der Dienst war bereit, aber beim Neustart des Kerns könnten Probleme aufgetreten sein oder der Dienst ist möglicherweise nicht verfügbar. Bitte überprüfen Sie dies.",
+  "Service installation or core restart encountered issues. Service might not be available. Please check system logs.": "Bei der Dienstinstallation oder dem Neustart des Kerns sind Probleme aufgetreten. Der Dienst ist möglicherweise nicht verfügbar. Bitte prüfen Sie die Systemprotokolle.",
+  "Service is ready and core restarted": "Service ist bereit und Kern wurde neu gestartet",
+  "Core restarted. Service is now available.": "Kern wurde neu gestartet. Service ist jetzt verfügbar",
   "Core Version Updated": "Kernversion wurde aktualisiert",
   "Clash Core Restarted": "Clash-Kern wurde neu gestartet",
   "GeoData Updated": "Geo-Daten wurden aktualisiert",
@@ -523,7 +524,6 @@
   "Unknown": "Unbekannt",
   "Auto update disabled": "Automatische Aktualisierung deaktiviert",
   "Update subscription successfully": "Abonnement erfolgreich aktualisiert",
-  "Update failed, retrying with Clash proxy...": "Abonnement-Aktualisierung fehlgeschlagen. Versuche es mit dem Clash-Proxy erneut...",
   "Update with Clash proxy successfully": "Aktualisierung mit Clash-Proxy erfolgreich",
   "Update failed even with Clash proxy": "Aktualisierung auch mit Clash-Proxy fehlgeschlagen",
   "Profile creation failed, retrying with Clash proxy...": "Erstellung des Abonnements fehlgeschlagen. Versuche es mit dem Clash-Proxy erneut...",
@@ -555,10 +555,9 @@
   "Disallowed ISP": "Nicht zugelassener Internetdienstanbieter",
   "Originals Only": "Nur Original",
   "Unsupported Country/Region": "Nicht unterstütztes Land/Region",
+  "Configuration saved successfully": "Zufalls-Konfiguration erfolgreich gespeichert",
   "Controller address copied to clipboard": "API-Port in die Zwischenablage kopiert",
   "Secret copied to clipboard": "API-Schlüssel in die Zwischenablage kopiert",
   "Copy to clipboard": "Klicken Sie hier, um zu kopieren",
-  "Port Config": "Port-Konfiguration",
-  "Configuration saved successfully": "Zufalls-Konfiguration erfolgreich gespeichert",
   "Enable one-click random API port and key. Click to randomize the port and key": "Einstellsichere Zufalls-API-Port- und Schlüsselgenerierung aktivieren. Klicken Sie, um Port und Schlüssel zu randomisieren"
 }

src/locales/en.json

@@ -628,7 +628,6 @@
   "Unknown": "Unknown",
   "Auto update disabled": "Auto update disabled",
   "Update subscription successfully": "Update subscription successfully",
-  "Update failed, retrying with Clash proxy...": "Update failed, retrying with Clash proxy...",
   "Update with Clash proxy successfully": "Update with Clash proxy successfully",
   "Update failed even with Clash proxy": "Update failed even with Clash proxy",
   "Profile creation failed, retrying with Clash proxy...": "Profile creation failed, retrying with Clash proxy...",
@@ -713,5 +712,7 @@
   "Allow Auto Update": "Allow Auto Update",
   "Menu reorder mode": "Menu reorder mode",
   "Unlock menu order": "Unlock menu order",
-  "Lock menu order": "Lock menu order"
+  "Lock menu order": "Lock menu order",
+  "Open App Log": "Open App Log",
+  "Open Core Log": "Open Core Log"
 }

src/locales/es.json

@@ -195,10 +195,11 @@
   "Settings": "Ajustes",
   "System Setting": "Ajustes del sistema",
   "Tun Mode": "Modo de interfaz virtual (TUN)",
-  "TUN requires Service Mode or Admin Mode": "El modo TUN requiere el modo de servicio o el modo de administrador",
   "Install Service": "Instalar servicio",
+  "Uninstall Service": "Desinstalar servicio",
   "Reset to Default": "Restablecer a los valores predeterminados",
   "Tun Mode Info": "El modo TUN (interfaz virtual) gestiona todo el tráfico del sistema. No es necesario habilitar el proxy del sistema cuando está activado.",
+  "TUN requires Service Mode or Admin Mode": "El modo TUN requiere el modo de servicio o el modo de administrador",
   "System Proxy Enabled": "El proxy del sistema está habilitado. Sus aplicaciones accederán a Internet a través del proxy.",
   "System Proxy Disabled": "El proxy del sistema está deshabilitado. Se recomienda a la mayoría de los usuarios habilitar esta opción.",
   "TUN Mode Enabled": "El modo TUN está habilitado. Las aplicaciones accederán a Internet a través de la interfaz virtual.",
@@ -254,6 +255,7 @@
   "Unified Delay Info": "Al habilitar la latencia unificada, se realizarán dos pruebas de latencia para eliminar las diferencias de latencia entre diferentes tipos de nodos causadas por el handshake de conexión, etc.",
   "Log Level": "Nivel de registro",
   "Log Level Info": "Solo se aplica al archivo de registro del núcleo en la carpeta Service del directorio de registros.",
+  "Port Config": "Configuración de puerto",
   "Random Port": "Puerto aleatorio",
   "Mixed Port": "Puerto de proxy mixto",
   "Socks Port": "Puerto de proxy SOCKS",
@@ -367,17 +369,16 @@
   "Stopping Core...": "Deteniendo núcleo...",
   "Restarting Core...": "Reiniciando núcleo...",
   "Installing Service...": "Instalando servicio...",
-  "Uninstall Service": "Desinstalar servicio",
-  "Service Installed Successfully": "Servicio instalado con éxito",
-  "Service is ready and core restarted": "El servicio está listo y el núcleo se ha reiniciado",
-  "Core restarted. Service is now available.": "El núcleo se ha reiniciado. El servicio está disponible.",
-  "Service was ready, but core restart might have issues or service became unavailable. Please check.": "El servicio estaba listo, pero puede haber habido problemas al reiniciar el núcleo o el servicio se volvió inaccesible. Por favor, verifique.",
-  "Service installation or core restart encountered issues. Service might not be available. Please check system logs.": "Hubo problemas durante la instalación del servicio o al reiniciar el núcleo. El servicio podría no estar disponible. Por favor, revise los registros del sistema.",
   "Uninstalling Service...": "Desinstalando servicio...",
-  "Waiting for service to be ready...": "Esperando a que el servicio esté listo...",
+  "Service Installed Successfully": "Servicio instalado con éxito",
   "Service Uninstalled Successfully": "Servicio desinstalado con éxito",
   "Proxy Daemon Duration Cannot be Less than 1 Second": "El intervalo de tiempo del daemon de proxy no puede ser menor de 1 segundo",
   "Invalid Bypass Format": "Formato de omisión de proxy no válido",
+  "Waiting for service to be ready...": "Esperando a que el servicio esté listo...",
+  "Service was ready, but core restart might have issues or service became unavailable. Please check.": "El servicio estaba listo, pero puede haber habido problemas al reiniciar el núcleo o el servicio se volvió inaccesible. Por favor, verifique.",
+  "Service installation or core restart encountered issues. Service might not be available. Please check system logs.": "Hubo problemas durante la instalación del servicio o al reiniciar el núcleo. El servicio podría no estar disponible. Por favor, revise los registros del sistema.",
+  "Service is ready and core restarted": "El servicio está listo y el núcleo se ha reiniciado",
+  "Core restarted. Service is now available.": "El núcleo se ha reiniciado. El servicio está disponible.",
   "Core Version Updated": "Versión del núcleo actualizada",
   "Clash Core Restarted": "Núcleo de Clash reiniciado",
   "GeoData Updated": "GeoData actualizado",
@@ -523,7 +524,6 @@
   "Unknown": "Desconocido",
   "Auto update disabled": "La actualización automática está deshabilitada",
   "Update subscription successfully": "Suscripción actualizada con éxito",
-  "Update failed, retrying with Clash proxy...": "Error al actualizar la suscripción. Intentando con el proxy de Clash...",
   "Update with Clash proxy successfully": "Actualización con el proxy de Clash exitosa",
   "Update failed even with Clash proxy": "Error al actualizar incluso con el proxy de Clash",
   "Profile creation failed, retrying with Clash proxy...": "Error al crear la suscripción. Intentando con el proxy de Clash...",
@@ -555,10 +555,9 @@
   "Disallowed ISP": "Proveedor de servicios de Internet no permitido",
   "Originals Only": "Solo originales",
   "Unsupported Country/Region": "País/región no soportado",
+  "Configuration saved successfully": "Configuración aleatoria guardada correctamente",
   "Controller address copied to clipboard": "El puerto API se copió al portapapeles",
   "Secret copied to clipboard": "La clave API se copió al portapapeles",
   "Copy to clipboard": "Haz clic aquí para copiar",
-  "Port Config": "Configuración de puerto",
-  "Configuration saved successfully": "Configuración aleatoria guardada correctamente",
   "Enable one-click random API port and key. Click to randomize the port and key": "Habilitar la generación de puerto y clave API aleatorios con un solo clic. Haz clic para randomizar el puerto y la clave"
 }

src/locales/fa.json

@@ -21,7 +21,6 @@
   "Label-Connections": "اتصالات",
   "Label-Rules": "قوانین",
   "Label-Logs": "لاگ‌ها",
-  "Label-Test": "آزمون",
   "Label-Settings": "تنظیمات",
   "Proxies": "پراکسی‌ها",
   "Proxy Groups": "گروه‌های پراکسی",
@@ -166,7 +165,6 @@
   "Table View": "نمای جدولی",
   "List View": "نمای لیستی",
   "Close All": "بستن همه",
-  "Default": "پیش‌فرض",
   "Download Speed": "سرعت دانلود",
   "Upload Speed": "سرعت بارگذاری",
   "Host": "میزبان",
@@ -197,6 +195,8 @@
   "Settings": "تنظیمات",
   "System Setting": "تنظیمات سیستم",
   "Tun Mode": "Tun (کارت شبکه مجازی)",
+  "TUN requires Service Mode": "حالت تونل‌زنی نیاز به سرویس دارد",
+  "Install Service": "نصب سرویس",
   "Reset to Default": "بازنشانی به پیش‌فرض",
   "Tun Mode Info": "حالت Tun (NIC مجازی): تمام ترافیک سیستم را ضبط می کند، وقتی فعال باشد، نیازی به فعال کردن پروکسی سیستم نیست.",
   "Stack": "انباشته Tun",
@@ -275,13 +275,13 @@
   "Restart": "راه‌اندازی مجدد",
   "Release Version": "نسخه نهایی",
   "Alpha Version": "نسخه آلفا",
-  "Please Install and Enable Service Mode First": "لطفاً ابتدا حالت سرویس را نصب و فعال کنید",
   "Please enter your root password": "لطفاً رمز ریشه خود را وارد کنید",
   "Grant": "اعطا",
   "Open UWP tool": "باز کردن ابزار UWP",
   "Open UWP tool Info": "از ویندوز 8 به بعد، برنامه‌های UWP (مانند Microsoft Store) از دسترسی مستقیم به خدمات شبکه محلی محدود شده‌اند و این ابزار می‌تواند برای دور زدن این محدودیت استفاده شود",
   "Update GeoData": "به‌روزرسانی GeoData",
-  "Verge Setting": "تنظیمات Verge",
+  "Verge Basic Setting": "تنظیمات پایه Verge",
+  "Verge Advanced Setting": "تنظیمات پیشرفته Verge",
   "Language": "زبان",
   "Theme Mode": "حالت تم",
   "theme.light": "روشن",
@@ -368,6 +368,7 @@
   "Profile Reactivated": "پروفایل مجدداً فعال شد",
   "Only YAML Files Supported": "فقط فایل‌های YAML پشتیبانی می‌شوند",
   "Settings Applied": "تنظیمات اعمال شد",
+  "Installing Service...": "در حال نصب سرویس...",
   "Service Installed Successfully": "سرویس با موفقیت نصب شد",
   "Service Uninstalled Successfully": "سرویس با موفقیت حذف نصب شد",
   "Proxy Daemon Duration Cannot be Less than 1 Second": "مدت زمان دیمن پراکسی نمی‌تواند کمتر از 1 ثانیه باشد",
@@ -451,10 +452,9 @@
   "Script File Error": "خطای فایل اسکریپت، تغییرات برگشت داده شد",
   "Core Changed Successfully": "هسته با موفقیت تغییر کرد",
   "Failed to Change Core": "تغییر هسته ناموفق بود",
-  "Verge Basic Setting": "تنظیمات پایه Verge",
-  "Verge Advanced Setting": "تنظیمات پیشرفته Verge",
-  "TUN requires Service Mode": "حالت تونل‌زنی نیاز به سرویس دارد",
-  "Install Service": "نصب سرویس",
-  "Installing Service...": "در حال نصب سرویس...",
-  "Service Administrator Prompt": "Clash Verge برای نصب مجدد سرویس سیستم به امتیازات مدیر نیاز دارد"
+  "Service Administrator Prompt": "Clash Verge برای نصب مجدد سرویس سیستم به امتیازات مدیر نیاز دارد",
+  "Default": "پیش‌فرض",
+  "Label-Test": "آزمون",
+  "Please Install and Enable Service Mode First": "لطفاً ابتدا حالت سرویس را نصب و فعال کنید",
+  "Verge Setting": "تنظیمات Verge"
 }

src/locales/id.json

@@ -21,40 +21,7 @@
   "Label-Connections": "Koneksi",
   "Label-Rules": "Aturan",
   "Label-Logs": "Log",
-  "Label-Test": "Tes",
   "Label-Settings": "Pengaturan",
-  "Dashboard": "Dasbor",
-  "Profile": "Profil",
-  "Help": "Bantuan",
-  "About": "Tentang",
-  "Theme": "Tema",
-  "Main Window": "Jendela Utama",
-  "Group Icon": "Ikon Grup",
-  "Menu Icon": "Ikon Menu",
-  "PAC File": "Berkas PAC",
-  "Web UI": "Antarmuka Web",
-  "Hotkeys": "Pintasan",
-  "Verge Mixed Port": "Port Campuran Verge",
-  "Verge Socks Port": "Port Socks Verge",
-  "Verge Redir Port": "Port Pengalihan Verge",
-  "Verge Tproxy Port": "Port Tproxy Verge",
-  "Verge Port": "Port Verge",
-  "Verge HTTP Enabled": "HTTP Verge Diaktifkan",
-  "WebDAV URL": "URL WebDAV",
-  "WebDAV Username": "Nama Pengguna WebDAV",
-  "WebDAV Password": "Kata Sandi WebDAV",
-  "Restart App": "Mulai Ulang Aplikasi",
-  "Restart Clash Core": "Mulai Ulang Core Clash",
-  "TUN Mode": "Mode TUN",
-  "Copy Env": "Salin Env",
-  "Conf Dir": "Direktori Konfigurasi",
-  "Core Dir": "Direktori Core",
-  "Logs Dir": "Direktori Log",
-  "Open Dir": "Buka Direktori",
-  "More": "Lainnya",
-  "Rule Mode": "Mode Aturan",
-  "Global Mode": "Mode Global",
-  "Direct Mode": "Mode Langsung",
   "Proxies": "Proksi",
   "Proxy Groups": "Grup Proksi",
   "Proxy Provider": "Penyedia Proksi",
@@ -198,7 +165,6 @@
   "Table View": "Tampilan Tabel",
   "List View": "Tampilan Daftar",
   "Close All": "Tutup Semua",
-  "Default": "Default",
   "Download Speed": "Kecepatan Unduh",
   "Upload Speed": "Kecepatan Unggah",
   "Host": "Host",
@@ -229,6 +195,8 @@
   "Settings": "Pengaturan",
   "System Setting": "Pengaturan Sistem",
   "Tun Mode": "Mode Tun (NIC Virtual)",
+  "TUN requires Service Mode": "Mode TUN memerlukan layanan",
+  "Install Service": "Instal Layanan",
   "Reset to Default": "Setel Ulang ke Default",
   "Tun Mode Info": "Mode Tun (NIC Virtual): Menangkap semua lalu lintas sistem, saat diaktifkan, tidak perlu mengaktifkan proksi sistem.",
   "Stack": "Tumpukan Tun",
@@ -312,7 +280,8 @@
   "Open UWP tool": "Buka alat UWP",
   "Open UWP tool Info": "Sejak Windows 8, aplikasi UWP (seperti Microsoft Store) dibatasi dari mengakses layanan jaringan host lokal secara langsung, dan alat ini dapat digunakan untuk melewati pembatasan ini",
   "Update GeoData": "Perbarui GeoData",
-  "Verge Setting": "Pengaturan Verge",
+  "Verge Basic Setting": "Pengaturan Dasar Verge",
+  "Verge Advanced Setting": "Pengaturan Lanjutan Verge",
   "Language": "Bahasa",
   "Theme Mode": "Mode Tema",
   "theme.light": "Terang",
@@ -399,6 +368,7 @@
   "Profile Reactivated": "Profil Diaktifkan Kembali",
   "Only YAML Files Supported": "Hanya File YAML yang Didukung",
   "Settings Applied": "Pengaturan Diterapkan",
+  "Installing Service...": "Memasang Layanan...",
   "Service Installed Successfully": "Layanan Berhasil Diinstal",
   "Service Uninstalled Successfully": "Layanan Berhasil Dicopot",
   "Proxy Daemon Duration Cannot be Less than 1 Second": "Durasi Daemon Proksi Tidak Boleh Kurang dari 1 Detik",
@@ -437,6 +407,38 @@
   "Confirm to restore this backup file?": "Konfirmasi untuk memulihkan file cadangan ini?",
   "Restore Success, App will restart in 1s": "Pemulihan Berhasil, Aplikasi akan dimulai ulang dalam 1 detik",
   "Failed to fetch backup files": "Gagal mengambil file cadangan",
+  "Profile": "Profil",
+  "Help": "Bantuan",
+  "About": "Tentang",
+  "Theme": "Tema",
+  "Main Window": "Jendela Utama",
+  "Group Icon": "Ikon Grup",
+  "Menu Icon": "Ikon Menu",
+  "PAC File": "Berkas PAC",
+  "Web UI": "Antarmuka Web",
+  "Hotkeys": "Pintasan",
+  "Verge Mixed Port": "Port Campuran Verge",
+  "Verge Socks Port": "Port Socks Verge",
+  "Verge Redir Port": "Port Pengalihan Verge",
+  "Verge Tproxy Port": "Port Tproxy Verge",
+  "Verge Port": "Port Verge",
+  "Verge HTTP Enabled": "HTTP Verge Diaktifkan",
+  "WebDAV URL": "URL WebDAV",
+  "WebDAV Username": "Nama Pengguna WebDAV",
+  "WebDAV Password": "Kata Sandi WebDAV",
+  "Dashboard": "Dasbor",
+  "Restart App": "Mulai Ulang Aplikasi",
+  "Restart Clash Core": "Mulai Ulang Core Clash",
+  "TUN Mode": "Mode TUN",
+  "Copy Env": "Salin Env",
+  "Conf Dir": "Direktori Konfigurasi",
+  "Core Dir": "Direktori Core",
+  "Logs Dir": "Direktori Log",
+  "Open Dir": "Buka Direktori",
+  "More": "Lainnya",
+  "Rule Mode": "Mode Aturan",
+  "Global Mode": "Mode Global",
+  "Direct Mode": "Mode Langsung",
   "Enable Tray Speed": "Aktifkan Tray Speed",
   "LightWeight Mode": "Mode Ringan",
   "LightWeight Mode Info": "Tutup GUI dan biarkan hanya kernel yang berjalan",
@@ -450,10 +452,8 @@
   "Script File Error": "Kesalahan file skrip, perubahan dibatalkan",
   "Core Changed Successfully": "Inti berhasil diubah",
   "Failed to Change Core": "Gagal mengubah inti",
-  "Verge Basic Setting": "Pengaturan Dasar Verge",
-  "Verge Advanced Setting": "Pengaturan Lanjutan Verge",
-  "TUN requires Service Mode": "Mode TUN memerlukan layanan",
-  "Install Service": "Instal Layanan",
-  "Installing Service...": "Memasang Layanan...",
-  "Service Administrator Prompt": "Clash Verge memerlukan hak administrator untuk menginstal ulang layanan sistem"
+  "Service Administrator Prompt": "Clash Verge memerlukan hak administrator untuk menginstal ulang layanan sistem",
+  "Default": "Default",
+  "Label-Test": "Tes",
+  "Verge Setting": "Pengaturan Verge"
 }