chore: publish tag alpha support

.devcontainer/devcontainer.json

@@ -1,101 +0,0 @@
-{
-  "name": "Clash Verge Rev Development Environment",
-  "image": "mcr.microsoft.com/devcontainers/base:ubuntu-22.04",
-
-  "features": {
-    "ghcr.io/devcontainers/features/node:1": {
-      "version": "20"
-    },
-    "ghcr.io/devcontainers/features/rust:1": {
-      "version": "latest",
-      "profile": "default"
-    },
-    "ghcr.io/devcontainers/features/git:1": {},
-    "ghcr.io/devcontainers/features/github-cli:1": {},
-    "ghcr.io/devcontainers/features/docker-in-docker:2": {}
-  },
-
-  "customizations": {
-    "vscode": {
-      "extensions": [
-        "rust-lang.rust-analyzer",
-        "tauri-apps.tauri-vscode",
-        "ms-vscode.vscode-typescript-next",
-        "esbenp.prettier-vscode",
-        "bradlc.vscode-tailwindcss",
-        "ms-vscode.vscode-json",
-        "redhat.vscode-yaml",
-        "formulahendry.auto-rename-tag",
-        "ms-vscode.hexeditor",
-        "christian-kohler.path-intellisense",
-        "yzhang.markdown-all-in-one",
-        "streetsidesoftware.code-spell-checker",
-        "ms-vscode.vscode-eslint"
-      ],
-      "settings": {
-        "rust-analyzer.cargo.features": ["verge-dev"],
-        "rust-analyzer.check.command": "clippy",
-        "editor.formatOnSave": true,
-        "editor.defaultFormatter": "esbenp.prettier-vscode",
-        "[rust]": {
-          "editor.defaultFormatter": "rust-lang.rust-analyzer"
-        },
-        "[json]": {
-          "editor.defaultFormatter": "esbenp.prettier-vscode"
-        },
-        "[yaml]": {
-          "editor.defaultFormatter": "redhat.vscode-yaml"
-        },
-        "[typescript]": {
-          "editor.defaultFormatter": "esbenp.prettier-vscode"
-        },
-        "[typescriptreact]": {
-          "editor.defaultFormatter": "esbenp.prettier-vscode"
-        }
-      }
-    }
-  },
-
-  "forwardPorts": [1420, 3000, 8080, 9090, 7890, 7891],
-
-  "portsAttributes": {
-    "1420": {
-      "label": "Tauri Dev Server",
-      "onAutoForward": "notify"
-    },
-    "3000": {
-      "label": "Vite Dev Server",
-      "onAutoForward": "notify"
-    },
-    "7890": {
-      "label": "Clash HTTP Proxy",
-      "onAutoForward": "silent"
-    },
-    "7891": {
-      "label": "Clash SOCKS Proxy",
-      "onAutoForward": "silent"
-    },
-    "9090": {
-      "label": "Clash API",
-      "onAutoForward": "silent"
-    }
-  },
-
-  "postCreateCommand": "bash .devcontainer/post-create.sh",
-
-  "mounts": [
-    "source=clash-verge-node-modules,target=${containerWorkspaceFolder}/node_modules,type=volume",
-    "source=clash-verge-cargo-registry,target=/usr/local/cargo/registry,type=volume",
-    "source=clash-verge-cargo-git,target=/usr/local/cargo/git,type=volume"
-  ],
-
-  "containerEnv": {
-    "RUST_BACKTRACE": "1",
-    "NODE_OPTIONS": "--max-old-space-size=4096",
-    "TAURI_DEV_WATCHER_IGNORE_FILE": ".taurignore"
-  },
-
-  "remoteUser": "vscode",
-  "workspaceFolder": "/workspaces/clash-verge-rev",
-  "shutdownAction": "stopContainer"
-}

.github/FUNDING.yml

@@ -1 +0,0 @@
-github: clash-verge-rev

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -9,16 +9,13 @@ body:
     attributes:
       value: |
         ## 在提交问题之前，请确认以下事项：
-
         1. 请 **确保** 您已经查阅了 [Clash Verge Rev 官方文档](https://clash-verge-rev.github.io/guide/term.html)  以及 [常见问题](https://clash-verge-rev.github.io/faq/windows.html)
         2. 请 **确保** [已有的问题](https://github.com/clash-verge-rev/clash-verge-rev/issues?q=is%3Aissue) 中没有人提交过相似issue，否则请在已有的issue下进行讨论
         3. 请 **务必** 给issue填写一个简洁明了的标题，以便他人快速检索
         4. 请 **务必** 查看 [Alpha](https://github.com/clash-verge-rev/clash-verge-rev/releases/tag/alpha) 版本更新日志
         5. 请 **务必** 尝试 [Alpha](https://github.com/clash-verge-rev/clash-verge-rev/releases/tag/alpha) 版本，确定问题是否仍然存在
         6. 请 **务必** 按照模板规范详细描述问题以及尝试更新 Alpha 版本，否则issue将会被直接关闭
-
         ## Before submitting the issue, please make sure of the following checklist:
-
         1. Please make sure you have read the [Clash Verge Rev official documentation](https://clash-verge-rev.github.io/guide/term.html) and [FAQ](https://clash-verge-rev.github.io/faq/windows.html)
         2. Please make sure there is no similar issue in the [existing issues](https://github.com/clash-verge-rev/clash-verge-rev/issues?q=is%3Aissue), otherwise please discuss under the existing issue
         3. Please be sure to fill in a concise and clear title for the issue so that others can quickly search
@@ -37,7 +34,6 @@ body:
     attributes:
       label: 软件版本 / Verge Version
       description: 请提供Verge的具体版本，如果是alpha版本，请注明下载时间(精确到小时分钟) / Please provide the specific version of Verge. If it is an alpha version, please indicate the download time (accurate to hours and minutes)
-      render: text
     validations:
       required: true
   - type: textarea
@@ -46,13 +42,13 @@ body:
       description: 请提供复现问题的步骤 / Steps to reproduce the behavior
     validations:
       required: true
-  - type: checkboxes
+  - type: dropdown
     attributes:
       label: 操作系统 / OS
       options:
-        - label: Windows
-        - label: Linux
-        - label: MacOS
+        - Windows
+        - Linux
+        - MacOS
     validations:
       required: true
   - type: input
@@ -65,9 +61,5 @@ body:
     attributes:
       label: 日志(勿上传日志文件，请粘贴日志内容) / Log (Do not upload the log file, paste the log content directly)
       description: 请提供完整或相关部分的Debug日志（请在“软件左侧菜单”->“设置”->“日志等级”调整到debug，Verge错误请把“杂项设置”->“app日志等级”调整到debug，并重启Verge生效。日志文件在“软件左侧菜单”->“设置”->“日志目录”下） / Please provide a complete or relevant part of the Debug log (please adjust the "Log level" to debug in "Software left menu" -> "Settings" -> "Log level". If there is a Verge error, please adjust "Miscellaneous settings" -> "app log level" to debug, and restart Verge to take effect. The log file is under "Software left menu" -> "Settings" -> "Log directory")
-      placeholder: |
-        日志目录一般位于 Clash Verge Rev 安装目录的 "logs/" 子目录中，请将日志内容粘贴到此处。
-        Log directory is usually located in the "logs/" subdirectory of the Clash Verge Rev installation directory, please paste the log content here.
-      render: log
     validations:
       required: true

.github/ISSUE_TEMPLATE/config.yml

@@ -1,4 +1,3 @@
-blank_issues_enabled: false
 contact_links:
   - name: 讨论交流 / Communication
     url: https://t.me/clash_verge_rev

.github/ISSUE_TEMPLATE/i18n_request.yml

@@ -1,58 +0,0 @@
-name: I18N / 多语言相关
-title: "[I18N] "
-description: 用于多语言翻译、国际化相关问题或建议 / For issues or suggestions related to translations and internationalization
-labels: ["I18n"]
-type: "Task"
-
-body:
-  - type: markdown
-    attributes:
-      value: |
-        ## I18N 相关问题/建议
-        请用此模板提交翻译错误、缺失、建议或新增语言请求。
-        Please use this template for translation errors, missing translations, suggestions, or new language requests.
-
-  - type: textarea
-    id: description
-    attributes:
-      label: 问题描述 / Description
-      description: 详细描述你的 I18N 问题或建议 / Please describe your I18N issue or suggestion in detail
-    validations:
-      required: true
-
-  - type: input
-    id: language
-    attributes:
-      label: 相关语言 / Language
-      description: 例如 zh, en, jp, ru, ... / e.g. zh, en, jp, ru, ...
-    validations:
-      required: true
-
-  - type: textarea
-    id: suggestion
-    attributes:
-      label: 建议或修正内容 / Suggestion or Correction
-      description: 如果是翻译修正或建议，请填写建议的内容 / If this is a translation correction or suggestion, please provide the suggested content
-    validations:
-      required: false
-
-  - type: checkboxes
-    id: i18n-type
-    attributes:
-      label: 问题类型 / Issue Type
-      description: 请选择适用类型（可多选） / Please select the applicable type(s)
-      options:
-        - label: 翻译错误 / Translation error
-        - label: 翻译缺失 / Missing translation
-        - label: 建议优化 / Suggestion
-        - label: 新增语言 / New language
-    validations:
-      required: true
-
-  - type: input
-    id: verge-version
-    attributes:
-      label: 软件版本 / Verge Version
-      description: 请提供你使用的 Verge 具体版本 / Please provide the specific version of Verge you are using
-    validations:
-      required: true

.github/workflows/alpha.yml

@@ -4,21 +4,10 @@ on:
   # 因为 alpha 不再负责频繁构建，且需要相对于 autobuild 更稳定使用环境
   # 所以不再使用 workflow_dispatch 触发
   # 应当通过 git tag 来触发构建
-  # TODO 手动控制版本号
-  workflow_dispatch:
-    # inputs:
-    #   tag_name:
-    #     description: "Alpha tag name (e.g. v1.2.3-alpha.1)"
-    #     required: true
-    #     type: string
-
-  # push:
-  #   # 应当限制在 dev 分支上触发发布。
-  #   branches:
-  #     - dev
-  #   # 应当限制 v*.*.*-alpha* 的 tag 来触发发布。
-  #   tags:
-  #     - "v*.*.*-alpha*"
+  # workflow_dispatch:
+  push:
+    tags:
+      - "v*.*.*-alpha*"
 permissions: write-all
 env:
   TAG_NAME: alpha
@@ -29,37 +18,8 @@ concurrency:
   group: "${{ github.workflow }} - ${{ github.head_ref || github.ref }}"
 
 jobs:
-  check_alpha_tag:
-    name: Check Alpha Tag package.json Version Consistency
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Check tag and package.json version
-        id: check_tag
-        run: |
-          TAG_REF="${GITHUB_REF##*/}"
-          echo "Current tag: $TAG_REF"
-          if [[ ! "$TAG_REF" =~ -alpha ]]; then
-            echo "Current tag is not an alpha tag."
-            exit 1
-          fi
-          PKG_VERSION=$(jq -r .version package.json)
-          echo "package.json version: $PKG_VERSION"
-          if [[ "$PKG_VERSION" != *alpha* ]]; then
-            echo "package.json version is not an alpha version."
-            exit 1
-          fi
-          if [[ "$TAG_REF" != "v$PKG_VERSION" ]]; then
-            echo "Tag ($TAG_REF) does not match package.json version (v$PKG_VERSION)."
-            exit 1
-          fi
-          echo "Alpha tag and package.json version are consistent."
-
   delete_old_assets:
     name: Delete Old Alpha Release Assets and Tags
-    needs: check_alpha_tag
     runs-on: ubuntu-latest
     steps:
       - name: Delete Old Alpha Tags Except Latest
@@ -286,7 +246,8 @@ jobs:
         uses: Swatinem/rust-cache@v2
         with:
           workspaces: src-tauri
-          save-if: false
+          cache-all-crates: true
+          cache-on-failure: true
 
       - name: Install dependencies (ubuntu only)
         if: matrix.os == 'ubuntu-22.04'
@@ -294,15 +255,6 @@ jobs:
           sudo apt-get update
           sudo apt-get install -y libxslt1.1 libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librsvg2-dev patchelf
 
-      - name: Install x86 OpenSSL (macOS only)
-        if: matrix.target == 'x86_64-apple-darwin'
-        run: |
-          arch -x86_64 brew install openssl@3
-          echo "OPENSSL_DIR=$(brew --prefix openssl@3)" >> $GITHUB_ENV
-          echo "OPENSSL_INCLUDE_DIR=$(brew --prefix openssl@3)/include" >> $GITHUB_ENV
-          echo "OPENSSL_LIB_DIR=$(brew --prefix openssl@3)/lib" >> $GITHUB_ENV
-          echo "PKG_CONFIG_PATH=$(brew --prefix openssl@3)/lib/pkgconfig" >> $GITHUB_ENV
-
       - name: Install Node
         uses: actions/setup-node@v4
         with:
@@ -316,7 +268,7 @@ jobs:
       - name: Pnpm install and check
         run: |
           pnpm i
-          pnpm run prebuild ${{ matrix.target }}
+          pnpm check ${{ matrix.target }}
 
       # - name: Release ${{ env.TAG_CHANNEL }} Version
       #   run: pnpm release-version ${{ env.TAG_NAME }}
@@ -371,7 +323,7 @@ jobs:
         uses: Swatinem/rust-cache@v2
         with:
           workspaces: src-tauri
-          save-if: false
+          cache-all-crates: true
 
       - name: Install Node
         uses: actions/setup-node@v4
@@ -386,7 +338,7 @@ jobs:
       - name: Pnpm install and check
         run: |
           pnpm i
-          pnpm run prebuild ${{ matrix.target }}
+          pnpm check ${{ matrix.target }}
 
       # - name: Release ${{ env.TAG_CHANNEL }} Version
       #   run: pnpm release-version ${{ env.TAG_NAME }}
@@ -499,7 +451,8 @@ jobs:
         uses: Swatinem/rust-cache@v2
         with:
           workspaces: src-tauri
-          save-if: false
+          cache-all-crates: true
+          cache-on-failure: true
 
       - name: Install Node
         uses: actions/setup-node@v4
@@ -514,7 +467,7 @@ jobs:
       - name: Pnpm install and check
         run: |
           pnpm i
-          pnpm run prebuild ${{ matrix.target }}
+          pnpm check ${{ matrix.target }}
 
       # - name: Release ${{ env.TAG_CHANNEL }} Version
       #   run: pnpm release-version ${{ env.TAG_NAME }}

.github/workflows/autobuild-check-test.yml

@@ -1,133 +0,0 @@
-name: Autobuild Check Logic Test
-
-on:
-  workflow_dispatch:
-
-jobs:
-  check_autobuild_logic:
-    name: Check Autobuild Should Run Logic
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 2
-
-      - name: Check if version or source changed, or assets already exist
-        id: check
-        run: |
-          # # 仅用于测试逻辑，手动触发自动跳过
-          # if [ "${{ github.event_name }}" == "workflow_dispatch" ]; then
-          #   echo "should_run=skip" >> $GITHUB_OUTPUT
-          #   echo "🟡 手动触发，跳过 should_run 检查"
-          #   exit 0
-          # fi
-
-          # 确保有 HEAD~1
-          if ! git rev-parse HEAD~1 > /dev/null 2>&1; then
-            echo "should_run=true" >> $GITHUB_OUTPUT
-            echo "🟢 没有前一个提交，默认需要构建"
-            exit 0
-          fi
-
-          # 版本号变更判断
-          CURRENT_VERSION=$(jq -r '.version' package.json)
-          PREVIOUS_VERSION=$(git show HEAD~1:package.json | jq -r '.version' 2>/dev/null || echo "")
-
-          if [ "$CURRENT_VERSION" != "$PREVIOUS_VERSION" ]; then
-            echo "should_run=true" >> $GITHUB_OUTPUT
-            echo "🟢 版本号变更: $PREVIOUS_VERSION → $CURRENT_VERSION"
-            exit 0
-          fi
-
-          # 检查 src 变更（排除常见产物与缓存）
-          SRC_DIFF=$(git diff --name-only HEAD~1 HEAD -- src/ | grep -Ev '^src/(dist|build|node_modules|\.next|\.cache)' || true)
-          TAURI_DIFF=$(git diff --name-only HEAD~1 HEAD -- src-tauri/ | grep -Ev '^src-tauri/(target|node_modules|dist|\.cache)' || true)
-
-          if [ -n "$SRC_DIFF" ] || [ -n "$TAURI_DIFF" ]; then
-            echo "should_run=true" >> $GITHUB_OUTPUT
-            echo "🟢 源码变更 detected"
-            exit 0
-          fi
-
-          # 找到最后一个修改 Tauri 相关文件的 commit
-          echo "🔍 查找最后一个 Tauri 相关变更的 commit..."
-
-          LAST_TAURI_COMMIT=""
-          for commit in $(git rev-list HEAD --max-count=50); do
-            # 检查此 commit 是否修改了 Tauri 相关文件
-            CHANGED_FILES=$(git show --name-only --pretty=format: $commit | tr '\n' ' ')
-            HAS_TAURI_CHANGES=false
-            
-            # 检查各个模式
-            if echo "$CHANGED_FILES" | grep -q "src/" && echo "$CHANGED_FILES" | grep -qvE "src/(dist|build|node_modules|\.next|\.cache)"; then
-              HAS_TAURI_CHANGES=true
-            elif echo "$CHANGED_FILES" | grep -qE "src-tauri/(src|Cargo\.(toml|lock)|tauri\..*\.conf\.json|build\.rs|capabilities)"; then
-              HAS_TAURI_CHANGES=true
-            fi
-            
-            if [ "$HAS_TAURI_CHANGES" = true ]; then
-              LAST_TAURI_COMMIT=$(git rev-parse --short $commit)
-              break
-            fi
-          done
-
-          if [ -z "$LAST_TAURI_COMMIT" ]; then
-            echo "⚠️  最近的 commits 中未找到 Tauri 相关变更，使用当前 commit"
-            LAST_TAURI_COMMIT=$(git rev-parse --short HEAD)
-          fi
-
-          CURRENT_COMMIT=$(git rev-parse --short HEAD)
-          echo "📝 最后 Tauri 相关 commit: $LAST_TAURI_COMMIT"
-          echo "📝 当前 commit: $CURRENT_COMMIT"
-
-          # 检查 autobuild release 是否存在
-          AUTOBUILD_RELEASE_EXISTS=$(gh release view "autobuild" --json id -q '.id' 2>/dev/null || echo "")
-
-          if [ -z "$AUTOBUILD_RELEASE_EXISTS" ]; then
-            echo "should_run=true" >> $GITHUB_OUTPUT
-            echo "🟢 没有 autobuild release，需构建"
-          else
-            # 检查 latest.json 是否存在
-            LATEST_JSON_EXISTS=$(gh release view "autobuild" --json assets -q '.assets[] | select(.name == "latest.json") | .name' 2>/dev/null || echo "")
-            
-            if [ -z "$LATEST_JSON_EXISTS" ]; then
-              echo "should_run=true" >> $GITHUB_OUTPUT
-              echo "🟢 没有 latest.json，需构建"
-            else
-              # 下载并解析 latest.json 检查版本和 commit hash
-              echo "📥 下载 latest.json 检查版本..."
-              LATEST_JSON_URL=$(gh release view "autobuild" --json assets -q '.assets[] | select(.name == "latest.json") | .browser_download_url' 2>/dev/null)
-              
-              if [ -n "$LATEST_JSON_URL" ]; then
-                LATEST_JSON_CONTENT=$(curl -s "$LATEST_JSON_URL" 2>/dev/null || echo "")
-                
-                if [ -n "$LATEST_JSON_CONTENT" ]; then
-                  LATEST_VERSION=$(echo "$LATEST_JSON_CONTENT" | jq -r '.version' 2>/dev/null || echo "")
-                  echo "📦 最新 autobuild 版本: $LATEST_VERSION"
-                  
-                  # 从版本字符串中提取 commit hash (格式: X.Y.Z+autobuild.MMDD.commit)
-                  LATEST_COMMIT=$(echo "$LATEST_VERSION" | sed -n 's/.*+autobuild\.[0-9]\{4\}\.\([a-f0-9]*\)$/\1/p' || echo "")
-                  echo "📝 最新 autobuild commit: $LATEST_COMMIT"
-                  
-                  if [ "$LAST_TAURI_COMMIT" != "$LATEST_COMMIT" ]; then
-                    echo "should_run=true" >> $GITHUB_OUTPUT
-                    echo "🟢 Tauri commit hash 不匹配 ($LAST_TAURI_COMMIT != $LATEST_COMMIT)，需构建"
-                  else
-                    echo "should_run=false" >> $GITHUB_OUTPUT
-                    echo "🔴 相同 Tauri commit hash ($LAST_TAURI_COMMIT)，不需构建"
-                  fi
-                else
-                  echo "should_run=true" >> $GITHUB_OUTPUT
-                  echo "⚠️  无法下载或解析 latest.json，需构建"
-                fi
-              else
-                echo "should_run=true" >> $GITHUB_OUTPUT
-                echo "⚠️  无法获取 latest.json 下载 URL，需构建"
-              fi
-            fi
-          fi
-
-      - name: Output should_run result
-        run: |
-          echo "Result: ${{ steps.check.outputs.should_run }}"

.github/workflows/autobuild.yml

@@ -3,14 +3,12 @@ name: Auto Build
 on:
   workflow_dispatch:
   schedule:
-    # UTC+8 12:00, 18:00 -> UTC 4:00, 10:00
-    - cron: "0 4,10 * * *"
+    # UTC+8 0,6,12,18
+    - cron: "0 16,22,4,10 * * *"
 permissions: write-all
 env:
   TAG_NAME: autobuild
   TAG_CHANNEL: AutoBuild
-  PRE_TAG_NAME: pre-autobuild
-  PRE_TAG_CHANNEL: PreAutoBuild
   CARGO_INCREMENTAL: 0
   RUST_BACKTRACE: short
 concurrency:
@@ -20,10 +18,55 @@ concurrency:
 jobs:
   check_commit:
     name: Check Commit Needs Build
-    uses: clash-verge-rev/clash-verge-rev/.github/workflows/check-commit-needs-build.yml@dev
-    with:
-      tag_name: autobuild
-      force_build: ${{ github.event_name == 'workflow_dispatch' }}
+    runs-on: ubuntu-latest
+    outputs:
+      should_run: ${{ steps.check.outputs.should_run }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 2
+
+      - name: Check if version changed or src changed
+        id: check
+        run: |
+          if [ "${{ github.event_name }}" == "workflow_dispatch" ]; then
+            echo "should_run=true" >> $GITHUB_OUTPUT
+            exit 0
+          fi
+
+          CURRENT_VERSION=$(cat package.json | jq -r '.version')
+          echo "Current version: $CURRENT_VERSION"
+
+          git checkout HEAD~1 package.json
+          PREVIOUS_VERSION=$(cat package.json | jq -r '.version')
+          echo "Previous version: $PREVIOUS_VERSION"
+
+          git checkout HEAD package.json
+
+          if [ "$CURRENT_VERSION" != "$PREVIOUS_VERSION" ]; then
+            echo "Version changed from $PREVIOUS_VERSION to $CURRENT_VERSION"
+            echo "should_run=true" >> $GITHUB_OUTPUT
+            exit 0
+          fi
+
+          CURRENT_SRC_HASH=$(git rev-parse HEAD:src)
+          PREVIOUS_SRC_HASH=$(git rev-parse HEAD~1:src 2>/dev/null || echo "")
+          CURRENT_TAURI_HASH=$(git rev-parse HEAD:src-tauri 2>/dev/null || echo "")
+          PREVIOUS_TAURI_HASH=$(git rev-parse HEAD~1:src-tauri 2>/dev/null || echo "")
+
+          echo "Current src hash: $CURRENT_SRC_HASH"
+          echo "Previous src hash: $PREVIOUS_SRC_HASH"
+          echo "Current tauri hash: $CURRENT_TAURI_HASH"
+          echo "Previous tauri hash: $PREVIOUS_TAURI_HASH"
+
+          if [ "$CURRENT_SRC_HASH" != "$PREVIOUS_SRC_HASH" ] || [ "$CURRENT_TAURI_HASH" != "$PREVIOUS_TAURI_HASH" ]; then
+            echo "Source directories changed"
+            echo "should_run=true" >> $GITHUB_OUTPUT
+          else
+            echo "Version and source directories unchanged"
+            echo "should_run=false" >> $GITHUB_OUTPUT
+          fi
 
   update_tag:
     name: Update tag
@@ -52,28 +95,9 @@ jobs:
           fi
         shell: bash
 
-      - uses: pnpm/action-setup@v4
-        name: Install pnpm
-        with:
-          run_install: false
-
-      - name: Install Node
-        uses: actions/setup-node@v4
-        with:
-          node-version: "22"
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Release AutoBuild Version
-        run: pnpm release-version autobuild-latest
-
       - name: Set Env
         run: |
           echo "BUILDTIME=$(TZ=Asia/Shanghai date)" >> $GITHUB_ENV
-          VERSION=$(jq -r .version package.json)
-          echo "VERSION=$VERSION" >> $GITHUB_ENV
-          echo "DOWNLOAD_URL=https://github.com/clash-verge-rev/clash-verge-rev/releases/download/${{ env.PRE_TAG_NAME }}" >> $GITHUB_ENV
         shell: bash
 
       - run: |
@@ -87,24 +111,25 @@ jobs:
           cat > release.txt << EOF
           $UPDATE_LOGS
 
-          ## 下载地址
+          ## 我应该下载哪个版本？
+
+          ### MacOS
+          - MacOS intel芯片: x64.dmg
+          - MacOS apple M芯片: aarch64.dmg
+
+          ### Linux
+          - Linux 64位: amd64.deb/amd64.rpm
+          - Linux arm64 architecture: arm64.deb/aarch64.rpm
+          - Linux armv7架构: armhf.deb/armhfp.rpm
 
           ### Windows (不再支持Win7)
           #### 正常版本(推荐)
-          - [64位(常用)](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_x64-setup.exe) | [ARM64(不常用)](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_arm64-setup.exe)
-
+          - 64位: x64-setup.exe
+          - arm64架构: arm64-setup.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)
-
-          ### macOS
-          - [Apple M芯片](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_aarch64.dmg) | [Intel芯片](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_x64.dmg)
-
-          ### Linux
-          #### DEB包(Debian系) 使用 apt ./路径 安装
-          - [64位](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_amd64.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 }}_amd64.rpm) | [ARM64](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_aarch64.rpm) | [ARMv7](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_armhfp.rpm)
+          - 64位: x64_fixed_webview2-setup.exe
+          - arm64架构: arm64_fixed_webview2-setup.exe
 
           ### FAQ
           - [常见问题](https://clash-verge-rev.github.io/faq/windows.html)
@@ -115,30 +140,19 @@ jobs:
           Created at ${{ env.BUILDTIME }}.
           EOF
 
-      - name: Upload Pre-Release
+      - name: Upload Release
         uses: softprops/action-gh-release@v2
         with:
-          tag_name: ${{ env.PRE_TAG_NAME }}
-          name: "Clash Verge Rev ${{ env.PRE_TAG_CHANNEL }}"
+          tag_name: ${{ env.TAG_NAME }}
+          name: "Clash Verge Rev ${{ env.TAG_CHANNEL }}"
           body_path: release.txt
           prerelease: true
           token: ${{ secrets.GITHUB_TOKEN }}
           generate_release_notes: true
 
-  clean_old_assets:
-    name: Clean Old Release Assets
-    needs: [check_commit, update_tag]
-    if: ${{ needs.check_commit.outputs.should_run == 'true' && needs.update_tag.result == 'success' }}
-
-    uses: clash-verge-rev/clash-verge-rev/.github/workflows/clean-old-assets.yml@dev
-    with:
-      tag_name: pre-autobuild
-      dry_run: false
-
   autobuild-x86-windows-macos-linux:
     name: Autobuild x86 Windows, MacOS and Linux
-    needs: [check_commit, update_tag]
-    if: ${{ needs.check_commit.outputs.should_run == 'true' }}
+    needs: update_tag
     strategy:
       fail-fast: false
       matrix:
@@ -169,8 +183,7 @@ jobs:
         with:
           workspaces: src-tauri
           cache-all-crates: true
-          save-if: ${{ github.ref == 'refs/heads/dev' }}
-          shared-key: autobuild-shared
+          cache-on-failure: true
 
       - name: Install dependencies (ubuntu only)
         if: matrix.os == 'ubuntu-22.04'
@@ -178,35 +191,25 @@ jobs:
           sudo apt-get update
           sudo apt-get install -y libxslt1.1 libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librsvg2-dev patchelf
 
-      - name: Install x86 OpenSSL (macOS only)
-        if: matrix.target == 'x86_64-apple-darwin'
-        run: |
-          arch -x86_64 brew install openssl@3
-          echo "OPENSSL_DIR=$(brew --prefix openssl@3)" >> $GITHUB_ENV
-          echo "OPENSSL_INCLUDE_DIR=$(brew --prefix openssl@3)/include" >> $GITHUB_ENV
-          echo "OPENSSL_LIB_DIR=$(brew --prefix openssl@3)/lib" >> $GITHUB_ENV
-          echo "PKG_CONFIG_PATH=$(brew --prefix openssl@3)/lib/pkgconfig" >> $GITHUB_ENV
+      - name: Install Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: "22"
 
       - uses: pnpm/action-setup@v4
         name: Install pnpm
         with:
           run_install: false
 
-      - name: Install Node
-        uses: actions/setup-node@v4
-        with:
-          node-version: "22"
-          cache: "pnpm"
-
       - name: Pnpm install and check
         run: |
           pnpm i
-          pnpm run prebuild ${{ matrix.target }}
+          pnpm check ${{ matrix.target }}
 
-      - name: Release ${{ env.PRE_TAG_CHANNEL }} Version
-        run: pnpm release-version autobuild-latest
+      - name: Release ${{ env.TAG_CHANNEL }} Version
+        run: pnpm release-version ${{ env.TAG_NAME }}
 
-      - name: Tauri build for Windows-macOS-Linux
+      - name: Tauri build
         uses: tauri-apps/tauri-action@v0
         env:
           NODE_OPTIONS: "--max_old_space_size=4096"
@@ -220,8 +223,8 @@ jobs:
           APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
           APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
         with:
-          tagName: ${{ env.PRE_TAG_NAME }}
-          releaseName: "Clash Verge Rev ${{ env.PRE_TAG_CHANNEL }}"
+          tagName: ${{ env.TAG_NAME }}
+          releaseName: "Clash Verge Rev ${{ env.TAG_CHANNEL }}"
           releaseBody: "More new features are now supported."
           releaseDraft: false
           prerelease: true
@@ -230,8 +233,7 @@ jobs:
 
   autobuild-arm-linux:
     name: Autobuild ARM Linux
-    needs: [check_commit, update_tag]
-    if: ${{ needs.check_commit.outputs.should_run == 'true' }}
+    needs: update_tag
     strategy:
       fail-fast: false
       matrix:
@@ -258,27 +260,24 @@ jobs:
         with:
           workspaces: src-tauri
           cache-all-crates: true
-          save-if: ${{ github.ref == 'refs/heads/dev' }}
-          shared-key: autobuild-shared
+
+      - name: Install Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: "22"
 
       - name: Install pnpm
         uses: pnpm/action-setup@v4
         with:
           run_install: false
 
-      - name: Install Node
-        uses: actions/setup-node@v4
-        with:
-          node-version: "22"
-          cache: "pnpm"
-
       - name: Pnpm install and check
         run: |
           pnpm i
-          pnpm run prebuild ${{ matrix.target }}
+          pnpm check ${{ matrix.target }}
 
-      - name: Release ${{ env.PRE_TAG_CHANNEL }} Version
-        run: pnpm release-version autobuild-latest
+      - name: Release ${{ env.TAG_CHANNEL }} Version
+        run: pnpm release-version ${{ env.TAG_NAME }}
 
       - name: Setup for linux
         run: |
@@ -329,7 +328,7 @@ jobs:
             gcc-arm-linux-gnueabihf \
             g++-arm-linux-gnueabihf
 
-      - name: Tauri Build for Linux
+      - name: Build for Linux
         run: |
           export PKG_CONFIG_ALLOW_CROSS=1
           if [ "${{ matrix.target }}" == "aarch64-unknown-linux-gnu" ]; then
@@ -352,11 +351,11 @@ jobs:
           echo "VERSION=$(cat package.json | jq '.version' | tr -d '"')" >> $GITHUB_ENV
           echo "BUILDTIME=$(TZ=Asia/Shanghai date)" >> $GITHUB_ENV
 
-      - name: Upload Pre-Release
+      - name: Upload Release
         uses: softprops/action-gh-release@v2
         with:
-          tag_name: ${{ env.PRE_TAG_NAME }}
-          name: "Clash Verge Rev ${{ env.PRE_TAG_CHANNEL }}"
+          tag_name: ${{ env.TAG_NAME }}
+          name: "Clash Verge Rev ${{ env.TAG_CHANNEL }}"
           prerelease: true
           token: ${{ secrets.GITHUB_TOKEN }}
           files: |
@@ -365,8 +364,7 @@ jobs:
 
   autobuild-x86-arm-windows_webview2:
     name: Autobuild x86 and ARM Windows with WebView2
-    needs: [check_commit, update_tag]
-    if: ${{ needs.check_commit.outputs.should_run == 'true' }}
+    needs: update_tag
     strategy:
       fail-fast: false
       matrix:
@@ -390,27 +388,25 @@ jobs:
         with:
           workspaces: src-tauri
           cache-all-crates: true
-          save-if: ${{ github.ref == 'refs/heads/dev' }}
-          shared-key: autobuild-shared
-
-      - name: Install pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          run_install: false
+          cache-on-failure: true
 
       - name: Install Node
         uses: actions/setup-node@v4
         with:
           node-version: "22"
-          cache: "pnpm"
+
+      - uses: pnpm/action-setup@v4
+        name: Install pnpm
+        with:
+          run_install: false
 
       - name: Pnpm install and check
         run: |
           pnpm i
-          pnpm run prebuild ${{ matrix.target }}
+          pnpm check ${{ matrix.target }}
 
-      - name: Release ${{ env.PRE_TAG_CHANNEL }} Version
-        run: pnpm release-version autobuild-latest
+      - name: Release ${{ env.TAG_CHANNEL }} Version
+        run: pnpm release-version ${{ env.TAG_NAME }}
 
       - name: Download WebView2 Runtime
         run: |
@@ -419,7 +415,7 @@ jobs:
           Remove-Item .\src-tauri\tauri.windows.conf.json
           Rename-Item .\src-tauri\webview2.${{ matrix.arch }}.json tauri.windows.conf.json
 
-      - name: Tauri build for Windows
+      - name: Tauri build
         id: build
         uses: tauri-apps/tauri-action@v0
         env:
@@ -451,163 +447,16 @@ jobs:
             Rename-Item $file.FullName $newName
           }
 
-      - name: Upload Pre-Release
+      - name: Upload Release
         uses: softprops/action-gh-release@v2
         with:
-          tag_name: ${{ env.PRE_TAG_NAME }}
-          name: "Clash Verge Rev ${{ env.PRE_TAG_CHANNEL }}"
+          tag_name: ${{ env.TAG_NAME }}
+          name: "Clash Verge Rev ${{ env.TAG_CHANNEL }}"
           prerelease: true
           token: ${{ secrets.GITHUB_TOKEN }}
           files: src-tauri/target/${{ matrix.target }}/release/bundle/nsis/*setup*
 
       - name: Portable Bundle
-        run: pnpm portable-fixed-webview2 ${{ matrix.target }} --${{ env.PRE_TAG_NAME }}
+        run: pnpm portable-fixed-webview2 ${{ matrix.target }} --${{ env.TAG_NAME }}
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-  promote-autobuild:
-    name: Promote PreAutoBuild to AutoBuild
-    runs-on: ubuntu-latest
-    needs:
-      [
-        autobuild-x86-windows-macos-linux,
-        autobuild-arm-linux,
-        autobuild-x86-arm-windows_webview2,
-      ]
-    if: >
-      ${{
-        needs.autobuild-x86-windows-macos-linux.result == 'success' &&
-        needs.autobuild-arm-linux.result == 'success' &&
-        needs.autobuild-x86-arm-windows_webview2.result == 'success'
-      }}
-    steps:
-      - name: Install gh CLI
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y gh jq
-
-      - name: Download PreAutoBuild Release Assets
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          mkdir pre-assets
-          release_id=$(gh api repos/${{ github.repository }}/releases/tags/${{ env.PRE_TAG_NAME }} | jq .id)
-          gh release download ${{ env.PRE_TAG_NAME }} --dir pre-assets
-
-          body=$(gh api repos/${{ github.repository }}/releases/$release_id | jq -r .body)
-          echo "$body" > release.txt
-
-      - name: Publish to autobuild tag
-        uses: softprops/action-gh-release@v2
-        with:
-          tag_name: ${{ env.TAG_NAME }}
-          name: "Clash Verge Rev ${{ env.TAG_CHANNEL }}"
-          body_path: release.txt
-          prerelease: true
-          token: ${{ secrets.GITHUB_TOKEN }}
-          files: pre-assets/*
-
-  notify-telegram:
-    name: Notify Telegram
-    runs-on: ubuntu-latest
-    needs:
-      [
-        update_tag,
-        autobuild-x86-windows-macos-linux,
-        autobuild-arm-linux,
-        autobuild-x86-arm-windows_webview2,
-        promote-autobuild,
-      ]
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Fetch UPDATE logs
-        id: fetch_update_logs
-        run: |
-          if [ -f "UPDATELOG.md" ]; then
-            UPDATE_LOGS=$(awk '/^## v/{if(flag) exit; flag=1} flag' UPDATELOG.md)
-            if [ -n "$UPDATE_LOGS" ]; then
-              echo "Found update logs"
-              echo "UPDATE_LOGS<<EOF" >> $GITHUB_ENV
-              echo "$UPDATE_LOGS" >> $GITHUB_ENV
-              echo "EOF" >> $GITHUB_ENV
-            else
-              echo "No update sections found in UPDATELOG.md"
-            fi
-          else
-            echo "UPDATELOG.md file not found"
-          fi
-        shell: bash
-
-      - name: Install Node
-        uses: actions/setup-node@v4
-        with:
-          node-version: "22"
-
-      - uses: pnpm/action-setup@v4
-        name: Install pnpm
-        with:
-          run_install: false
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Release AutoBuild Version
-        run: pnpm release-version autobuild-latest
-
-      - name: Get Version and Release Info
-        run: |
-          sudo apt-get update
-          sudo apt-get install jq
-          echo "VERSION=$(cat package.json | jq '.version' | tr -d '"')" >> $GITHUB_ENV
-          echo "DOWNLOAD_URL=https://github.com/clash-verge-rev/clash-verge-rev/releases/download/autobuild" >> $GITHUB_ENV
-          echo "BUILDTIME=$(TZ=Asia/Shanghai date)" >> $GITHUB_ENV
-
-      - name: Generate release.txt
-        run: |
-          if [ -z "$UPDATE_LOGS" ]; then
-            echo "No update logs found, using default message"
-            UPDATE_LOGS="More new features are now supported. Check for detailed changelog soon."
-          else
-            echo "Using found update logs"
-          fi
-
-          cat > release.txt << EOF
-          $UPDATE_LOGS
-
-          ## 下载地址
-
-          ### Windows (不再支持Win7)
-          #### 正常版本(推荐)
-          - [64位(常用)](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_x64-setup.exe) | [ARM64(不常用)](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_arm64-setup.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)
-
-          ### macOS
-          - [Apple M芯片](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_aarch64.dmg) | [Intel芯片](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_x64.dmg)
-
-          ### Linux
-          #### DEB包(Debian系) 使用 apt ./路径 安装
-          - [64位](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_amd64.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 }}_amd64.rpm) | [ARM64](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_aarch64.rpm) | [ARMv7](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_armhfp.rpm)
-
-          ### FAQ
-          - [常见问题](https://clash-verge-rev.github.io/faq/windows.html)
-
-          ### 稳定机场VPN推荐
-          - [狗狗加速](https://verge.dginv.click/#/register?code=oaxsAGo6)
-
-          Created at ${{ env.BUILDTIME }}.
-          EOF
-
-      - name: Send Telegram Notification
-        run: node scripts/telegram.mjs
-        env:
-          TELEGRAM_BOT_TOKEN: ${{ secrets.TELEGRAM_BOT_TOKEN }}
-          BUILD_TYPE: autobuild
-          VERSION: ${{ env.VERSION }}
-          DOWNLOAD_URL: ${{ env.DOWNLOAD_URL }}

.github/workflows/check-commit-needs-build.yml

@@ -1,159 +0,0 @@
-name: Check Commit Needs Build
-
-on:
-  workflow_dispatch:
-    inputs:
-      tag_name:
-        description: "Release tag name to check against (default: autobuild)"
-        required: false
-        default: "autobuild"
-        type: string
-      force_build:
-        description: "Force build regardless of checks"
-        required: false
-        default: false
-        type: boolean
-  workflow_call:
-    inputs:
-      tag_name:
-        description: "Release tag name to check against (default: autobuild)"
-        required: false
-        default: "autobuild"
-        type: string
-      force_build:
-        description: "Force build regardless of checks"
-        required: false
-        default: false
-        type: boolean
-    outputs:
-      should_run:
-        description: "Whether the build should run"
-        value: ${{ jobs.check_commit.outputs.should_run }}
-      last_tauri_commit:
-        description: "The last commit hash with Tauri-related changes"
-        value: ${{ jobs.check_commit.outputs.last_tauri_commit }}
-      autobuild_version:
-        description: "The generated autobuild version string"
-        value: ${{ jobs.check_commit.outputs.autobuild_version }}
-
-permissions:
-  contents: read
-  actions: read
-
-env:
-  TAG_NAME: ${{ inputs.tag_name || 'autobuild' }}
-
-jobs:
-  check_commit:
-    name: Check Commit Needs Build
-    runs-on: ubuntu-latest
-    outputs:
-      should_run: ${{ steps.check.outputs.should_run }}
-      last_tauri_commit: ${{ steps.check.outputs.last_tauri_commit }}
-      autobuild_version: ${{ steps.check.outputs.autobuild_version }}
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 50
-
-      - name: Check if version changed or src changed
-        id: check
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          # Force build if requested
-          if [ "${{ inputs.force_build }}" == "true" ]; then
-            echo "🚀 Force build requested"
-            echo "should_run=true" >> $GITHUB_OUTPUT
-            exit 0
-          fi
-
-          CURRENT_VERSION=$(cat package.json | jq -r '.version')
-          echo "📦 Current version: $CURRENT_VERSION"
-
-          git checkout HEAD~1 package.json
-          PREVIOUS_VERSION=$(cat package.json | jq -r '.version')
-          echo "📦 Previous version: $PREVIOUS_VERSION"
-
-          git checkout HEAD package.json
-
-          if [ "$CURRENT_VERSION" != "$PREVIOUS_VERSION" ]; then
-            echo "✅ Version changed from $PREVIOUS_VERSION to $CURRENT_VERSION"
-            echo "should_run=true" >> $GITHUB_OUTPUT
-            exit 0
-          fi
-
-          # Use get_latest_tauri_commit.bash to find the latest Tauri-related commit
-          echo "🔍 Finding last commit with Tauri-related changes using script..."
-
-          # Make script executable
-          chmod +x scripts-workflow/get_latest_tauri_commit.bash
-
-          # Get the latest Tauri-related commit hash (full hash)
-          LAST_TAURI_COMMIT_FULL=$(./scripts-workflow/get_latest_tauri_commit.bash)
-          if [[ $? -ne 0 ]] || [[ -z "$LAST_TAURI_COMMIT_FULL" ]]; then
-            echo "❌ Failed to get Tauri-related commit, using current commit"
-            LAST_TAURI_COMMIT_FULL=$(git rev-parse HEAD)
-          fi
-
-          # Get short hash for display and version tagging
-          LAST_TAURI_COMMIT=$(git rev-parse --short "$LAST_TAURI_COMMIT_FULL")
-
-          echo "📝 Last Tauri-related commit: $LAST_TAURI_COMMIT"
-
-          # Generate autobuild version using autobuild-latest format
-          CURRENT_BASE_VERSION=$(echo "$CURRENT_VERSION" | sed -E 's/-(alpha|beta|rc)(\.[0-9]+)?//g' | sed -E 's/\+[a-zA-Z0-9.-]+//g')
-          MONTH=$(TZ=Asia/Shanghai date +%m)
-          DAY=$(TZ=Asia/Shanghai date +%d)
-          AUTOBUILD_VERSION="${CURRENT_BASE_VERSION}+autobuild.${MONTH}${DAY}.${LAST_TAURI_COMMIT}"
-
-          echo "🏷️  Autobuild version: $AUTOBUILD_VERSION"
-          echo "📝 Last Tauri commit: $LAST_TAURI_COMMIT"
-
-          # Set outputs for other jobs to use
-          echo "last_tauri_commit=$LAST_TAURI_COMMIT" >> $GITHUB_OUTPUT
-          echo "autobuild_version=$AUTOBUILD_VERSION" >> $GITHUB_OUTPUT
-
-          # Check if autobuild release exists
-          echo "🔍 Checking autobuild release and latest.json..."
-          AUTOBUILD_RELEASE_EXISTS=$(gh release view "${{ env.TAG_NAME }}" --json id -q '.id' 2>/dev/null || echo "")
-
-          if [ -z "$AUTOBUILD_RELEASE_EXISTS" ]; then
-            echo "✅ No autobuild release exists, build needed"
-            echo "should_run=true" >> $GITHUB_OUTPUT
-          else
-            # Check if latest.json exists in the release
-            LATEST_JSON_EXISTS=$(gh release view "${{ env.TAG_NAME }}" --json assets -q '.assets[] | select(.name == "latest.json") | .name' 2>/dev/null || echo "")
-            
-            if [ -z "$LATEST_JSON_EXISTS" ]; then
-              echo "✅ No latest.json found in autobuild release, build needed"
-              echo "should_run=true" >> $GITHUB_OUTPUT
-            else
-              # Download and parse latest.json to check version and commit hash
-              echo "📥 Downloading latest.json to check version..."
-              LATEST_JSON_URL="https://github.com/clash-verge-rev/clash-verge-rev/releases/download/autobuild/latest.json"
-              
-              LATEST_JSON_CONTENT=$(curl -sL "$LATEST_JSON_URL" 2>/dev/null || echo "")
-              
-              if [ -n "$LATEST_JSON_CONTENT" ]; then
-                LATEST_VERSION=$(echo "$LATEST_JSON_CONTENT" | jq -r '.version' 2>/dev/null || echo "")
-                echo "📦 Latest autobuild version: $LATEST_VERSION"
-                
-                # Extract commit hash from version string (format: X.Y.Z+autobuild.MMDD.commit)
-                LATEST_COMMIT=$(echo "$LATEST_VERSION" | sed -n 's/.*+autobuild\.[0-9]\{4\}\.\([a-f0-9]*\)$/\1/p' || echo "")
-                echo "📝 Latest autobuild commit: $LATEST_COMMIT"
-                
-                if [ "$LAST_TAURI_COMMIT" != "$LATEST_COMMIT" ]; then
-                  echo "✅ Tauri commit hash mismatch ($LAST_TAURI_COMMIT != $LATEST_COMMIT), build needed"
-                  echo "should_run=true" >> $GITHUB_OUTPUT
-                else
-                  echo "❌ Same Tauri commit hash ($LAST_TAURI_COMMIT), no build needed"
-                  echo "should_run=false" >> $GITHUB_OUTPUT
-                fi
-              else
-                echo "⚠️  Failed to download or parse latest.json, build needed"
-                echo "should_run=true" >> $GITHUB_OUTPUT
-              fi
-            fi
-          fi

.github/workflows/clean-old-assets.yml

@@ -1,220 +0,0 @@
-name: Clean Old Assets
-
-on:
-  workflow_dispatch:
-    inputs:
-      tag_name:
-        description: "Release tag name to clean (default: autobuild)"
-        required: false
-        default: "autobuild"
-        type: string
-      dry_run:
-        description: "Dry run mode (only show what would be deleted)"
-        required: false
-        default: false
-        type: boolean
-  workflow_call:
-    inputs:
-      tag_name:
-        description: "Release tag name to clean (default: autobuild)"
-        required: false
-        default: "autobuild"
-        type: string
-      dry_run:
-        description: "Dry run mode (only show what would be deleted)"
-        required: false
-        default: false
-        type: boolean
-
-permissions: write-all
-
-env:
-  TAG_NAME: ${{ inputs.tag_name || 'autobuild' }}
-  TAG_CHANNEL: AutoBuild
-
-jobs:
-  check_current_version:
-    name: Check Current Version and Commit
-    runs-on: ubuntu-latest
-    outputs:
-      current_version: ${{ steps.check.outputs.current_version }}
-      last_tauri_commit: ${{ steps.check.outputs.last_tauri_commit }}
-      autobuild_version: ${{ steps.check.outputs.autobuild_version }}
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 50
-
-      - name: Get current version and find last Tauri commit
-        id: check
-        run: |
-          CURRENT_VERSION=$(cat package.json | jq -r '.version')
-          echo "📦 Current version: $CURRENT_VERSION"
-
-          # Find the last commit that changed Tauri-related files
-          echo "🔍 Finding last commit with Tauri-related changes..."
-
-          # Define patterns for Tauri-related files
-          TAURI_PATTERNS="src/ src-tauri/src src-tauri/Cargo.toml src-tauri/Cargo.lock src-tauri/tauri.*.conf.json src-tauri/build.rs src-tauri/capabilities"
-
-          # Get the last commit that changed any of these patterns (excluding build artifacts)
-          LAST_TAURI_COMMIT=""
-          for commit in $(git rev-list HEAD --max-count=50); do
-            # Check if this commit changed any Tauri-related files
-            CHANGED_FILES=$(git show --name-only --pretty=format: $commit | tr '\n' ' ')
-            HAS_TAURI_CHANGES=false
-            
-            # Check each pattern
-            if echo "$CHANGED_FILES" | grep -q "src/" && echo "$CHANGED_FILES" | grep -qvE "src/(dist|build|node_modules|\.next|\.cache)"; then
-              HAS_TAURI_CHANGES=true
-            elif echo "$CHANGED_FILES" | grep -qE "src-tauri/(src|Cargo\.(toml|lock)|tauri\..*\.conf\.json|build\.rs|capabilities)"; then
-              HAS_TAURI_CHANGES=true
-            fi
-            
-            if [ "$HAS_TAURI_CHANGES" = true ]; then
-              LAST_TAURI_COMMIT=$(git rev-parse --short $commit)
-              break
-            fi
-          done
-
-          if [ -z "$LAST_TAURI_COMMIT" ]; then
-            echo "⚠️  No Tauri-related changes found in recent commits, using current commit"
-            LAST_TAURI_COMMIT=$(git rev-parse --short HEAD)
-          fi
-
-          echo "📝 Last Tauri-related commit: $LAST_TAURI_COMMIT"
-          echo "📝 Current commit: $(git rev-parse --short HEAD)"
-
-          # Generate autobuild version for consistency
-          CURRENT_BASE_VERSION=$(echo "$CURRENT_VERSION" | sed -E 's/-(alpha|beta|rc)(\.[0-9]+)?//g' | sed -E 's/\+[a-zA-Z0-9.-]+//g')
-          MONTH=$(TZ=Asia/Shanghai date +%m)
-          DAY=$(TZ=Asia/Shanghai date +%d)
-          AUTOBUILD_VERSION="${CURRENT_BASE_VERSION}+autobuild.${MONTH}${DAY}.${LAST_TAURI_COMMIT}"
-
-          echo "🏷️  Current autobuild version: $AUTOBUILD_VERSION"
-
-          # Set outputs for other jobs to use
-          echo "current_version=$CURRENT_VERSION" >> $GITHUB_OUTPUT
-          echo "last_tauri_commit=$LAST_TAURI_COMMIT" >> $GITHUB_OUTPUT
-          echo "autobuild_version=$AUTOBUILD_VERSION" >> $GITHUB_OUTPUT
-
-  clean_old_assets:
-    name: Clean Old Release Assets
-    runs-on: ubuntu-latest
-    needs: check_current_version
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Clean old assets from release
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          TAG_NAME: ${{ env.TAG_NAME }}
-          DRY_RUN: ${{ inputs.dry_run }}
-        run: |
-          # Use values from check_current_version job
-          CURRENT_AUTOBUILD_VERSION="${{ needs.check_current_version.outputs.autobuild_version }}"
-          LAST_TAURI_COMMIT="${{ needs.check_current_version.outputs.last_tauri_commit }}"
-          CURRENT_VERSION="${{ needs.check_current_version.outputs.current_version }}"
-
-          echo "📦 Current version: $CURRENT_VERSION"
-          echo "📦 Current autobuild version: $CURRENT_AUTOBUILD_VERSION"
-          echo "📝 Last Tauri commit: $LAST_TAURI_COMMIT"
-          echo "🏷️  Target tag: $TAG_NAME"
-          echo "🔍 Dry run mode: $DRY_RUN"
-
-          # Check if release exists
-          RELEASE_EXISTS=$(gh release view "$TAG_NAME" --json id -q '.id' 2>/dev/null || echo "")
-
-          if [ -z "$RELEASE_EXISTS" ]; then
-            echo "❌ Release '$TAG_NAME' not found"
-            exit 1
-          fi
-
-          echo "✅ Found release '$TAG_NAME'"
-
-          # Get all assets
-          echo "📋 Getting list of all assets..."
-          assets=$(gh release view "$TAG_NAME" --json assets -q '.assets[].name' || true)
-
-          if [ -z "$assets" ]; then
-            echo "ℹ️  No assets found in release '$TAG_NAME'"
-            exit 0
-          fi
-
-          echo "📋 Found assets:"
-          echo "$assets" | sed 's/^/  - /'
-
-          # Count assets to keep and delete
-          ASSETS_TO_KEEP=""
-          ASSETS_TO_DELETE=""
-
-          for asset in $assets; do
-            # Keep assets that match current autobuild version or are non-versioned files (like latest.json)
-            if [[ "$asset" == *"$CURRENT_AUTOBUILD_VERSION"* ]] || [[ "$asset" == "latest.json" ]]; then
-              ASSETS_TO_KEEP="$ASSETS_TO_KEEP$asset\n"
-            else
-              ASSETS_TO_DELETE="$ASSETS_TO_DELETE$asset\n"
-            fi
-          done
-
-          echo ""
-          echo "🔒 Assets to keep (current version: $CURRENT_AUTOBUILD_VERSION):"
-          if [ -n "$ASSETS_TO_KEEP" ]; then
-            echo -e "$ASSETS_TO_KEEP" | grep -v '^$' | sed 's/^/  - /'
-          else
-            echo "  - None"
-          fi
-
-          echo ""
-          echo "🗑️  Assets to delete:"
-          if [ -n "$ASSETS_TO_DELETE" ]; then
-            echo -e "$ASSETS_TO_DELETE" | grep -v '^$' | sed 's/^/  - /'
-          else
-            echo "  - None"
-            echo "ℹ️  No old assets to clean"
-            exit 0
-          fi
-
-          if [ "$DRY_RUN" = "true" ]; then
-            echo ""
-            echo "🔍 DRY RUN MODE: No assets will actually be deleted"
-            echo "   To actually delete these assets, run this workflow again with dry_run=false"
-          else
-            echo ""
-            echo "🗑️  Deleting old assets..."
-            
-            DELETED_COUNT=0
-            FAILED_COUNT=0
-            
-            for asset in $assets; do
-              # Skip assets that should be kept
-              if [[ "$asset" == *"$CURRENT_AUTOBUILD_VERSION"* ]] || [[ "$asset" == "latest.json" ]]; then
-                continue
-              fi
-              
-              echo "  Deleting: $asset"
-              if gh release delete-asset "$TAG_NAME" "$asset" -y 2>/dev/null; then
-                DELETED_COUNT=$((DELETED_COUNT + 1))
-              else
-                echo "    ⚠️  Failed to delete $asset"
-                FAILED_COUNT=$((FAILED_COUNT + 1))
-              fi
-            done
-
-            echo ""
-            echo "📊 Cleanup summary:"
-            echo "  - Deleted: $DELETED_COUNT assets"
-            if [ $FAILED_COUNT -gt 0 ]; then
-              echo "  - Failed: $FAILED_COUNT assets"
-            fi
-            echo "  - Kept: $(echo -e "$ASSETS_TO_KEEP" | grep -v '^$' | wc -l) assets"
-            
-            if [ $FAILED_COUNT -gt 0 ]; then
-              echo "⚠️  Some assets failed to delete. Please check the logs above."
-              exit 1
-            else
-              echo "✅ Cleanup completed successfully!"
-            fi
-          fi

.github/workflows/cross_check.yaml

@@ -1,64 +0,0 @@
-name: Cross Platform Cargo Check
-
-on:
-  workflow_dispatch:
-#   pull_request:
-#   push:
-# branches: [main, dev]
-
-permissions:
-  contents: read
-
-jobs:
-  cargo-check:
-    # Treat all Rust compiler warnings as errors
-    env:
-      RUSTFLAGS: "-D warnings"
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - os: macos-latest
-            target: aarch64-apple-darwin
-          - os: windows-latest
-            target: x86_64-pc-windows-msvc
-          - os: ubuntu-latest
-            target: x86_64-unknown-linux-gnu
-    runs-on: ${{ matrix.os }}
-    steps:
-      - name: Checkout Repository
-        uses: actions/checkout@v4
-
-      - name: Install Rust Stable
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          targets: ${{ matrix.target }}
-
-      - name: Add Rust Target
-        run: rustup target add ${{ matrix.target }}
-
-      - name: Install Node
-        uses: actions/setup-node@v4
-        with:
-          node-version: "20"
-
-      - uses: pnpm/action-setup@v4
-        name: Install pnpm
-        with:
-          run_install: false
-
-      - name: Pnpm install and check
-        run: |
-          pnpm i
-          pnpm run prebuild ${{ matrix.target }}
-
-      - name: Rust Cache
-        uses: Swatinem/rust-cache@v2
-        with:
-          workspaces: src-tauri
-          save-if: false
-
-      - name: Cargo Check (deny warnings)
-        working-directory: src-tauri
-        run: |
-          cargo check --target ${{ matrix.target }} --workspace --all-features

.github/workflows/dev.yml

@@ -2,30 +2,12 @@ name: Development Test
 
 on:
   workflow_dispatch:
-    inputs:
-      run_windows:
-        description: "运行 Windows"
-        required: false
-        type: boolean
-        default: true
-      run_macos_aarch64:
-        description: "运行 macOS aarch64"
-        required: false
-        type: boolean
-        default: true
-      run_windows_arm64:
-        description: "运行 Windows ARM64"
-        required: false
-        type: boolean
-        default: true
-
 permissions: write-all
 env:
-  TAG_NAME: deploytest
-  TAG_CHANNEL: DeployTest
   CARGO_INCREMENTAL: 0
   RUST_BACKTRACE: short
 concurrency:
+  # only allow per workflow per commit (and not pr) to run at a time
   group: "${{ github.workflow }} - ${{ github.head_ref || github.ref }}"
   cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
 
@@ -38,71 +20,47 @@ jobs:
           - os: windows-latest
             target: x86_64-pc-windows-msvc
             bundle: nsis
-            id: windows
-            input: run_windows
           - os: macos-latest
             target: aarch64-apple-darwin
             bundle: dmg
-            id: macos-aarch64
-            input: run_macos_aarch64
-          - os: windows-latest
-            target: aarch64-pc-windows-msvc
-            bundle: nsis
-            id: windows-arm64
-            input: run_windows_arm64
+          - os: macos-latest
+            target: x86_64-apple-darwin
+            bundle: dmg
 
     runs-on: ${{ matrix.os }}
     steps:
-      - name: Skip job if not selected
-        if: github.event.inputs[matrix.input] != 'true'
-        run: echo "Job ${{ matrix.id }} skipped as requested"
-
       - name: Checkout Repository
-        if: github.event.inputs[matrix.input] == 'true'
         uses: actions/checkout@v4
 
       - name: Install Rust Stable
-        if: github.event.inputs[matrix.input] == 'true'
         uses: dtolnay/rust-toolchain@stable
 
       - name: Add Rust Target
-        if: github.event.inputs[matrix.input] == 'true'
         run: rustup target add ${{ matrix.target }}
 
       - name: Rust Cache
-        if: github.event.inputs[matrix.input] == 'true'
         uses: Swatinem/rust-cache@v2
         with:
           workspaces: src-tauri
-          save-if: false
           cache-all-crates: true
-          shared-key: autobuild-shared
-
-      - uses: pnpm/action-setup@v4
-        name: Install pnpm
-        if: github.event.inputs[matrix.input] == 'true'
-        with:
-          run_install: false
+          cache-on-failure: true
 
       - name: Install Node
-        if: github.event.inputs[matrix.input] == 'true'
         uses: actions/setup-node@v4
         with:
           node-version: "20"
-          cache: "pnpm"
+
+      - uses: pnpm/action-setup@v4
+        name: Install pnpm
+        with:
+          run_install: false
 
       - name: Pnpm install and check
-        if: github.event.inputs[matrix.input] == 'true'
         run: |
           pnpm i
-          pnpm run prebuild ${{ matrix.target }}
-
-      - name: Release ${{ env.TAG_CHANNEL }} Version
-        if: github.event.inputs[matrix.input] == 'true'
-        run: pnpm release-version ${{ env.TAG_NAME }}
+          pnpm check ${{ matrix.target }}
 
       - name: Tauri build
-        if: github.event.inputs[matrix.input] == 'true'
         uses: tauri-apps/tauri-action@v0
         env:
           NODE_OPTIONS: "--max_old_space_size=4096"
@@ -120,7 +78,7 @@ jobs:
           args: --target ${{ matrix.target }} -b ${{ matrix.bundle }}
 
       - name: Upload Artifacts
-        if: matrix.os == 'macos-latest' && github.event.inputs[matrix.input] == 'true'
+        if: matrix.os == 'macos-latest'
         uses: actions/upload-artifact@v4
         with:
           name: ${{ matrix.target }}
@@ -128,7 +86,7 @@ jobs:
           if-no-files-found: error
 
       - name: Upload Artifacts
-        if: matrix.os == 'windows-latest' && github.event.inputs[matrix.input] == 'true'
+        if: matrix.os == 'windows-latest'
         uses: actions/upload-artifact@v4
         with:
           name: ${{ matrix.target }}

.github/workflows/fmt.yml

@@ -1,50 +0,0 @@
-# Copyright 2019-2024 Tauri Programme within The Commons Conservancy
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-License-Identifier: MIT
-
-name: Check Formatting
-
-on:
-  pull_request:
-
-jobs:
-  rustfmt:
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: install Rust stable and rustfmt
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          components: rustfmt
-
-      - name: run cargo fmt
-        run: cargo fmt --manifest-path ./src-tauri/Cargo.toml --all -- --check
-
-  prettier:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: "lts/*"
-      - run: corepack enable
-      - run: pnpm install --frozen-lockfile
-      - run: pnpm format:check
-
-  # taplo:
-  #   name: taplo (.toml files)
-  #   runs-on: ubuntu-latest
-  #   steps:
-  #     - uses: actions/checkout@v4
-
-  #     - name: install Rust stable
-  #       uses: dtolnay/rust-toolchain@stable
-
-  #     - name: install taplo-cli
-  #       uses: taiki-e/install-action@v2
-  #       with:
-  #         tool: taplo-cli
-
-  #     - run: taplo fmt --check --diff

.github/workflows/lint-clippy.yml

@@ -1,70 +0,0 @@
-name: Clippy Lint
-
-on:
-  pull_request:
-  workflow_dispatch:
-
-jobs:
-  clippy:
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - os: windows-latest
-            target: x86_64-pc-windows-msvc
-          - os: macos-latest
-            target: aarch64-apple-darwin
-          - os: ubuntu-22.04
-            target: x86_64-unknown-linux-gnu
-
-    runs-on: ${{ matrix.os }}
-    steps:
-      - name: Checkout Repository
-        uses: actions/checkout@v4
-
-      - name: Install Rust Stable
-        uses: dtolnay/rust-toolchain@stable
-
-      - name: Add Rust Target
-        run: rustup target add ${{ matrix.target }}
-
-      - name: Rust Cache
-        uses: Swatinem/rust-cache@v2
-        with:
-          workspaces: src-tauri
-          save-if: false
-          cache-all-crates: false
-          shared-key: autobuild-shared
-
-      - name: Install dependencies (ubuntu only)
-        if: matrix.os == 'ubuntu-22.04'
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libxslt1.1 libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librsvg2-dev patchelf
-
-      - name: Install pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          run_install: false
-
-      - name: Install Node
-        uses: actions/setup-node@v4
-        with:
-          node-version: "22"
-          cache: "pnpm"
-
-      - name: Pnpm install and check
-        run: |
-          pnpm i
-          pnpm run prebuild ${{ matrix.target }}
-
-      # This workflow runs linting using cargo clippy.
-      # Note: If the web build step is skipped,
-      # cargo clippy will fail to run due to missing web dist in the Tauri environment.
-      - name: Build Web Assets
-        run: pnpm run web:build
-        env:
-          NODE_OPTIONS: "--max_old_space_size=4096"
-
-      - name: Run Clippy
-        run: cargo clippy --manifest-path src-tauri/Cargo.toml --all-targets --all-features -- -D warnings

.github/workflows/release.yml

@@ -5,6 +5,9 @@ on:
   # ! 不再使用 workflow_dispatch 触发。
   # workflow_dispatch:
   push:
+    # ? 应当限制在 main 分支上触发发布。
+    # branches:
+    #   - main
     tags:
       - "v*.*.*"
 permissions: write-all
@@ -17,138 +20,8 @@ concurrency:
   cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
 
 jobs:
-  check_tag_version:
-    name: Check Release Tag and package.json Version Consistency
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Check if tag is from main branch
-        run: |
-          TAG_REF="${GITHUB_REF##*/}"
-          echo "Checking if tag $TAG_REF is from main branch..."
-
-          TAG_COMMIT=$(git rev-list -n 1 $TAG_REF)
-          MAIN_COMMITS=$(git rev-list origin/main)
-
-          if echo "$MAIN_COMMITS" | grep -q "$TAG_COMMIT"; then
-            echo "✅ Tag $TAG_REF is from main branch"
-          else
-            echo "❌ Tag $TAG_REF is not from main branch"
-            echo "This release workflow only accepts tags from main branch."
-            exit 1
-          fi
-
-      - name: Check tag and package.json version
-        run: |
-          TAG_REF="${GITHUB_REF_NAME:-${GITHUB_REF##*/}}"
-          echo "Current tag: $TAG_REF"
-
-          PKG_VERSION=$(jq -r .version package.json)
-          echo "package.json version: $PKG_VERSION"
-
-          EXPECTED_TAG="v$PKG_VERSION"
-
-          if [[ "$TAG_REF" != "$EXPECTED_TAG" ]]; then
-            echo "❌ Version mismatch:"
-            echo "   Git tag       : $TAG_REF"
-            echo "   package.json  : $EXPECTED_TAG"
-            exit 1
-          fi
-
-          echo "✅ Tag and package.json version are consistent."
-
-  update_tag:
-    name: Update tag
-    runs-on: ubuntu-latest
-    needs: [release, release-for-linux-arm, release-for-fixed-webview2]
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Fetch UPDATE logs
-        id: fetch_update_logs
-        run: |
-          if [ -f "UPDATELOG.md" ]; then
-            UPDATE_LOGS=$(awk '/^## v/{if(flag) exit; flag=1} flag' UPDATELOG.md)
-            if [ -n "$UPDATE_LOGS" ]; then
-              echo "Found update logs"
-              echo "UPDATE_LOGS<<EOF" >> $GITHUB_ENV
-              echo "$UPDATE_LOGS" >> $GITHUB_ENV
-              echo "EOF" >> $GITHUB_ENV
-            else
-              echo "No update sections found in UPDATELOG.md"
-            fi
-          else
-            echo "UPDATELOG.md file not found"
-          fi
-        shell: bash
-
-      - name: Set Env
-        run: |
-          echo "BUILDTIME=$(TZ=Asia/Shanghai date)" >> $GITHUB_ENV
-          TAG_REF="${GITHUB_REF##*/}"
-          echo "TAG_NAME=$TAG_REF" >> $GITHUB_ENV
-          VERSION=$(echo "$TAG_REF" | sed 's/^v//')
-          echo "VERSION=$VERSION" >> $GITHUB_ENV
-          echo "DOWNLOAD_URL=https://github.com/clash-verge-rev/clash-verge-rev/releases/download/$TAG_REF" >> $GITHUB_ENV
-        shell: bash
-
-      - run: |
-          if [ -z "$UPDATE_LOGS" ]; then
-            echo "No update logs found, using default message"
-            UPDATE_LOGS="More new features are now supported. Check for detailed changelog soon."
-          else
-            echo "Using found update logs"
-          fi
-
-          cat > release.txt << EOF
-          $UPDATE_LOGS
-
-          ## 下载地址
-
-          ### Windows (不再支持Win7)
-          #### 正常版本(推荐)
-          - [64位(常用)](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_x64-setup.exe) | [ARM64(不常用)](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_arm64-setup.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)
-
-          ### macOS
-          - [Apple M芯片](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_aarch64.dmg) | [Intel芯片](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_x64.dmg)
-
-          ### Linux
-          #### DEB包(Debian系) 使用 apt ./路径 安装
-          - [64位](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_amd64.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.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)
-
-          ### 稳定机场VPN推荐
-          - [狗狗加速](https://verge.dginv.click/#/register?code=oaxsAGo6)
-          Created at ${{ env.BUILDTIME }}.
-          EOF
-
-      - name: Upload Release
-        uses: softprops/action-gh-release@v2
-        with:
-          tag_name: ${{ env.TAG_NAME }}
-          name: "Clash Verge Rev ${{ env.TAG_NAME }}"
-          body_path: release.txt
-          draft: false
-          prerelease: false
-          token: ${{ secrets.GITHUB_TOKEN }}
-          # generate_release_notes: true
-
   release:
     name: Release Build
-    needs: [check_tag_version]
     strategy:
       fail-fast: false
       matrix:
@@ -179,7 +52,8 @@ jobs:
         uses: Swatinem/rust-cache@v2
         with:
           workspaces: src-tauri
-          save-if: false
+          cache-all-crates: true
+          cache-on-failure: true
 
       - name: Install dependencies (ubuntu only)
         if: matrix.os == 'ubuntu-22.04'
@@ -187,15 +61,6 @@ jobs:
           sudo apt-get update
           sudo apt-get install -y libxslt1.1 libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librsvg2-dev patchelf
 
-      - name: Install x86 OpenSSL (macOS only)
-        if: matrix.target == 'x86_64-apple-darwin'
-        run: |
-          arch -x86_64 brew install openssl@3
-          echo "OPENSSL_DIR=$(brew --prefix openssl@3)" >> $GITHUB_ENV
-          echo "OPENSSL_INCLUDE_DIR=$(brew --prefix openssl@3)/include" >> $GITHUB_ENV
-          echo "OPENSSL_LIB_DIR=$(brew --prefix openssl@3)/lib" >> $GITHUB_ENV
-          echo "PKG_CONFIG_PATH=$(brew --prefix openssl@3)/lib/pkgconfig" >> $GITHUB_ENV
-
       - name: Install Node
         uses: actions/setup-node@v4
         with:
@@ -209,7 +74,7 @@ jobs:
       - name: Pnpm install and check
         run: |
           pnpm i
-          pnpm run prebuild ${{ matrix.target }}
+          pnpm check ${{ matrix.target }}
 
       - name: Tauri build
         uses: tauri-apps/tauri-action@v0
@@ -225,18 +90,14 @@ jobs:
           APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
           APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
         with:
-          tagName: ${{ github.ref_name }}
-          releaseName: "Clash Verge Rev ${{ github.ref_name }}"
-          releaseBody: "Draft release, will be updated later."
-          releaseDraft: true
-          prerelease: false
+          tagName: v__VERSION__
+          releaseName: "Clash Verge Rev v__VERSION__"
+          releaseBody: "More new features are now supported."
           tauriScript: pnpm
           args: --target ${{ matrix.target }}
-          includeUpdaterJson: true
 
   release-for-linux-arm:
     name: Release Build for Linux ARM
-    needs: [check_tag_version]
     strategy:
       fail-fast: false
       matrix:
@@ -262,7 +123,7 @@ jobs:
         uses: Swatinem/rust-cache@v2
         with:
           workspaces: src-tauri
-          save-if: false
+          cache-all-crates: true
 
       - name: Install Node
         uses: actions/setup-node@v4
@@ -277,7 +138,7 @@ jobs:
       - name: Pnpm install and check
         run: |
           pnpm i
-          pnpm run prebuild ${{ matrix.target }}
+          pnpm check ${{ matrix.target }}
 
       - name: "Setup for linux"
         run: |-
@@ -351,7 +212,7 @@ jobs:
         with:
           tag_name: v${{env.VERSION}}
           name: "Clash Verge Rev v${{env.VERSION}}"
-          body: "See release notes for detailed changelog."
+          body: "More new features are now supported."
           token: ${{ secrets.GITHUB_TOKEN }}
           files: |
             src-tauri/target/${{ matrix.target }}/release/bundle/deb/*.deb
@@ -359,7 +220,6 @@ jobs:
 
   release-for-fixed-webview2:
     name: Release Build for Fixed WebView2
-    needs: [check_tag_version]
     strategy:
       fail-fast: false
       matrix:
@@ -382,7 +242,8 @@ jobs:
         uses: Swatinem/rust-cache@v2
         with:
           workspaces: src-tauri
-          save-if: false
+          cache-all-crates: true
+          cache-on-failure: true
 
       - name: Install Node
         uses: actions/setup-node@v4
@@ -397,7 +258,7 @@ jobs:
       - name: Pnpm install and check
         run: |
           pnpm i
-          pnpm run prebuild ${{ matrix.target }}
+          pnpm check ${{ matrix.target }}
 
       - name: Download WebView2 Runtime
         run: |
@@ -443,7 +304,7 @@ jobs:
         with:
           tag_name: v${{steps.build.outputs.appVersion}}
           name: "Clash Verge Rev v${{steps.build.outputs.appVersion}}"
-          body: "See release notes for detailed changelog."
+          body: "More new features are now supported."
           token: ${{ secrets.GITHUB_TOKEN }}
           files: src-tauri/target/${{ matrix.target }}/release/bundle/nsis/*setup*
 
@@ -455,7 +316,7 @@ jobs:
   release-update:
     name: Release Update
     runs-on: ubuntu-latest
-    needs: [update_tag]
+    needs: [release, release-for-linux-arm]
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
@@ -480,7 +341,7 @@ jobs:
 
   release-update-for-fixed-webview2:
     runs-on: ubuntu-latest
-    needs: [update_tag]
+    needs: [release-for-fixed-webview2]
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
@@ -506,7 +367,7 @@ jobs:
   submit-to-winget:
     name: Submit to Winget
     runs-on: ubuntu-latest
-    needs: [update_tag, release-update]
+    needs: [release-update]
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
@@ -525,103 +386,3 @@ jobs:
           release-tag: v${{env.VERSION}}
           installers-regex: '_(arm64|x64|x86)-setup\.exe$'
           token: ${{ secrets.WINGET_TOKEN  }}
-
-  notify-telegram:
-    name: Notify Telegram
-    runs-on: ubuntu-latest
-    needs:
-      [
-        update_tag,
-        release-update,
-        release-update-for-fixed-webview2,
-        submit-to-winget,
-      ]
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Fetch UPDATE logs
-        id: fetch_update_logs
-        run: |
-          if [ -f "UPDATELOG.md" ]; then
-            UPDATE_LOGS=$(awk '/^## v/{if(flag) exit; flag=1} flag' UPDATELOG.md)
-            if [ -n "$UPDATE_LOGS" ]; then
-              echo "Found update logs"
-              echo "UPDATE_LOGS<<EOF" >> $GITHUB_ENV
-              echo "$UPDATE_LOGS" >> $GITHUB_ENV
-              echo "EOF" >> $GITHUB_ENV
-            else
-              echo "No update sections found in UPDATELOG.md"
-            fi
-          else
-            echo "UPDATELOG.md file not found"
-          fi
-        shell: bash
-
-      - name: Install Node
-        uses: actions/setup-node@v4
-        with:
-          node-version: "22"
-
-      - uses: pnpm/action-setup@v4
-        name: Install pnpm
-        with:
-          run_install: false
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Get Version and Release Info
-        run: |
-          sudo apt-get update
-          sudo apt-get install jq
-          echo "VERSION=$(cat package.json | jq '.version' | tr -d '"')" >> $GITHUB_ENV
-          echo "DOWNLOAD_URL=https://github.com/clash-verge-rev/clash-verge-rev/releases/download/v$(cat package.json | jq '.version' | tr -d '"')" >> $GITHUB_ENV
-          echo "BUILDTIME=$(TZ=Asia/Shanghai date)" >> $GITHUB_ENV
-
-      - name: Generate release.txt
-        run: |
-          if [ -z "$UPDATE_LOGS" ]; then
-            echo "No update logs found, using default message"
-            UPDATE_LOGS="More new features are now supported. Check for detailed changelog soon."
-          else
-            echo "Using found update logs"
-          fi
-
-          cat > release.txt << EOF
-          $UPDATE_LOGS
-
-          ## 下载地址
-
-          ### Windows (不再支持Win7)
-          #### 正常版本(推荐)
-          - [64位(常用)](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_x64-setup.exe) | [ARM64(不常用)](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_arm64-setup.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)
-
-          ### macOS
-          - [Apple M芯片](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_aarch64.dmg) | [Intel芯片](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_x64.dmg)
-
-          ### Linux
-          #### DEB包(Debian系) 使用 apt ./路径 安装
-          - [64位](${{ env.DOWNLOAD_URL }}/Clash.Verge_${{ env.VERSION }}_amd64.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.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)
-
-          ### 稳定机场VPN推荐
-          - [狗狗加速](https://verge.dginv.click/#/register?code=oaxsAGo6)
-          Created at ${{ env.BUILDTIME }}.
-          EOF
-
-      - name: Send Telegram Notification
-        run: node scripts/telegram.mjs
-        env:
-          TELEGRAM_BOT_TOKEN: ${{ secrets.TELEGRAM_BOT_TOKEN }}
-          BUILD_TYPE: release
-          VERSION: ${{ env.VERSION }}
-          DOWNLOAD_URL: ${{ env.DOWNLOAD_URL }}

.gitignore

@@ -10,4 +10,3 @@ scripts/_env.sh
 .tool-versions
 .idea
 .old
-.eslintcache

.husky/pre-commit

@@ -2,25 +2,17 @@
 
 #pnpm pretty-quick --staged
 
-if git diff --cached --name-only | grep -q '^src/'; then
-    pnpm format:check
-    if [ $? -ne 0 ]; then
-        echo "Code format check failed in src/. Please fix formatting issues."
-        exit 1
-    fi
-fi
+# 运行 clippy fmt
+cd src-tauri
+cargo fmt
 
-if git diff --cached --name-only | grep -q '^src-tauri/'; then
-    cd src-tauri
-    cargo fmt
-    if [ $? -ne 0 ]; then
-        echo "rustfmt failed to format the code. Please fix the issues and try again."
-        exit 1
-    fi
-    cd ..
+if [ $? -ne 0 ]; then
+    echo "rustfmt failed to format the code. Please fix the issues and try again."
+    exit 1
 fi
+cd ..
 
-#git add .
+git add .
 
 # 允许提交
 exit 0

.husky/pre-push

@@ -1,34 +1,13 @@
 #!/bin/bash
 
-# $1: remote name (e.g., origin)
-# $2: remote url (e.g., git@github.com:clash-verge-rev/clash-verge-rev.git)
+# 运行 clippy
+# cargo clippy  --manifest-path ./src-tauri/Cargo.toml --fix
 
-if git diff --cached --name-only | grep -q '^src-tauri/'; then
-    cargo clippy --manifest-path ./src-tauri/Cargo.toml
-    if [ $? -ne 0 ]; then
-        echo "Clippy found issues in src-tauri. Please fix them before pushing."
-        exit 1
-    fi
-fi
-
-
-# Only run format check if the remote exists and is the main repo
-remote_name="$1"
-if git remote get-url "$remote_name" >/dev/null 2>&1; then
-    remote_url=$(git remote get-url "$remote_name")
-    if [[ "$remote_url" =~ github\.com[:/]+clash-verge-rev/clash-verge-rev(\.git)?$ ]]; then
-        echo "[pre-push] Detected push to clash-verge-rev/clash-verge-rev ($remote_url)"
-        echo "[pre-push] Running pnpm format:check..."
-        pnpm format:check
-        if [ $? -ne 0 ]; then
-            echo "❌ Code format check failed. Please fix formatting before pushing."
-            exit 1
-        fi
-    else
-        echo "[pre-push] Not pushing to target repo. Skipping format check."
-    fi
-else
-    echo "[pre-push] Remote $remote_name does not exist. Skipping format check."
-fi
+# 如果 clippy 失败，阻止 push
+# if [ $? -ne 0 ]; then
+#    echo "Clippy found issues in sub_crate. Please fix them before pushing."
+#    exit 1
+# fi
 
+# 允许 push
 exit 0

.prettierignore

@@ -1,8 +0,0 @@
-# README.md
-# UPDATELOG.md
-# CONTRIBUTING.md
-
-pnpm-lock.yaml
-
-src-tauri/target/
-src-tauri/gen/

.prettierrc

@@ -1,16 +0,0 @@
-{
-  "printWidth": 80,
-  "tabWidth": 2,
-  "useTabs": false,
-  "semi": true,
-  "singleQuote": false,
-  "jsxSingleQuote": false,
-  "trailingComma": "all",
-  "bracketSpacing": true,
-  "bracketSameLine": false,
-  "arrowParens": "always",
-  "proseWrap": "preserve",
-  "htmlWhitespaceSensitivity": "css",
-  "endOfLine": "lf",
-  "embeddedLanguageFormatting": "auto"
-}

CONTRIBUTING.md

@@ -8,15 +8,10 @@ Before you start contributing to the project, you need to set up your developmen
 
 ### Prerequisites
 
-1. **Install Rust and Node.js**: Our project requires both Rust and Node.js. Please follow the instructions provided [here](https://tauri.app/start/prerequisites/) to install them on your system.
+1. **Install Rust and Node.js**: Our project requires both Rust and Node.js. Please follow the instructions provided [here](https://tauri.app/v1/guides/getting-started/prerequisites) to install them on your system.
 
 ### Setup for Windows Users
 
-> [!NOTE]
-> **If you are using a Windows ARM device, you additionally need to install [LLVM](https://github.com/llvm/llvm-project/releases) (including clang) and set the environment variable.**
->
-> Because the `ring` crate is compiled based on `clang` under Windows ARM.
-
 If you're a Windows user, you may need to perform some additional steps:
 
 - Make sure to add Rust and Node.js to your system's PATH. This is usually done during the installation process, but you can verify and manually add them if necessary.
@@ -38,15 +33,12 @@ npm install pnpm -g
 ```
 
 ### Install Dependencies
-
 Install node packages
-
 ```shell
 pnpm install
 ```
 
 Install apt packages ONLY for Ubuntu
-
 ```shell
 apt-get install -y libxslt1.1 libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librsvg2-dev patchelf
 ```
@@ -56,14 +48,11 @@ apt-get install -y libxslt1.1 libwebkit2gtk-4.1-dev libayatana-appindicator3-dev
 You have two options for downloading the clash binary:
 
 - Automatically download it via the provided script:
-
   ```shell
-  pnpm run prebuild
-  # Use '--force' or '-f' to update both the Mihomo core version
-  # and the Clash Verge Rev service version to the latest available.
-  pnpm run prebuild --force
+  pnpm run check
+  # Use '--force' to force update to the latest version
+  # pnpm run check --force
   ```
-
 - Manually download it from the [Mihomo release](https://github.com/MetaCubeX/mihomo/releases). After downloading, rename the binary according to the [Tauri configuration](https://tauri.app/v1/api/config#bundleconfig.externalbin).
 
 ### Run the Development Server
@@ -74,8 +63,6 @@ To run the development server, use the following command:
 pnpm dev
 # If an app instance already exists, use a different command
 pnpm dev:diff
-# To using tauri built-in dev tool
-pnpm dev:tauri
 ```
 
 ### Build the Project
@@ -118,25 +105,20 @@ pnpm portable
 
 If you changed the rust code, it's recommanded to execute code style formatting and quailty checks.
 
-1. Code quailty checks
+1. Code style formatting
 
 ```bash
-# For rust backend
-$ clash-verge-rev: pnpm clippy
-# For frontend (not yet).
-```
-
-2. Code style formatting
-
-```bash
-# For rust backend
 $ clash-verge-rev: cd src-tauri
 $ clash-verge-rev/src-tauri: cargo fmt
-# For frontend
-$ clash-verge-rev: pnpm format:check
-$ clash-verge-rev: pnpm format
 ```
 
+2. Code quailty checks
+
+```bash
+$ clash-verge-rev: pnpm clippy
+```
+
+
 Once you have made your changes:
 
 1. Fork the repository.

README.md

@@ -23,13 +23,13 @@ Supports Windows (x64/x86), Linux (x64/arm64) and macOS 10.15+ (intel/apple).
 
 #### 我应当怎样选择发行版
 
-| 版本        | 特征                                     | 链接                                                                                   |
-| :---------- | :--------------------------------------- | :------------------------------------------------------------------------------------- |
-| Stable      | 正式版，高可靠性，适合日常使用。         | [Release](https://github.com/clash-verge-rev/clash-verge-rev/releases)                 |
-| Alpha(废弃) | 测试发布流程。                           | [Alpha](https://github.com/clash-verge-rev/clash-verge-rev/releases/tag/alpha)         |
-| AutoBuild   | 滚动更新版，适合测试反馈，可能存在缺陷。 | [AutoBuild](https://github.com/clash-verge-rev/clash-verge-rev/releases/tag/autobuild) |
+| 版本 | 特征 | 链接 |
+|:-----|:-----|:-----|
+|Stable|正式版，高可靠性，适合日常使用。|[Release](https://github.com/clash-verge-rev/clash-verge-rev/releases) |
+|Alpha|早期测试版，功能未完善，可能存在缺陷。|[Alpha](https://github.com/clash-verge-rev/clash-verge-rev/releases/tag/alpha)|
+|AutoBuild|滚动更新版，持续集成更新，适合开发测试。|[AutoBuild](https://github.com/clash-verge-rev/clash-verge-rev/releases/tag/autobuild)|
 
-#### 安装说明和常见问题，请到 [文档页](https://clash-verge-rev.github.io/) 查看
+#### 安装说明和常见问题，请到 [文档页](https://clash-verge-rev.github.io/) 查看 
 
 ---
 
@@ -49,12 +49,11 @@ Supports Windows (x64/x86), Linux (x64/arm64) and macOS 10.15+ (intel/apple).
 - 解锁流媒体及 ChatGPT
 - 官网：[https://狗狗加速.com](https://verge.dginv.click/#/register?code=oaxsAGo6)
 
-#### 本项目的构建与发布环境由 [YXVM](https://yxvm.com/aff.php?aff=827) 独立服务器全力支持，
 
+#### 本项目的构建与发布环境由 [YXVM](https://yxvm.com/aff.php?aff=827) 独立服务器全力支持，
 感谢提供 独享资源、高性能、高速网络 的强大后端环境。如果你觉得下载够快、使用够爽，那是因为我们用了好服务器！
 
 🧩 YXVM 独立服务器优势：
-
 - 🌎 优质网络，回程优化，下载快到飞起
 - 🔧 物理机独享资源，非VPS可比，性能拉满
 - 🧠 适合跑代理、搭建 WEB 站 CDN 站 、搞 CI/CD 或任何高负载应用
@@ -88,7 +87,7 @@ To run the development server, execute the following commands after all prerequi
 
 ```shell
 pnpm i
-pnpm run prebuild
+pnpm run check
 pnpm dev
 ```
 

UPDATELOG.md

@@ -1,371 +1,143 @@
-## v2.4.3
-
-### 🚀 优化改进
-
-- 重构并简化服务模式启动检测流程，消除重复检测
-- 重构并简化窗口创建流程
-- 重构日志系统，单个日志默认最大 10 MB
-- 优化前端资源占用
-
-### 🐞 修复问题
-
-- 优化服务模式重装逻辑，避免不必要的重复检查
-- 修复轻量模式退出无响应的问题
-- 修复托盘轻量模式支持退出/进入
-- 修复静默启动和自动进入轻量模式时，托盘状态刷新不再依赖窗口创建流程
-- macOS Tun/系统代理 模式下图标大小不统一
-- 托盘节点切换不再显示隐藏组
-- 修复前端 IP 检测无法使用 ipapi, ipsb 提供商
-
-## v2.4.2
-
-### ✨ 新增功能
-
-- 增加托盘节点选择
-
-### 🚀 性能优化
-
-- 优化前端首页加载速度
-- 优化前端未使用 i18n 文件缓存
-- 优化后端内存占用
-- 优化后端启动速度
-
-### 🐞 修复问题
-
-- 修复首页节点切换失效的问题
-- 修复和优化服务检查流程
-- 修复2.4.1引入的订阅地址重定向报错问题
-- 修复 rpm/deb 包名称问题
-- 修复托盘轻量模式状态检测异常
-- 修复通过 scheme 导入订阅崩溃
-- 修复单例检测实效
-- 修复启动阶段可能导致的无法连接内核
-- 修复导入订阅无法 Auth Basic
-
-### 👙 界面样式
-
-- 简化和改进代理设置样式
-
-## v2.4.1
-
-### 🏆 重大改进
-
-- **应用响应速度提升**：采用全新异步处理架构，大幅提升应用响应速度和稳定性
-
-### ✨ 新增功能
-
-- **Mihomo(Meta) 内核升级至 v1.19.13**
-
-### 🚀 性能优化
-
-- 优化热键响应速度，提升快捷键操作体验
-- 改进服务管理响应性，减少系统服务操作等待时间
-- 提升文件和配置处理性能
-- 优化任务管理和日志记录效率
-- 优化异步内存管理，减少内存占用并提升多任务处理效率
-- 优化启动阶段初始化性能
-
-### 🐞 修复问题
-
-- 修复应用在某些操作中可能出现的响应延迟问题
-- 修复任务管理中的潜在并发问题
-- 修复通过托盘重启应用无法恢复
-- 修复订阅在某些情况下无法导入
-- 修复无法新建订阅时使用远程链接
-- 修复卸载服务后的 tun 开关状态问题
-- 修复页面快速切换订阅时导致崩溃
-- 修复丢失工作目录时无法恢复环境
-- 修复从轻量模式恢复导致崩溃
-
-### 👙 界面样式
-
-- 统一代理设置样式
-
-### 🗑️ 移除内容
-
-- 移除启动阶段自动清理过期订阅
-
-## v2.4.0
-
-**发行代号：融**
-代号释义： 「融」象征融合与贯通，寓意新版本通过全新 IPC 通信机制 将系统各部分紧密衔接，打破壁垒，实现更高效的 数据流通与全面性能优化。
-
-### 🏆 重大改进
-
-- **核心通信架构升级**：采用全新通信机制，提升应用性能和稳定性
-- **流量监控系统重构**：全新的流量监控界面，支持更丰富的数据展示
-- **数据缓存优化**：改进配置和节点数据缓存，提升响应速度
-
-### ✨ 新增功能
-
-- **Mihomo(Meta) 内核升级至 v1.19.12**
-- 新增版本信息复制按钮
-- 增强型流量监控，支持更详细的数据分析
-- 新增流量图表多种显示模式
-- 新增强制刷新配置和节点缓存功能
-- 首页流量统计支持查看刻度线详情
-
-### 🚀 性能优化
-
-- 全面提升数据传输和处理效率
-- 优化内存使用，减少系统资源消耗
-- 改进流量图表渲染性能
-- 优化配置和节点刷新策略，从5秒延长到60秒
-- 改进数据缓存机制，减少重复请求
-- 优化异步程序性能
-
-### 🐞 修复问题
-
-- 修复系统代理状态检测和显示不一致问题
-- 修复系统主题窗口颜色不一致问题
-- 修复特殊字符 URL 处理问题
-- 修复配置修改后缓存不同步问题
-- 修复 Windows 安装器自启设置问题
-- 修复 macOS 下 Dock 图标恢复窗口问题
-- 修复 linux 下 KDE/Plasma 异常标题栏按钮
-- 修复架构升级后节点测速功能异常
-- 修复架构升级后流量统计功能异常
-- 修复架构升级后日志功能异常
-- 修复外部控制器跨域配置保存问题
-- 修复首页端口显示不一致问题
-- 修复首页流量统计刻度线显示问题
-- 修复日志页面按钮功能混淆问题
-- 修复日志等级设置保存问题
-- 修复日志等级异常过滤
-- 修复清理日志天数功能异常
-- 修复偶发性启动卡死问题
-- 修复首页虚拟网卡开关在管理模式下的状态问题
-
-### 🔧 技术改进
-
-- 统一使用新的内核通信方式
-- 新增外部控制器配置界面
-- 改进跨平台兼容性支持
-
-## v2.3.2
-
-### 🐞 修复问题
-
-- 修复系统代理端口不同步问题
-- 修复自定义 `css` 背景图无法生效问题
-- 修复在轻量模式下快速点击托盘图标带来的竞争态卡死问题
-- 修复同时开启静默启动与自动进入轻量模式后，自动进入轻量模式失效的问题
-- 修复静默启动时托盘工具栏轻量模式开启与关闭状态的同步
-- 修复导入订阅时非 http 协议链接被错误尝试导入
-- 修复切换节点后页面长时间 loading 及缓存过期导致的数据不同步问题
-- 修复将快捷键名称更名为 `Clash Verge`之后无法删除图标和无法删除注册表
-- 修复`DNS`覆写 `fallback` `proxy server` `nameserver` `direct Nameserver` 字段支持留空
-- 修复`DNS`覆写 `nameserver-policy` 字段无法正确识别 `geo` 库
-- 修复搜索框输入特殊字符崩溃
-- 修复 Windows 下 Start UP 名称与 exe 名称不统一
-- 修复显示 Mihomo 内核日志等级应该大于设置等级
-
-### ✨ 新增功能
-
-- `sidecar` 模式下清理多余的内核进程，防止运行出现异常
-- 新 macOS 下 TUN 和系统代理模式托盘图标（暂测）
-- 快捷键事件通过系统通知
-- 添加外部 `cors` 控制面板
-
-### 🚀 优化改进
-
-- 优化重构订阅切换逻辑，可以随时中断载入过程，防止卡死
-- 引入事件驱动代理管理器，优化代理配置更新逻辑，防止卡死
-- 改进主页订阅卡流量已使用比例计算精度
-- 优化后端缓存刷新机制，支持毫秒级 TTL（默认 3000ms），减少重复请求并提升性能，切换节点时强制刷新后端数据，前端 UI 实时更新，操作更流畅
-- 解耦前端数据拉取与后端缓存刷新，提升节点切换速度和一致性
-
-### 🗑️ 移除内容
-
-- 移除了 macOS tray 图标显示网络速率
-
-### 🌐 国际化更新
-
-- 修复部分翻译缺失和不一致问题
-
-## v2.3.1
-
-### 🐞 修复问题
-
-- 增加配置文件校验，修复从古老版本升级上来的"No such file or directory (os error 2)"错误
-- 修复扩展脚本转义错误
-- 修复 macOS Intel X86 架构构建错误导致无法运行
-- 修复 Linux 下界面边框白边问题
-- 修复 托盘 无响应问题
-- 修复 托盘 无法从轻量模式退出并恢复窗口
-- 修复 快速切换订阅可能导致的卡死问题
-
-### ✨ 新增功能
-
-- 新增 window-state 窗口状态管理和恢复
-
-### 🚀 优化改进
-
-- 优化 托盘 统一响应
-- 优化 静默启动+自启动轻量模式 运行方式
-- 降低前端潜在内存泄漏风险，提升运行时性能
-- 优化 React 状态、副作用、数据获取、清理等流程。
-
 ## v2.3.0
 
-**发行代号：御**
-代号释义： 「御」，象征掌控与守护，寓意本次版本对系统稳定性、安全性与用户体验的全面驾驭与提升。
+尽管外部控制密钥已自动补全默认值且不允许为空。仍然推荐自行修改外部控制密钥。
 
-尽管 `external-controller` 密钥现已自动补全默认值且不允许为空，**仍建议手动修改密钥以提高安全性**。
+#### ⚠️ 已知问题
+ - 仅在Ubuntu 22.04/24.04，Fedora 41 **Gnome桌面环境** 做过简单测试，不保证其他其他Linux发行版可用，将在未来做进一步适配和调优
+ - MacOS 下 墙贴主要为浅色，Tray 图标深色时图标闪烁；彩色 Tray 速率颜色淡
+ - 窗口状态管理器已确定上游存在缺陷，暂时移除。当前不再内置窗口大小和位置记忆。
+ - MacOS 下卸载服务后需手动重启软件才能与内核通信。
 
-### ⚠️ 已知问题
+### 2.3.0 相对于 2.2.3
+#### 🐞 修复问题
+ - 首页"代理模式"快速切换导致的卡死问题
+ - 解锁测试报错信息
+ - Macos 快捷键关闭窗口无法启用自动轻量模式
+ - 静默启动异常窗口创建和关闭流程
+ - Windows 错误的全局快捷键 `Ctrl+Q` 注册
+ - Vless URL 解码时网络类型错误
+ - 切换自定义代理地址导致系统代理状态异常
+ - Macos TUN 默认无效网卡名称
+ - 托盘更改订阅后 UI 不同步的问题
+ - 修复提权漏洞，改用带认证的 IPC 通信
+ - 编辑器中连字符问题
+ - 安装服务模式后无法立即开启 TUN 模式
+ - 同步更新多语言翻译
+ - 修复 .window-state.json 无法删除的问题
+ - 无法修改配置更新 HTTP 请求超时
+ - 修复 getDelayFix 钩子问题
+ - 使用外部扩展脚本覆写代理组时首页无法显示代理组
+ - 导出诊断 Verge 版本与设置页面不同步
+ - 切换语言时可能造成设置页面无法加载
 
-- 仅在 Ubuntu 22.04/24.04、Fedora 41 的 **GNOME 桌面环境** 做过简单测试，不保证其他 Linux 发行版兼容，后续将逐步适配和优化。
-- macOS：
-  - MacOS 下自动升级成功后请关闭程序等待 30 秒重启，因为 MacOS 的端口释放特性，卸载服务后需重启应用等 30 秒才能恢复内核通信。立即启动可能无法正常启动内核。
-  - 墙贴主要为浅色，深色 Tray 图标存在闪烁问题；
-  - 彩色 Tray 图标颜色偏淡；
+#### ✨ 新增功能
+ - Mihomo(Meta)内核升级至 1.19.10
+ - 允许代理主机地址设置为非 127.0.0.1 对 WSL 代理友好
+ - 关闭系统代理时关闭已建立的网络连接
+ - 托盘显示当前轻量模式状态
+ - Webdav 请求加入 UA
+ - Webdav 支持目录重定向
+ - Webdav 备份目录检查和文件上传重试机制
+ - 系统代理守卫可检查意外设置变更并恢复
+ - 定时自动订阅更新也能自动回退使用代理
+ - 订阅请求超时机制，防止订阅更新的时候卡死
+ - 订阅卡片点击时间可切换下次自动更新时间，自动更新触发后页面有明确的成功与否提示
+ - 添加网络管理器以优化网络请求处理，防止资源竞争导致的启动时 UI 卡死
+ - 更新依赖，替换弃用元素
+ - 首页当前节点增加排序功能
+ - DNS 覆写下增加 Hosts 设置功能
+ - 修复服务模式安装后无法立即开启 TUN 模式的问题
+ - 支持手动卸载服务模式，回退到 Sidecar 模式
+ - 添加了土耳其语,日本语,德语,西班牙语,繁体中文的支持
+ - 卸载服务的按钮
+ - 添加了Zashboard的一键跳转URL
+ - 使用操作系统默认的窗口管理器
+ - 切换、升级、重启内核的状态管理
+ - 更精细化控制自动日志清理，新增1天选项
+ - Winodws 快捷键名称改为 `Clash Verge`
+ - 配置加载阶段自动补全 external-controller secret 字段。
 
-- 已确认窗口状态管理器存在上游缺陷，已暂时移除窗口大小与位置记忆功能。
+#### 🚀 优化改进
+ - 系统代理 Bypass 设置
+ - Windows 下使用 Startup 文件夹的方式实现开机自启，解决管理员模式下开机自启的各种问题
+ - 切换到规则页面时自动刷新规则数据
+ - 重构更新失败回退机制，使用后端完成更新失败后回退到使用 Clash 代理再次尝试更新
+ - 编辑非激活订阅的时候不在触发当前订阅配置重载
+ - 改进核心功能防止主进程阻塞、改进MihomoManager实现，以及优化窗口创建流程
+ - 优化系统代理设置更新逻辑
+ - 重构前端通知系统分离通知线程防止前端卡死
+ - 优化网络请求和错误处理
+ - 重构通知系统
+ - 使用异步方法重构 UI 启动逻辑，解决启动软件过程中的各种卡死问题
+ - MacOS 下默认关闭托盘速率显示
+ - 优化服务操作流程，提升系统服务相关操作的稳定性和用户体验
+ - 优化了其他语言的翻译问题
+ - Mihomo 内核默认日志等级为 warn
+ - Clash Verge Rev 应用默认日志等级为 warn
+ - 重构了原来的 IP 信息请求重试机制，采用轮询检测，解决了 Network Error 和超时问题
+ - 对轮询检测机制进行了优化，引入洗牌算法来增强随机性
+ - 对获取系统信息的流程进行了优化，并添加了去重检测机制，确保剔除重复的信息
+ - 优化窗口状态初始化逻辑和添加缺失的权限设置
+ - 异步化配置：优化端口查找和配置保存逻辑
+ - 重构事件通知机制到独立线程，避免前端卡死
+ - 优化端口设置，每个端口可随机设置端口号
+ - 优化了保存机制，使用平滑函数，防止客户端卡死
+ - 优化端口设置退出和保存机制
+ - 强制为 Mihomo 配置补全并覆盖 external-controller-cors 字段，默认不允许跨域和仅本地请求，提升 cors 安全性，升级配置时自动覆盖
+ - 修改 端口检测范围 （1111-65536）
+ - 配置文件缺失 secret 字段时自动填充默认值 set-your-secret
+ - 优化异步处理，防止部分组件 UI 阻塞
+ - 关闭 DNS 启用
+ - 延迟测试链接更换为 Https 协议 https://cp.cloudflare.com/generate_204
 
-### 🐞 修复问题
-
-- 修复首页“代理模式”快速切换导致的卡死问题
-- 修复 MacOS 快捷键关闭窗口无法启用自动轻量模式
-- 修复静默启动异常窗口的创建与关闭流程
-- 修复 Windows 下错误注册的全局快捷键 `Ctrl+Q`
-- 修复解锁测试报错信息与 VLESS URL 解码时的网络类型错误
-- 修复切换自定义代理地址后系统代理状态异常
-- 修复 macOS TUN 默认无效网卡名称
-- 修复更改订阅后托盘 UI 不同步的问题
-- 修复服务模式安装后无法立即开启 TUN 模式
-- 修复无法删除 `.window-state.json`
-- 修复无法修改配置更新 HTTP 请求超时问题
-- 修复 `getDelayFix` 钩子异常
-- 修复外部扩展脚本覆写代理组时首页无法显示代理组
-- 修复 Verge 导出诊断版本与设置页面不同步
-- 修复切换语言时设置页面可能加载失败
-- 修复编辑器中连字符处理问题
-- 修复提权漏洞，改用带认证的 IPC 通信机制
-- 修复静默启动无法使用自动轻量模式
-- 修复 JS 脚本转义特殊字符报错
-- 修复 macOS 静默启动时异常启动 Dock 栏图标
-
-### ✨ 新增功能
-
-- **Mihomo(Meta) 内核升级至 v1.19.10**
-- 支持设置代理地址为非 `127.0.0.1`，提升 WSL 兼容性
-- 系统代理守卫：可检测意外变更并自动恢复
-- 托盘新增当前轻量模式状态显示
-- 关闭系统代理时同时断开已建立的连接
-- 新增 WebDAV 功能：
-  - 加入 UA 请求头
-  - 支持目录重定向
-  - 备份目录检查与上传重试机制
-
-- 自动订阅更新机制：
-  - 加入请求超时机制防止卡死
-  - 支持在代理状态下自动重试订阅更新
-  - 支持订阅卡片点击切换下次自动更新时间，并显示更新结果提示
-
-- DNS 设置新增 Hosts 配置功能
-- 首页代理节点支持排序
-- 支持服务模式手动卸载，回退至 Sidecar 模式
-- 核心状态管理支持切换、升级、重启
-- 配置加载阶段自动补全 `external-controller secret`
-- 新增日志自动清理周期选项（含1天）
-- 新增 Zashboard 一键跳转入口
-- 使用系统默认窗口管理器
-
-### 🚀 优化改进
-
-- **系统相关：**
-  - 系统代理 Bypass 设置优化
-  - 优化代理设置更新逻辑与守卫机制
-  - Windows 启动方式调整为 Startup 文件夹，解决管理员模式下自启问题
-
-- **性能与稳定性：**
-  - 全面异步化处理配置加载、UI 启动、事件通知等关键流程，解决卡顿问题
-  - 优化 MihomoManager 实现与窗口创建流程
-  - 改进内核日志等级为 `warn`，减少噪音输出
-  - 重构主进程与通知系统，提升响应性与分离度
-  - 优化网络请求与错误处理机制
-  - 添加网络管理器防止资源竞争引发 UI 卡死
-  - 优化配置文件加载内存使用
-  - 优化缓存 Mihomo proxy 和 providers 信息内存使用
-
-- **前端与界面体验：**
-  - 切换规则页自动刷新数据
-  - 非激活订阅编辑时不再触发配置重载
-  - 优化托盘速率显示，macOS 下默认关闭
-  - Windows 快捷键名称更名为 `Clash Verge`
-  - 更新失败可回退至使用代理重试
-  - 支持异步端口查找与保存，端口支持随机生成
-  - 修改端口检测范围至 `1111-65536`
-  - 优化保存机制，使用平滑函数防止卡顿
-
-- **配置增强与安全性：**
-  - 配置缺失 `secret` 字段时自动补全为 `set-your-secret`
-  - 强制为 Mihomo 配置补全 `external-controller-cors` 字段（默认不允许跨域，限制本地访问）计划后续支持自定义 cors
-  - 优化窗口权限设置与状态初始化逻辑
-  - 网络延迟测试替换为 HTTPS 协议：`https://cp.cloudflare.com/generate_204`
-  - 优化 IP 信息获取流程，添加去重机制与轮询检测算法
-
-- 同步修复翻译错误与不一致项，优化整体语言体验
-- 加强语言切换后的页面稳定性，避免加载异常
-
-### 🗑️ 移除内容
-
-- 窗口状态管理器（上游存在缺陷）
-- WebDAV 跨平台备份恢复限制
-
----
+#### 🗑️ 移除内容
+ - 窗口状态管理器
+ - Webdav 跨平台备份恢复限制
 
 ## v2.2.3
 
 #### 已知问题
-
-- 仅在Ubuntu 22.04/24.04，Fedora 41 **Gnome桌面环境** 做过简单测试，不保证其他其他Linux发行版可用，将在未来做进一步适配和调优
-- MacOS 自定义图标与速率显示推荐图标尺寸为 256x256。其他尺寸（可能）会导致不正常图标和速率间隙
-- MacOS 下 墙贴主要为浅色，Tray 图标深色时图标闪烁；彩色 Tray 速率颜色淡
-- Linux 下 Clash Verge Rev 内存占用显著高于 Windows / MacOS
+ - 仅在Ubuntu 22.04/24.04，Fedora 41 **Gnome桌面环境** 做过简单测试，不保证其他其他Linux发行版可用，将在未来做进一步适配和调优
+ - MacOS 自定义图标与速率显示推荐图标尺寸为 256x256。其他尺寸（可能）会导致不正常图标和速率间隙
+ - MacOS 下 墙贴主要为浅色，Tray 图标深色时图标闪烁；彩色 Tray 速率颜色淡
+ - Linux 下 Clash Verge Rev 内存占用显著高于 Windows / MacOS
 
 ### 2.2.3 相对于 2.2.2
-
 #### 修复了：
-
-- 首页“当前代理”因为重复刷新导致的CPU占用过高的问题
-- “开机自启”和“DNS覆写”开关跳动问题
-- 自定义托盘图标未能应用更改
-- MacOS 自定义托盘图标显示速率时图标和文本间隙过大
-- MacOS 托盘速率显示不全
-- Linux 在系统服务模式下无法拉起 Mihomo 内核
-- 使用异步操作，避免获取系统信息和切换代理模式可能带来的崩溃
-- 相同节点名称可能导致的页面渲染出错
-- URL Schemes被截断的问题
-- 首页流量统计卡更好的时间戳范围
-- 静默启动无法触发自动轻量化计时器
+ - 首页“当前代理”因为重复刷新导致的CPU占用过高的问题
+ - “开机自启”和“DNS覆写”开关跳动问题
+ - 自定义托盘图标未能应用更改
+ - MacOS 自定义托盘图标显示速率时图标和文本间隙过大
+ - MacOS 托盘速率显示不全
+ - Linux 在系统服务模式下无法拉起 Mihomo 内核
+ - 使用异步操作，避免获取系统信息和切换代理模式可能带来的崩溃
+ - 相同节点名称可能导致的页面渲染出错
+ - URL Schemes被截断的问题
+ - 首页流量统计卡更好的时间戳范围
+ - 静默启动无法触发自动轻量化计时器
 
 #### 新增了：
-
-- Mihomo(Meta)内核升级至 1.19.4
-- Clash Verge Rev 从现在开始不再强依赖系统服务和管理权限
-- 支持根据用户偏好选择Sidecar(用户空间)模式或安装服务
-- 增加载入初始配置文件的错误提示，防止切换到错误的订阅配置
-- 检测是否以管理员模式运行软件，如果是提示无法使用开机自启
-- 代理组显示节点数量
-- 统一运行模式检测，支持管理员模式下开启TUN模式
-- 托盘切换代理模式会根据设置自动断开之前连接
-- 如订阅获取失败回退使用Clash内核代理再次尝试
+ - Mihomo(Meta)内核升级至 1.19.4
+ - Clash Verge Rev 从现在开始不再强依赖系统服务和管理权限
+ - 支持根据用户偏好选择Sidecar(用户空间)模式或安装服务
+ - 增加载入初始配置文件的错误提示，防止切换到错误的订阅配置
+ - 检测是否以管理员模式运行软件，如果是提示无法使用开机自启
+ - 代理组显示节点数量
+ - 统一运行模式检测，支持管理员模式下开启TUN模式
+ - 托盘切换代理模式会根据设置自动断开之前连接
+ - 如订阅获取失败回退使用Clash内核代理再次尝试
 
 #### 移除了：
-
-- 实时保存窗口位置和大小。这个功能可能会导致窗口异常大小和位置，还需观察。
+ - 实时保存窗口位置和大小。这个功能可能会导致窗口异常大小和位置，还需观察。
 
 #### 优化了：
-
-- 重构了后端内核管理逻辑，更轻量化和有效的管理内核，提高了性能和稳定性
-- 前端统一刷新应用数据，优化数据获取和刷新逻辑
-- 优化首页流量图表代码，调整图表文字边距
-- MacOS 托盘速率更好的显示样式和更新逻辑
-- 首页仅在有流量图表时显示流量图表区域
-- 更新DNS默认覆写配置
-- 移除测试目录，简化资源初始化逻辑
+ - 重构了后端内核管理逻辑，更轻量化和有效的管理内核，提高了性能和稳定性
+ - 前端统一刷新应用数据，优化数据获取和刷新逻辑
+ - 优化首页流量图表代码，调整图表文字边距
+ - MacOS 托盘速率更好的显示样式和更新逻辑
+ - 首页仅在有流量图表时显示流量图表区域
+ - 更新DNS默认覆写配置
+ - 移除测试目录，简化资源初始化逻辑
 
 ## v2.2.2
 
@@ -376,29 +148,23 @@
 代号释义： 本次发布在功能上的大幅扩展。新首页设计为用户带来全新交互体验，DNS 覆写功能增强网络控制能力，解锁测试页面助力内容访问自由度提升，轻量模式提供灵活使用选择。此外，macOS 应用菜单集成、sidecar 模式、诊断信息导出等新特性进一步丰富了软件的适用场景。这些新增功能显著拓宽了 Clash Verge 的功能边界，为用户提供了更强大的工具和可能性。
 
 #### 已知问题
-
-- 仅在Ubuntu 22.04/24.04，Fedora 41 **Gnome桌面环境** 做过简单测试，不保证其他其他Linux发行版可用，将在未来做进一步适配和调优
+ - 仅在Ubuntu 22.04/24.04，Fedora 41 **Gnome桌面环境** 做过简单测试，不保证其他其他Linux发行版可用，将在未来做进一步适配和调优
 
 ### 2.2.2 相对于 2.2.1(已下架不再提供)
-
 #### 修复了：
-
-- 弹黑框的问题（原因是服务崩溃触发重装机制）
-- MacOS进入轻量模式以后隐藏Dock图标
-- 增加轻量模式缺失的tray翻译
-- Linux下的窗口边框被削掉的问题
+ - 弹黑框的问题（原因是服务崩溃触发重装机制）
+ - MacOS进入轻量模式以后隐藏Dock图标
+ - 增加轻量模式缺失的tray翻译
+ - Linux下的窗口边框被削掉的问题
 
 #### 新增了:
-
-- 加强服务检测和重装逻辑
-- 增强内核与服务保活机制
-- 增加服务模式下的僵尸进程清理机制
-- 新增当服务模式多次尝试失败后自动回退至用户空间模式
+ - 加强服务检测和重装逻辑
+ - 增强内核与服务保活机制
+ - 增加服务模式下的僵尸进程清理机制
+ - 新增当服务模式多次尝试失败后自动回退至用户空间模式
 
 ### 2.2.1 相对于 2.2.0(已下架不再提供)
-
 #### 修复了：
-
 1. **首页**
    - 修复 Direct 模式首页无法渲染
    - 修复 首页启用轻量模式导致 ClashVergeRev 从托盘退出
@@ -415,7 +181,6 @@
    - 修复 MacOS 轻量模式下 Dock 栏图标无法隐藏。
 
 #### 新增了:
-
 1. **首页**
    - 首页文本过长自动截断
 2. **轻量模式**
@@ -432,7 +197,6 @@
 ## 2.2.0(已下架不再提供)
 
 #### 新增功能
-
 1. **首页**
    - 新增首页功能，默认启动页面改为首页。
    - 首页流量图卡片显示上传/下载名称。
@@ -464,7 +228,6 @@
    - 新增代理命令。
 
 #### 修复
-
 1. **系统**
    - 修复 Windows 热键崩溃。
    - 修复 macOS 无框标题。
@@ -478,7 +241,6 @@
    - 修复构建失败问题。
 
 #### 优化
-
 1. **性能**
    - 重构后端，巨幅性能优化。
    - 优化首页组件性能。
@@ -534,7 +296,7 @@
 
 - 新增窗口状态实时监控与自动保存功能
 - 增强核心配置变更时的验证与错误处理机制
-- 支持通过环境变量 `CLASH_VERGE_REV_IP`自定义复制IP地址
+- 支持通过环境变量`CLASH_VERGE_REV_IP`自定义复制IP地址
 - 添加连接表列宽持久化设置与进程过滤功能
 - 新增代理组首字母导航与动态滚动定位功能
 - 实现连接追踪暂停/恢复功能
@@ -855,7 +617,7 @@
 - 禁用部分 Webview2 快捷键
 - 热键配置新增连接符 + 号
 - 新增部分悬浮提示按钮，用于解释说明
-- 当日志等级为 `Debug`时（更改需重启软件生效），支持点击内存主动内存回收（绿色文字）
+- 当日志等级为`Debug`时（更改需重启软件生效），支持点击内存主动内存回收（绿色文字）
 - 设置页面右上角新增 TG 频道链接
 - 各种细节优化和界面性能优化
 
@@ -895,7 +657,7 @@
 - 禁用部分 Webview2 快捷键
 - 热键配置新增连接符 + 号
 - 新增部分悬浮提示按钮，用于解释说明
-- 当日志等级为 `Debug`时（更改需重启软件生效），支持点击内存主动内存回收（绿色文字）
+- 当日志等级为`Debug`时（更改需重启软件生效），支持点击内存主动内存回收（绿色文字）
 - 设置页面右上角新增 TG 频道链接
 - 各种细节优化和界面性能优化
 
@@ -931,7 +693,7 @@
 - 禁用部分 Webview2 快捷键
 - 热键配置新增连接符 + 号
 - 新增部分悬浮提示按钮，用于解释说明
-- 当日志等级为 `Debug`时（更改需重启软件生效），支持点击内存主动内存回收（绿色文字）
+- 当日志等级为`Debug`时（更改需重启软件生效），支持点击内存主动内存回收（绿色文字）
 - 设置页面右上角新增 TG 频道链接
 
 ### Bugs Fixes
@@ -1105,7 +867,7 @@
 ### Features
 
 - 缓存代理组图标
-- 使用 `boa_engine` 代替 `rquickjs`
+- 使用`boa_engine` 代替 `rquickjs`
 - 支持 Linux armv7
 
 ### Bugs Fixes
@@ -1170,7 +932,7 @@
 - 支持自定义托盘图标
 - 支持禁用代理组图标
 - 代理组显示当前代理
-- 修改 `打开面板` 快捷键为 `打开/关闭面板`
+- 修改 `打开面板` 快捷键为`打开/关闭面板`
 
 ---
 
@@ -1334,7 +1096,7 @@
 
 ### Bugs Fixes
 
-- Windows 下更新时无法覆盖 `clash-verge-service.exe`的问题(需要卸载重装一次服务，下次更新生效)
+- Windows 下更新时无法覆盖`clash-verge-service.exe`的问题(需要卸载重装一次服务，下次更新生效)
 - 窗口最大化按钮变化问题
 - 窗口尺寸保存错误问题
 - 复制环境变量类型无法切换问题

crowdin.yml

@@ -1,4 +0,0 @@
-files:
-  - source: /src/locales/en.json
-    translation: /src/locales
-    multilingual: 1

eslint.config.ts

@@ -1,106 +0,0 @@
-import js from "@eslint/js";
-import configPrettier from "eslint-config-prettier";
-import pluginImport from "eslint-plugin-import";
-import pluginPrettier from "eslint-plugin-prettier";
-import pluginReact from "eslint-plugin-react";
-import pluginReactHooks from "eslint-plugin-react-hooks";
-import pluginReactRefresh from "eslint-plugin-react-refresh";
-import pluginUnusedImports from "eslint-plugin-unused-imports";
-import { defineConfig } from "eslint/config";
-import globals from "globals";
-import tseslint from "typescript-eslint";
-
-export default defineConfig([
-  {
-    files: ["**/*.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"],
-
-    plugins: {
-      js,
-      react: pluginReact,
-      "react-hooks": pluginReactHooks,
-      import: pluginImport,
-      "react-refresh": pluginReactRefresh,
-      "unused-imports": pluginUnusedImports,
-      prettier: pluginPrettier,
-    },
-
-    extends: [
-      "js/recommended",
-      tseslint.configs.recommended,
-      pluginReact.configs.flat.recommended,
-      pluginReact.configs.flat["jsx-runtime"],
-      configPrettier,
-    ],
-
-    languageOptions: {
-      globals: globals.browser,
-    },
-
-    settings: {
-      react: {
-        version: "detect",
-      },
-      "import/resolver": {
-        typescript: {
-          project: "./tsconfig.json",
-        },
-      },
-    },
-
-    rules: {
-      // React
-      "react-hooks/rules-of-hooks": "error",
-      "react-hooks/exhaustive-deps": "error",
-      "react-refresh/only-export-components": [
-        "warn",
-        { allowConstantExport: true },
-      ],
-
-      // TypeScript
-      "@typescript-eslint/no-explicit-any": "off",
-
-      // unused-imports 代替 no-unused-vars
-      "@typescript-eslint/no-unused-vars": "off",
-      "unused-imports/no-unused-imports": "error",
-      "unused-imports/no-unused-vars": [
-        "warn",
-        {
-          vars: "all",
-          varsIgnorePattern: "^_+$",
-          args: "after-used",
-          argsIgnorePattern: "^_+$",
-        },
-      ],
-
-      // Import
-      "import/no-unresolved": "error",
-      "import/order": [
-        "warn",
-        {
-          groups: [
-            "builtin",
-            "external",
-            "internal",
-            "parent",
-            "sibling",
-            "index",
-          ],
-          "newlines-between": "always",
-          alphabetize: {
-            order: "asc",
-            caseInsensitive: true,
-          },
-        },
-      ],
-
-      // 其他常见
-      "prefer-const": "warn",
-      "no-case-declarations": "error",
-      "no-fallthrough": "error",
-      "no-empty": ["warn", { allowEmptyCatch: true }],
-
-      // Prettier 格式化问题
-      "prettier/prettier": "warn",
-    },
-  },
-]);

package.json

@@ -1,117 +1,115 @@
 {
   "name": "clash-verge",
-  "version": "2.4.3",
+  "version": "2.3.0-alpha.5",
   "license": "GPL-3.0-only",
   "scripts": {
-    "dev": "cross-env RUST_BACKTRACE=full tauri dev -f verge-dev",
-    "dev:diff": "cross-env RUST_BACKTRACE=full tauri dev -f verge-dev",
-    "dev:trace": "cross-env RUST_BACKTRACE=full RUSTFLAGS=\"--cfg tokio_unstable\" tauri dev -f verge-dev tokio-trace",
-    "dev:tauri": "cross-env RUST_BACKTRACE=full tauri dev -f tauri-dev",
+    "dev": "cross-env RUST_BACKTRACE=1 tauri dev -f verge-dev",
+    "dev:diff": "cross-env RUST_BACKTRACE=1 tauri dev -f verge-dev",
     "build": "cross-env NODE_OPTIONS='--max-old-space-size=4096' tauri build",
     "build:fast": "cross-env NODE_OPTIONS='--max-old-space-size=4096' tauri build -- --profile fast-release",
     "tauri": "tauri",
     "web:dev": "vite",
     "web:build": "tsc --noEmit && vite build",
     "web:serve": "vite preview",
-    "prebuild": "node scripts/prebuild.mjs",
+    "check": "node scripts/check.mjs",
     "updater": "node scripts/updater.mjs",
     "updater-fixed-webview2": "node scripts/updater-fixed-webview2.mjs",
     "portable": "node scripts/portable.mjs",
     "portable-fixed-webview2": "node scripts/portable-fixed-webview2.mjs",
     "fix-alpha-version": "node scripts/fix-alpha_version.mjs",
     "release-version": "node scripts/release-version.mjs",
-    "release:autobuild": "pnpm release-version autobuild",
-    "release:deploytest": "pnpm release-version deploytest",
     "publish-version": "node scripts/publish-version.mjs",
+    "prepare": "husky",
     "fmt": "cargo fmt --manifest-path ./src-tauri/Cargo.toml",
-    "clippy": "cargo clippy  --manifest-path ./src-tauri/Cargo.toml",
-    "lint": "eslint -c eslint.config.ts  --cache src",
-    "format": "prettier --write .",
-    "format:check": "prettier --check ."
+    "clippy": "cargo clippy  --manifest-path ./src-tauri/Cargo.toml"
   },
   "dependencies": {
     "@dnd-kit/core": "^6.3.1",
     "@dnd-kit/sortable": "^10.0.0",
     "@dnd-kit/utilities": "^3.2.2",
     "@emotion/react": "^11.14.0",
-    "@emotion/styled": "^11.14.1",
+    "@emotion/styled": "^11.14.0",
     "@juggle/resize-observer": "^3.4.0",
-    "@mui/icons-material": "^7.3.2",
-    "@mui/lab": "7.0.0-beta.17",
-    "@mui/material": "^7.3.2",
-    "@mui/x-data-grid": "^8.11.2",
-    "@tauri-apps/api": "2.8.0",
-    "@tauri-apps/plugin-clipboard-manager": "^2.3.0",
-    "@tauri-apps/plugin-dialog": "^2.4.0",
-    "@tauri-apps/plugin-fs": "^2.4.2",
-    "@tauri-apps/plugin-http": "~2",
-    "@tauri-apps/plugin-process": "^2.3.0",
-    "@tauri-apps/plugin-shell": "2.3.1",
-    "@tauri-apps/plugin-updater": "2.9.0",
+    "@mui/icons-material": "^7.1.1",
+    "@mui/lab": "7.0.0-beta.13",
+    "@mui/material": "^7.1.1",
+    "@mui/x-data-grid": "^8.5.0",
+    "@tauri-apps/api": "2.5.0",
+    "@tauri-apps/plugin-clipboard-manager": "^2.2.2",
+    "@tauri-apps/plugin-dialog": "^2.2.2",
+    "@tauri-apps/plugin-fs": "^2.3.0",
+    "@tauri-apps/plugin-global-shortcut": "^2.2.1",
+    "@tauri-apps/plugin-notification": "^2.2.2",
+    "@tauri-apps/plugin-process": "^2.2.1",
+    "@tauri-apps/plugin-shell": "2.2.1",
+    "@tauri-apps/plugin-updater": "2.7.1",
+    "@tauri-apps/plugin-window-state": "^2.2.2",
+    "@types/d3-shape": "^3.1.7",
     "@types/json-schema": "^7.0.15",
-    "ahooks": "^3.9.5",
-    "axios": "^1.12.2",
-    "dayjs": "1.11.18",
-    "foxact": "^0.2.49",
-    "i18next": "^25.5.2",
+    "ahooks": "^3.8.5",
+    "axios": "^1.9.0",
+    "chart.js": "^4.4.9",
+    "cli-color": "^2.0.4",
+    "d3-shape": "^3.2.0",
+    "dayjs": "1.11.13",
+    "foxact": "^0.2.45",
+    "glob": "^11.0.2",
+    "i18next": "^25.2.1",
+    "js-base64": "^3.7.7",
     "js-yaml": "^4.1.0",
-    "json-schema": "^0.4.0",
     "lodash-es": "^4.17.21",
-    "monaco-editor": "^0.53.0",
+    "monaco-editor": "^0.52.2",
     "monaco-yaml": "^5.4.0",
     "nanoid": "^5.1.5",
-    "react": "19.1.1",
-    "react-dom": "19.1.1",
+    "peggy": "^5.0.3",
+    "react": "19.1.0",
+    "react-chartjs-2": "^5.3.0",
+    "react-dom": "19.1.0",
     "react-error-boundary": "6.0.0",
-    "react-hook-form": "^7.62.0",
-    "react-i18next": "15.7.3",
+    "react-hook-form": "^7.57.0",
+    "react-i18next": "15.5.2",
     "react-markdown": "10.1.0",
-    "react-monaco-editor": "0.59.0",
-    "react-router-dom": "7.9.1",
-    "react-virtuoso": "^4.14.0",
-    "swr": "^2.3.6",
+    "react-monaco-editor": "0.58.0",
+    "react-router-dom": "7.6.2",
+    "react-virtuoso": "^4.12.8",
+    "sockette": "^2.0.6",
+    "swr": "^2.3.3",
+    "tar": "^7.4.3",
     "types-pac": "^1.0.3",
-    "zustand": "^5.0.8"
+    "zustand": "^5.0.5"
   },
   "devDependencies": {
     "@actions/github": "^6.0.1",
-    "@eslint/js": "^9.35.0",
-    "@tauri-apps/cli": "2.8.4",
+    "@tauri-apps/cli": "2.5.0",
+    "@types/js-cookie": "^3.0.6",
     "@types/js-yaml": "^4.0.9",
     "@types/lodash-es": "^4.17.12",
-    "@types/react": "19.1.13",
-    "@types/react-dom": "19.1.9",
-    "@vitejs/plugin-legacy": "^7.2.1",
-    "@vitejs/plugin-react": "5.0.2",
+    "@types/react": "19.1.6",
+    "@types/react-dom": "19.1.6",
+    "@vitejs/plugin-legacy": "^6.1.1",
+    "@vitejs/plugin-react": "4.5.1",
     "adm-zip": "^0.5.16",
-    "cli-color": "^2.0.4",
-    "commander": "^14.0.1",
-    "cross-env": "^10.0.0",
-    "eslint": "^9.35.0",
-    "eslint-config-prettier": "^10.1.8",
-    "eslint-import-resolver-typescript": "^4.4.4",
-    "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-prettier": "^5.5.4",
-    "eslint-plugin-react": "^7.37.5",
-    "eslint-plugin-react-hooks": "^5.2.0",
-    "eslint-plugin-react-refresh": "^0.4.20",
-    "eslint-plugin-unused-imports": "^4.2.0",
-    "glob": "^11.0.3",
-    "globals": "^16.4.0",
+    "commander": "^14.0.0",
+    "cross-env": "^7.0.3",
     "https-proxy-agent": "^7.0.6",
-    "jiti": "^2.5.1",
-    "meta-json-schema": "^1.19.13",
+    "husky": "^9.1.7",
+    "meta-json-schema": "^1.19.10",
     "node-fetch": "^3.3.2",
-    "prettier": "^3.6.2",
-    "sass": "^1.92.1",
-    "tar": "^7.4.3",
-    "terser": "^5.44.0",
-    "typescript": "^5.9.2",
-    "typescript-eslint": "^8.44.0",
-    "vite": "^7.1.5",
+    "prettier": "^3.5.3",
+    "pretty-quick": "^4.2.2",
+    "sass": "^1.89.1",
+    "terser": "^5.40.0",
+    "typescript": "^5.8.3",
+    "vite": "^6.3.5",
     "vite-plugin-monaco-editor": "^1.1.0",
-    "vite-plugin-svgr": "^4.5.0"
+    "vite-plugin-svgr": "^4.3.0"
+  },
+  "prettier": {
+    "tabWidth": 2,
+    "semi": true,
+    "singleQuote": false,
+    "endOfLine": "lf"
   },
   "type": "module",
   "packageManager": "pnpm@9.13.2"
-}
+}

renovate.json

@@ -1,5 +1,5 @@
 {
-  "extends": ["config:recommended", ":disableDependencyDashboard"],
+  "extends": ["config:recommended"],
   "baseBranches": ["dev"],
   "enabledManagers": ["cargo", "npm"],
   "labels": ["dependencies"],
@@ -38,5 +38,5 @@
     }
   ],
   "postUpdateOptions": ["pnpmDedupe"],
-  "ignoreDeps": ["criterion"]
+  "ignoreDeps": ["serde_yaml"]
 }

scripts-workflow/get_latest_tauri_commit.bash

@@ -1,56 +0,0 @@
-#!/bin/bash
-
-# 获取最近一个和 Tauri 相关的改动的 commit hash
-# This script finds the latest commit that modified Tauri-related files
-
-# Tauri 相关文件的模式
-TAURI_PATTERNS=(
-    "src-tauri/"
-    "Cargo.toml"
-    "Cargo.lock"
-    "tauri.*.conf.json"
-    "package.json"
-    "pnpm-lock.yaml"
-    "src/"
-)
-
-# 排除的文件模式（build artifacts 等）
-EXCLUDE_PATTERNS=(
-    "src-tauri/target/"
-    "src-tauri/gen/"
-    "*.log"
-    "*.tmp"
-    "node_modules/"
-    ".git/"
-)
-
-# 构建 git log 的路径过滤参数
-PATHS=""
-for pattern in "${TAURI_PATTERNS[@]}"; do
-    if [[ -e "$pattern" ]]; then
-        PATHS="$PATHS $pattern"
-    fi
-done
-
-# 如果没有找到相关路径，返回错误
-if [[ -z "$PATHS" ]]; then
-    echo "Error: No Tauri-related paths found in current directory" >&2
-    exit 1
-fi
-
-# 获取最新的 commit hash
-# 使用 git log 查找最近修改了 Tauri 相关文件的提交
-LATEST_COMMIT=$(git log --format="%H" -n 1 -- $PATHS)
-
-# 验证是否找到了 commit
-if [[ -z "$LATEST_COMMIT" ]]; then
-    echo "Error: No commits found for Tauri-related files" >&2
-    exit 1
-fi
-
-# 输出结果
-echo "$LATEST_COMMIT"
-
-# 如果需要更多信息，可以取消注释以下行
-# echo "Latest Tauri-related commit: $LATEST_COMMIT"
-# git show --stat --oneline "$LATEST_COMMIT"

scripts/check-unused-i18n.js

@@ -1,21 +1,21 @@
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-const LOCALES_DIR = path.resolve(__dirname, "../src/locales");
+const LOCALES_DIR = path.resolve(__dirname, '../src/locales');
 const SRC_DIRS = [
-  path.resolve(__dirname, "../src"),
-  path.resolve(__dirname, "../src-tauri"),
+  path.resolve(__dirname, '../src'),
+  path.resolve(__dirname, '../src-tauri')
 ];
-const exts = [".js", ".ts", ".tsx", ".jsx", ".vue", ".rs"];
+const exts = ['.js', '.ts', '.tsx', '.jsx', '.vue', '.rs'];
 
 // 递归获取所有文件
 function getAllFiles(dir, exts) {
   let files = [];
-  fs.readdirSync(dir).forEach((file) => {
+  fs.readdirSync(dir).forEach(file => {
     const full = path.join(dir, file);
     if (fs.statSync(full).isDirectory()) {
       files = files.concat(getAllFiles(full, exts));
@@ -28,21 +28,21 @@ function getAllFiles(dir, exts) {
 
 // 读取所有源码内容为一个大字符串
 function getAllSourceContent() {
-  const files = SRC_DIRS.flatMap((dir) => getAllFiles(dir, exts));
-  return files.map((f) => fs.readFileSync(f, "utf8")).join("\n");
+  const files = SRC_DIRS.flatMap(dir => getAllFiles(dir, exts));
+  return files.map(f => fs.readFileSync(f, 'utf8')).join('\n');
 }
 
 // 白名单 key，不检查这些 key 是否被使用
 const WHITELIST_KEYS = [
-  "theme.light",
-  "theme.dark",
-  "theme.system",
-  "Already Using Latest Core Version",
+  'theme.light',
+  'theme.dark',
+  'theme.system',
+  "Already Using Latest Core Version"
 ];
 
 // 主流程
 function processI18nFile(i18nPath, lang, allSource) {
-  const i18n = JSON.parse(fs.readFileSync(i18nPath, "utf8"));
+  const i18n = JSON.parse(fs.readFileSync(i18nPath, 'utf8'));
   const keys = Object.keys(i18n);
 
   const used = {};
@@ -50,7 +50,7 @@ function processI18nFile(i18nPath, lang, allSource) {
 
   let checked = 0;
   const total = keys.length;
-  keys.forEach((key) => {
+  keys.forEach(key => {
     if (WHITELIST_KEYS.includes(key)) {
       used[key] = i18n[key];
     } else {
@@ -65,10 +65,8 @@ function processI18nFile(i18nPath, lang, allSource) {
     checked++;
     if (checked % 20 === 0 || checked === total) {
       const percent = ((checked / total) * 100).toFixed(1);
-      process.stdout.write(
-        `\r[${lang}] Progress: ${checked}/${total} (${percent}%)`,
-      );
-      if (checked === total) process.stdout.write("\n");
+      process.stdout.write(`\r[${lang}] Progress: ${checked}/${total} (${percent}%)`);
+      if (checked === total) process.stdout.write('\n');
     }
   });
 
@@ -76,27 +74,25 @@ function processI18nFile(i18nPath, lang, allSource) {
   console.log(`\n[${lang}] Unused keys:`, unused);
 
   // 备份原文件
-  const oldPath = i18nPath + ".old";
+  const oldPath = i18nPath + '.old';
   fs.renameSync(i18nPath, oldPath);
 
   // 写入精简后的 i18n 文件（保留原文件名）
-  fs.writeFileSync(i18nPath, JSON.stringify(used, null, 2), "utf8");
-  console.log(
-    `[${lang}] Cleaned i18n file written to src/locales/${path.basename(i18nPath)}`,
-  );
+  fs.writeFileSync(i18nPath, JSON.stringify(used, null, 2), 'utf8');
+  console.log(`[${lang}] Cleaned i18n file written to src/locales/${path.basename(i18nPath)}`);
   console.log(`[${lang}] Original file backed up as ${path.basename(oldPath)}`);
 }
 
 function main() {
   // 支持 zhtw.json、zh-tw.json、zh_CN.json 等
-  const files = fs
-    .readdirSync(LOCALES_DIR)
-    .filter((f) => /^[a-z0-9\-_]+\.json$/i.test(f) && !f.endsWith(".old"));
+  const files = fs.readdirSync(LOCALES_DIR).filter(f =>
+    /^[a-z0-9\-_]+\.json$/i.test(f) && !f.endsWith('.old')
+  );
   const allSource = getAllSourceContent();
-  files.forEach((file) => {
-    const lang = path.basename(file, ".json");
+  files.forEach(file => {
+    const lang = path.basename(file, '.json');
     processI18nFile(path.join(LOCALES_DIR, file), lang, allSource);
   });
 }
 
-main();
+main();

scripts/check.mjs

@@ -12,7 +12,7 @@ import { glob } from "glob";
 
 const cwd = process.cwd();
 const TEMP_DIR = path.join(cwd, "node_modules/.verge");
-const FORCE = process.argv.includes("--force") || process.argv.includes("-f");
+const FORCE = process.argv.includes("--force");
 
 const PLATFORM_MAP = {
   "x86_64-pc-windows-msvc": "win32",
@@ -43,8 +43,7 @@ const ARCH_MAP = {
 
 const arg1 = process.argv.slice(2)[0];
 const arg2 = process.argv.slice(2)[1];
-let target;
-target = arg1 === "--force" || arg1 === "-f" ? arg2 : arg1;
+const target = arg1 === "--force" ? arg2 : arg1;
 const { platform, arch } = target
   ? { platform: PLATFORM_MAP[target], arch: ARCH_MAP[target] }
   : process;
@@ -62,12 +61,12 @@ const META_ALPHA_URL_PREFIX = `https://github.com/MetaCubeX/mihomo/releases/down
 let META_ALPHA_VERSION;
 
 const META_ALPHA_MAP = {
-  "win32-x64": "mihomo-windows-amd64-v2",
+  "win32-x64": "mihomo-windows-amd64-compatible",
   "win32-ia32": "mihomo-windows-386",
   "win32-arm64": "mihomo-windows-arm64",
-  "darwin-x64": "mihomo-darwin-amd64-v1",
+  "darwin-x64": "mihomo-darwin-amd64-compatible",
   "darwin-arm64": "mihomo-darwin-arm64",
-  "linux-x64": "mihomo-linux-amd64-v2",
+  "linux-x64": "mihomo-linux-amd64-compatible",
   "linux-ia32": "mihomo-linux-386",
   "linux-arm64": "mihomo-linux-arm64",
   "linux-arm": "mihomo-linux-armv7",
@@ -109,12 +108,12 @@ const META_URL_PREFIX = `https://github.com/MetaCubeX/mihomo/releases/download`;
 let META_VERSION;
 
 const META_MAP = {
-  "win32-x64": "mihomo-windows-amd64-v2",
+  "win32-x64": "mihomo-windows-amd64-compatible",
   "win32-ia32": "mihomo-windows-386",
   "win32-arm64": "mihomo-windows-arm64",
-  "darwin-x64": "mihomo-darwin-amd64-v2",
+  "darwin-x64": "mihomo-darwin-amd64-compatible",
   "darwin-arm64": "mihomo-darwin-arm64",
-  "linux-x64": "mihomo-linux-amd64-v2",
+  "linux-x64": "mihomo-linux-amd64-compatible",
   "linux-ia32": "mihomo-linux-386",
   "linux-arm64": "mihomo-linux-arm64",
   "linux-arm": "mihomo-linux-armv7",

scripts/publish-version.mjs

@@ -38,9 +38,7 @@ async function run() {
   let tag = null;
   if (versionArg === "alpha") {
     // 读取 package.json 里的主版本
-    const pkg = await import(path.join(rootDir, "package.json"), {
-      assert: { type: "json" },
-    });
+    const pkg = await import(path.join(rootDir, "package.json"), { assert: { type: "json" } });
     tag = `v${pkg.default.version}-alpha`;
   } else if (isSemver(versionArg)) {
     // 1.2.3 或 v1.2.3
@@ -54,7 +52,7 @@ async function run() {
       execSync(`git tag ${tag}`, { stdio: "inherit" });
       execSync(`git push origin ${tag}`, { stdio: "inherit" });
       console.log(`[INFO]: Git tag ${tag} created and pushed.`);
-    } catch {
+    } catch (e) {
       console.error(`[ERROR]: Failed to create or push git tag: ${tag}`);
       process.exit(1);
     }
@@ -63,4 +61,4 @@ async function run() {
   }
 }
 
-run();
+run();

scripts/release-version.mjs

@@ -1,3 +1,5 @@
+
+
 /**
  * CLI tool to update version numbers in package.json, src-tauri/Cargo.toml, and src-tauri/tauri.conf.json.
  *
@@ -6,19 +8,15 @@
  *
  * <version> can be:
  *   - A full semver version (e.g., 1.2.3, v1.2.3, 1.2.3-beta, v1.2.3+build)
- *   - A tag: "alpha", "beta", "rc", "autobuild", "autobuild-latest", or "deploytest"
+ *   - A tag: "alpha", "beta", "rc", or "autobuild"
  *     - "alpha", "beta", "rc": Appends the tag to the current base version (e.g., 1.2.3-beta)
  *     - "autobuild": Appends a timestamped autobuild tag (e.g., 1.2.3+autobuild.2406101530)
- *     - "autobuild-latest": Appends an autobuild tag with latest Tauri commit (e.g., 1.2.3+autobuild.0614.a1b2c3d)
- *     - "deploytest": Appends a timestamped deploytest tag (e.g., 1.2.3+deploytest.2406101530)
  *
  * Examples:
  *   pnpm release-version 1.2.3
  *   pnpm release-version v1.2.3-beta
  *   pnpm release-version beta
  *   pnpm release-version autobuild
- *   pnpm release-version autobuild-latest
- *   pnpm release-version deploytest
  *
  * The script will:
  *   - Validate and normalize the version argument
@@ -29,68 +27,22 @@
  * Errors are logged and the process exits with code 1 on failure.
  */
 
-import { execSync } from "child_process";
-import { program } from "commander";
 import fs from "fs/promises";
 import path from "path";
+import { program } from "commander";
 
 /**
- * 获取当前 git 短 commit hash
+ * 生成短时间戳（格式：YYMMDDHHMM）
  * @returns {string}
  */
-function getGitShortCommit() {
-  try {
-    return execSync("git rev-parse --short HEAD").toString().trim();
-  } catch {
-    console.warn("[WARN]: Failed to get git short commit, fallback to 'nogit'");
-    return "nogit";
-  }
-}
-
-/**
- * 获取最新 Tauri 相关提交的短 hash
- * @returns {string}
- */
-function getLatestTauriCommit() {
-  try {
-    const fullHash = execSync(
-      "bash ./scripts-workflow/get_latest_tauri_commit.bash",
-    )
-      .toString()
-      .trim();
-    return execSync(`git rev-parse --short ${fullHash}`).toString().trim();
-  } catch {
-    console.warn(
-      "[WARN]: Failed to get latest Tauri commit, fallback to current git short commit",
-    );
-    return getGitShortCommit();
-  }
-}
-
-/**
- * 生成短时间戳（格式：MMDD）或带 commit（格式：MMDD.cc39b27）
- * 使用 Asia/Shanghai 时区
- * @param {boolean} withCommit 是否带 commit
- * @returns {string}
- */
-function generateShortTimestamp(withCommit = false) {
+function generateShortTimestamp() {
   const now = new Date();
-
-  const formatter = new Intl.DateTimeFormat("en-CA", {
-    timeZone: "Asia/Shanghai",
-    month: "2-digit",
-    day: "2-digit",
-  });
-
-  const parts = formatter.formatToParts(now);
-  const month = parts.find((part) => part.type === "month").value;
-  const day = parts.find((part) => part.type === "day").value;
-
-  if (withCommit) {
-    const gitShort = getGitShortCommit();
-    return `${month}${day}.${gitShort}`;
-  }
-  return `${month}${day}`;
+  const year = String(now.getFullYear()).slice(-2);
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  const hours = String(now.getHours()).padStart(2, "0");
+  const minutes = String(now.getMinutes()).padStart(2, "0");
+  return `${year}${month}${day}${hours}${minutes}`;
 }
 
 /**
@@ -99,9 +51,7 @@ function generateShortTimestamp(withCommit = false) {
  * @returns {boolean}
  */
 function isValidVersion(version) {
-  return /^v?\d+\.\d+\.\d+(-(alpha|beta|rc)(\.\d+)?)?(\+[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*)?$/i.test(
-    version,
-  );
+  return /^v?\d+\.\d+\.\d+(-(alpha|beta|rc)(\.\d+)?)?(\+[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*)?$/i.test(version);
 }
 
 /**
@@ -119,8 +69,8 @@ function normalizeVersion(version) {
  * @returns {string}
  */
 function getBaseVersion(version) {
-  let base = version.replace(/-(alpha|beta|rc)(\.\d+)?/i, "");
-  base = base.replace(/\+[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*/g, "");
+  let base = version.replace(/-(alpha|beta|rc)(\.\d+)?/i, '');
+  base = base.replace(/\+[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*/g, '');
   return base;
 }
 
@@ -135,21 +85,10 @@ async function updatePackageVersion(newVersion) {
     const data = await fs.readFile(packageJsonPath, "utf8");
     const packageJson = JSON.parse(data);
 
-    console.log(
-      "[INFO]: Current package.json version is: ",
-      packageJson.version,
-    );
-    packageJson.version = newVersion.startsWith("v")
-      ? newVersion.slice(1)
-      : newVersion;
-    await fs.writeFile(
-      packageJsonPath,
-      JSON.stringify(packageJson, null, 2),
-      "utf8",
-    );
-    console.log(
-      `[INFO]: package.json version updated to: ${packageJson.version}`,
-    );
+    console.log("[INFO]: Current package.json version is: ", packageJson.version);
+    packageJson.version = newVersion.startsWith("v") ? newVersion.slice(1) : newVersion;
+    await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2), "utf8");
+    console.log(`[INFO]: package.json version updated to: ${packageJson.version}`);
   } catch (error) {
     console.error("Error updating package.json version:", error);
     throw error;
@@ -166,22 +105,18 @@ async function updateCargoVersion(newVersion) {
   try {
     const data = await fs.readFile(cargoTomlPath, "utf8");
     const lines = data.split("\n");
-    const versionWithoutV = newVersion.startsWith("v")
-      ? newVersion.slice(1)
-      : newVersion;
+    const versionWithoutV = newVersion.startsWith("v") ? newVersion.slice(1) : newVersion;
+    const baseVersion = getBaseVersion(versionWithoutV);
 
     const updatedLines = lines.map((line) => {
       if (line.trim().startsWith("version =")) {
-        return line.replace(
-          /version\s*=\s*"[^"]+"/,
-          `version = "${versionWithoutV}"`,
-        );
+        return line.replace(/version\s*=\s*"[^"]+"/, `version = "${baseVersion}"`);
       }
       return line;
     });
 
     await fs.writeFile(cargoTomlPath, updatedLines.join("\n"), "utf8");
-    console.log(`[INFO]: Cargo.toml version updated to: ${versionWithoutV}`);
+    console.log(`[INFO]: Cargo.toml version updated to: ${baseVersion}`);
   } catch (error) {
     console.error("Error updating Cargo.toml version:", error);
     throw error;
@@ -198,26 +133,13 @@ async function updateTauriConfigVersion(newVersion) {
   try {
     const data = await fs.readFile(tauriConfigPath, "utf8");
     const tauriConfig = JSON.parse(data);
-    const versionWithoutV = newVersion.startsWith("v")
-      ? newVersion.slice(1)
-      : newVersion;
+    const versionWithoutV = newVersion.startsWith("v") ? newVersion.slice(1) : newVersion;
+    const baseVersion = getBaseVersion(versionWithoutV);
 
-    console.log(
-      "[INFO]: Current tauri.conf.json version is: ",
-      tauriConfig.version,
-    );
-
-    // 使用完整版本信息，包含build metadata
-    tauriConfig.version = versionWithoutV;
-
-    await fs.writeFile(
-      tauriConfigPath,
-      JSON.stringify(tauriConfig, null, 2),
-      "utf8",
-    );
-    console.log(
-      `[INFO]: tauri.conf.json version updated to: ${versionWithoutV}`,
-    );
+    console.log("[INFO]: Current tauri.conf.json version is: ", tauriConfig.version);
+    tauriConfig.version = baseVersion;
+    await fs.writeFile(tauriConfigPath, JSON.stringify(tauriConfig, null, 2), "utf8");
+    console.log(`[INFO]: tauri.conf.json version updated to: ${baseVersion}`);
   } catch (error) {
     console.error("Error updating tauri.conf.json version:", error);
     throw error;
@@ -251,29 +173,15 @@ async function main(versionArg) {
 
   try {
     let newVersion;
-    const validTags = [
-      "alpha",
-      "beta",
-      "rc",
-      "autobuild",
-      "autobuild-latest",
-      "deploytest",
-    ];
+    const validTags = ["alpha", "beta", "rc", "autobuild"];
 
     if (validTags.includes(versionArg.toLowerCase())) {
       const currentVersion = await getCurrentVersion();
       const baseVersion = getBaseVersion(currentVersion);
 
       if (versionArg.toLowerCase() === "autobuild") {
-        // 格式: 2.3.0+autobuild.250613.cc39b27
-        newVersion = `${baseVersion}+autobuild.${generateShortTimestamp(true)}`;
-      } else if (versionArg.toLowerCase() === "autobuild-latest") {
-        // 格式: 2.3.0+autobuild.0614.a1b2c3d (使用最新 Tauri 提交)
-        const latestTauriCommit = getLatestTauriCommit();
-        newVersion = `${baseVersion}+autobuild.${generateShortTimestamp()}.${latestTauriCommit}`;
-      } else if (versionArg.toLowerCase() === "deploytest") {
-        // 格式: 2.3.0+deploytest.250613.cc39b27
-        newVersion = `${baseVersion}+deploytest.${generateShortTimestamp(true)}`;
+        const timestamp = generateShortTimestamp();
+        newVersion = `${baseVersion}+autobuild.${timestamp}`;
       } else {
         newVersion = `${baseVersion}-${versionArg.toLowerCase()}`;
       }
@@ -302,3 +210,4 @@ program
   .argument("<version>", "version tag or full version")
   .action(main)
   .parse(process.argv);
+

scripts/telegram.mjs

@@ -1,110 +0,0 @@
-import axios from "axios";
-import { readFileSync } from "fs";
-import { log_success, log_error, log_info } from "./utils.mjs";
-
-const CHAT_ID_RELEASE = "@clash_verge_re"; // 正式发布频道
-const CHAT_ID_TEST = "@vergetest"; // 测试频道
-
-async function sendTelegramNotification() {
-  if (!process.env.TELEGRAM_BOT_TOKEN) {
-    throw new Error("TELEGRAM_BOT_TOKEN is required");
-  }
-
-  const version =
-    process.env.VERSION ||
-    (() => {
-      const pkg = readFileSync("package.json", "utf-8");
-      return JSON.parse(pkg).version;
-    })();
-
-  const downloadUrl =
-    process.env.DOWNLOAD_URL ||
-    `https://github.com/clash-verge-rev/clash-verge-rev/releases/download/v${version}`;
-
-  const isAutobuild =
-    process.env.BUILD_TYPE === "autobuild" || version.includes("autobuild");
-  const chatId = isAutobuild ? CHAT_ID_TEST : CHAT_ID_RELEASE;
-  const buildType = isAutobuild ? "滚动更新版" : "正式版";
-
-  log_info(`Preparing Telegram notification for ${buildType} ${version}`);
-  log_info(`Target channel: ${chatId}`);
-  log_info(`Download URL: ${downloadUrl}`);
-
-  // 读取发布说明和下载地址
-  let releaseContent = "";
-  try {
-    releaseContent = readFileSync("release.txt", "utf-8");
-    log_info("成功读取 release.txt 文件");
-  } catch (error) {
-    log_error("无法读取 release.txt，使用默认发布说明", error);
-    releaseContent = "更多新功能现已支持，详细更新日志请查看发布页面。";
-  }
-
-  // Markdown 转换为 HTML
-  function convertMarkdownToTelegramHTML(content) {
-    return content
-      .split("\n")
-      .map((line) => {
-        if (line.trim().length === 0) {
-          return "";
-        } else if (line.startsWith("## ")) {
-          return `<b>${line.replace("## ", "")}</b>`;
-        } else if (line.startsWith("### ")) {
-          return `<b>${line.replace("### ", "")}</b>`;
-        } else if (line.startsWith("#### ")) {
-          return `<b>${line.replace("#### ", "")}</b>`;
-        } else {
-          let processedLine = line.replace(
-            /\[([^\]]+)\]\(([^)]+)\)/g,
-            (match, text, url) => {
-              const encodedUrl = encodeURI(url);
-              return `<a href="${encodedUrl}">${text}</a>`;
-            },
-          );
-          processedLine = processedLine.replace(
-            /\*\*([^*]+)\*\*/g,
-            "<b>$1</b>",
-          );
-          return processedLine;
-        }
-      })
-      .join("\n");
-  }
-
-  const formattedContent = convertMarkdownToTelegramHTML(releaseContent);
-
-  const releaseTitle = isAutobuild ? "滚动更新版发布" : "正式发布";
-  const encodedVersion = encodeURIComponent(version);
-  const content = `<b>🎉 <a href="https://github.com/clash-verge-rev/clash-verge-rev/releases/tag/autobuild">Clash Verge Rev v${version}</a> ${releaseTitle}</b>\n\n${formattedContent}`;
-
-  // 发送到 Telegram
-  try {
-    await axios.post(
-      `https://api.telegram.org/bot${process.env.TELEGRAM_BOT_TOKEN}/sendMessage`,
-      {
-        chat_id: chatId,
-        text: content,
-        link_preview_options: {
-          is_disabled: false,
-          url: `https://github.com/clash-verge-rev/clash-verge-rev/releases/tag/v${encodedVersion}`,
-          prefer_large_media: true,
-        },
-        parse_mode: "HTML",
-      },
-    );
-    log_success(`✅ Telegram 通知发送成功到 ${chatId}`);
-  } catch (error) {
-    log_error(
-      `❌ Telegram 通知发送失败到 ${chatId}:`,
-      error.response?.data || error.message,
-      error,
-    );
-    process.exit(1);
-  }
-}
-
-// 执行函数
-sendTelegramNotification().catch((error) => {
-  log_error("脚本执行失败:", error);
-  process.exit(1);
-});

scripts/updatelog.mjs

@@ -8,7 +8,7 @@ const UPDATE_LOG = "UPDATELOG.md";
 export async function resolveUpdateLog(tag) {
   const cwd = process.cwd();
 
-  const reTitle = /^## v[\d.]+/;
+  const reTitle = /^## v[\d\.]+/;
   const reEnd = /^---/;
 
   const file = path.join(cwd, UPDATE_LOG);
@@ -54,7 +54,7 @@ export async function resolveUpdateLogDefault() {
 
   const data = await fsp.readFile(file, "utf-8");
 
-  const reTitle = /^## v[\d.]+/;
+  const reTitle = /^## v[\d\.]+/;
   const reEnd = /^---/;
 
   let isCapturing = false;

src-tauri/Cargo.toml

@@ -1,92 +1,85 @@
 [package]
 name = "clash-verge"
-version = "2.4.3"
+version = "2.3.0"
 description = "clash verge"
-authors = ["zzzgydi", "Tunglies", "wonfen", "MystiPanda"]
+authors = ["zzzgydi", "wonfen", "MystiPanda"]
 license = "GPL-3.0-only"
 repository = "https://github.com/clash-verge-rev/clash-verge-rev.git"
 default-run = "clash-verge"
-edition = "2024"
+edition = "2021"
 build = "build.rs"
 
 [package.metadata.bundle]
 identifier = "io.github.clash-verge-rev.clash-verge-rev"
 
 [build-dependencies]
-tauri-build = { version = "2.4.1", features = [] }
+tauri-build = { version = "2.2.0", features = [] }
 
 [dependencies]
-warp = { version = "0.4.2", features = ["server"] }
-anyhow = "1.0.99"
+warp = "0.3.7"
+anyhow = "1.0.98"
 dirs = "6.0"
 open = "5.3.2"
-log = "0.4.28"
+log = "0.4.27"
 dunce = "1.0.5"
+log4rs = "1.3.0"
 nanoid = "0.4"
-chrono = "0.4.42"
-sysinfo = { version = "0.37.0", features = ["network", "system"] }
+chrono = "0.4.41"
+sysinfo = "0.35.2"
 boa_engine = "0.20.0"
-serde_json = "1.0.145"
-serde_yaml_ng = "0.10.0"
+serde_json = "1.0.140"
+serde_yaml = "0.9.34-deprecated"
 once_cell = "1.21.3"
+lazy_static = "1.5.0"
 port_scanner = "0.1.5"
 delay_timer = "0.11.6"
 parking_lot = "0.12.4"
-percent-encoding = "2.3.2"
-tokio = { version = "1.47.1", features = [
+percent-encoding = "2.3.1"
+tokio = { version = "1.45.1", features = [
   "rt-multi-thread",
   "macros",
   "time",
   "sync",
 ] }
-serde = { version = "1.0.225", features = ["derive"] }
-reqwest = { version = "0.12.23", features = ["json", "cookies"] }
-regex = "1.11.2"
+serde = { version = "1.0.219", features = ["derive"] }
+reqwest = { version = "0.12.19", features = ["json", "rustls-tls", "cookies"] }
+regex = "1.11.1"
 sysproxy = { git = "https://github.com/clash-verge-rev/sysproxy-rs" }
-tauri = { version = "2.8.5", features = [
+image = "0.25.6"
+imageproc = "0.25.0"
+tauri = { version = "2.5.1", features = [
   "protocol-asset",
   "devtools",
   "tray-icon",
   "image-ico",
   "image-png",
 ] }
-network-interface = { version = "2.0.3", features = ["serde"] }
-tauri-plugin-shell = "2.3.1"
-tauri-plugin-dialog = "2.4.0"
-tauri-plugin-fs = "2.4.2"
-tauri-plugin-process = "2.3.0"
-tauri-plugin-clipboard-manager = "2.3.0"
-tauri-plugin-deep-link = "2.4.3"
-tauri-plugin-window-state = "2.4.0"
-zip = "5.1.1"
-reqwest_dav = "0.2.2"
+network-interface = { version = "2.0.1", features = ["serde"] }
+tauri-plugin-shell = "2.2.1"
+tauri-plugin-dialog = "2.2.2"
+tauri-plugin-fs = "2.3.0"
+tauri-plugin-process = "2.2.1"
+tauri-plugin-clipboard-manager = "2.2.2"
+tauri-plugin-deep-link = "2.3.0"
+tauri-plugin-devtools = "2.0.0"
+tauri-plugin-window-state = "2.2.2"
+zip = "4.0.0"
+reqwest_dav = "0.2.1"
 aes-gcm = { version = "0.10.3", features = ["std"] }
 base64 = "0.22.1"
 getrandom = "0.3.3"
+tokio-tungstenite = "0.26.2"
 futures = "0.3.31"
 sys-locale = "0.3.2"
-libc = "0.2.175"
+async-trait = "0.1.88"
+mihomo_api = { path = "src_crates/crate_mihomo_api" }
+ab_glyph = "0.2.29"
+tungstenite = "0.26.2"
+libc = "0.2.172"
 gethostname = "1.0.2"
 hmac = "0.12.1"
 sha2 = "0.10.9"
 hex = "0.4.3"
-scopeguard = "1.2.0"
-kode-bridge = "0.2.1"
-dashmap = "6.1.0"
-tauri-plugin-notification = "2.3.1"
-tokio-stream = "0.1.17"
-isahc = { version = "1.7.2", default-features = false, features = [
-  "text-decoding",
-  "parking_lot",
-] }
-backoff = { version = "0.4.0", features = ["tokio"] }
-tauri-plugin-http = "2"
-flexi_logger = "0.31.2"
-cfg-if = "1.0.3"
-nu-ansi-term = { version = "0.50.1", optional = true }
-console-subscriber = { version = "0.4.1", optional = true }
-tauri-plugin-devtools = { version = "2.0.1" }
-
 
 [target.'cfg(windows)'.dependencies]
 runas = "=1.2.0"
@@ -100,110 +93,55 @@ winapi = { version = "0.3.9", features = [
   "errhandlingapi",
   "minwindef",
   "winerror",
-  "tlhelp32",
-  "processthreadsapi",
-  "winhttp",
-  "winreg",
 ] }
 
 [target.'cfg(target_os = "linux")'.dependencies]
 users = "0.11.0"
 
 [target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies]
-tauri-plugin-autostart = "2.5.0"
-tauri-plugin-global-shortcut = "2.3.0"
-tauri-plugin-updater = "2.9.0"
+tauri-plugin-autostart = { git = "https://github.com/tauri-apps/plugins-workspace", branch = "v2" }
+tauri-plugin-global-shortcut = "2.2.1"
+tauri-plugin-updater = "2.7.1"
 
 [features]
 default = ["custom-protocol"]
 custom-protocol = ["tauri/custom-protocol"]
-verge-dev = ["nu-ansi-term"]
-tauri-dev = []
-tokio-trace = ["console-subscriber"]
+verge-dev = []
 
 [profile.release]
 panic = "abort"
-codegen-units = 16
+codegen-units = 1
 lto = true
-opt-level = 2
-debug = false
+opt-level = "s"
 strip = true
-overflow-checks = false
-rpath = false
 
 [profile.dev]
 incremental = true
-codegen-units = 64
-opt-level = 0
-debug = true
-strip = "none"
-overflow-checks = true
-lto = false
-rpath = false
+codegen-units = 256 # 增加编译单元，提升编译速度
+opt-level = 0       # 禁用优化，进一步提升编译速度
+debug = true        # 保留调试信息
+strip = false       # 不剥离符号，保留调试信息
 
 [profile.fast-release]
-inherits = "release"
-incremental = true
-codegen-units = 64
-lto = false
-opt-level = 0
-debug = true
-strip = false
+inherits = "release" # 继承 release 的配置
+panic = "abort"      # 与 release 相同
+codegen-units = 256  # 增加编译单元，提升编译速度
+lto = false          # 禁用 LTO，提升编译速度
+opt-level = 0        # 禁用优化，大幅提升编译速度
+debug = true         # 保留调试信息
+strip = false        # 不剥离符号，保留调试信息
 
 [lib]
 name = "app_lib"
 crate-type = ["staticlib", "cdylib", "rlib"]
 
 [dev-dependencies]
-criterion = "0.7.0"
+tempfile = "3.20.0"
 
-[lints.clippy]
-# Core categories - most important for code safety and correctness
-correctness = { level = "deny", priority = -1 }
-suspicious = { level = "deny", priority = -1 }
+[workspace]
+members = ["src_crates/crate_mihomo_api"]
 
-# Critical safety lints - warn for now due to extensive existing usage
-unwrap_used = "warn"
-expect_used = "warn"
-panic = "deny"
-unimplemented = "deny"
-
-# Development quality lints
-todo = "warn"
-dbg_macro = "warn"
-#print_stdout = "warn"
-#print_stderr = "warn"
-
-# Performance lints for proxy application
-clone_on_ref_ptr = "warn"
-rc_clone_in_vec_init = "warn"
-large_stack_arrays = "warn"
-large_const_arrays = "warn"
-
-# Security lints
-#integer_division = "warn"
-#lossy_float_literal = "warn"
-#default_numeric_fallback = "warn"
-
-# Mutex and async lints - strict control
-async_yields_async = "deny" # Prevents missing await in async blocks
-mutex_atomic = "deny"       # Use atomics instead of Mutex<bool/int>
-mutex_integer = "deny"      # Use AtomicInt instead of Mutex<int>
-rc_mutex = "deny"           # Single-threaded Rc with Mutex is wrong
-unused_async = "deny"       # Too many false positives in Tauri/framework code
-await_holding_lock = "deny"
-large_futures = "deny"
-future_not_send = "deny"
-
-# Common style improvements
-redundant_else = "deny"             # Too many in existing code
-needless_continue = "deny"          # Too many in existing code
-needless_raw_string_hashes = "deny" # Too many in existing code
-
-# Disable noisy categories for existing codebase but keep them available
-#style = { level = "allow", priority = -1 }
-#complexity = { level = "allow", priority = -1 }
-#perf = { level = "allow", priority = -1 }
-#pedantic = { level = "allow", priority = -1 }
-#nursery = { level = "allow", priority = -1 }
-#restriction = { level = "allow", priority = -1 }
+# [patch.crates-io]
+# bitflags = { git = "https://github.com/bitflags/bitflags", rev = "2.9.0" }
+# zerocopy = { git = "https://github.com/google/zerocopy", rev = "v0.8.24" }
+# tungstenite = { git = "https://github.com/snapview/tungstenite-rs", rev = "v0.26.2" }

src-tauri/benches/draft_benchmark.rs

@@ -1,91 +0,0 @@
-use criterion::{Criterion, criterion_group, criterion_main};
-use std::hint::black_box;
-
-// 业务模型 & Draft
-use app_lib::config::Draft as DraftNew;
-use app_lib::config::IVerge;
-
-// fn bench_apply_old(c: &mut Criterion) {
-//     c.bench_function("apply_draft_old", |b| {
-//         b.iter(|| {
-//             let verge = Box::new(IVerge {
-//                 enable_auto_launch: Some(true),
-//                 enable_tun_mode: Some(false),
-//                 ..Default::default()
-//             });
-
-//             let draft = DraftOld::from(black_box(verge));
-
-//             {
-//                 let mut d = draft.draft_mut();
-//                 d.enable_auto_launch = Some(false);
-//             }
-
-//             let _ = draft.apply();
-//         });
-//     });
-// }
-
-// fn bench_discard_old(c: &mut Criterion) {
-//     c.bench_function("discard_draft_old", |b| {
-//         b.iter(|| {
-//             let verge = Box::new(IVerge::default());
-//             let draft = DraftOld::from(black_box(verge));
-
-//             {
-//                 let mut d = draft.draft_mut();
-//                 d.enable_auto_launch = Some(false);
-//             }
-
-//             let _ = draft.discard();
-//         });
-//     });
-// }
-
-/// 基准：修改草稿并 apply()
-fn bench_apply_new(c: &mut Criterion) {
-    c.bench_function("apply_draft_new", |b| {
-        b.iter(|| {
-            let verge = Box::new(IVerge {
-                enable_auto_launch: Some(true),
-                enable_tun_mode: Some(false),
-                ..Default::default()
-            });
-
-            let draft = DraftNew::from(black_box(verge));
-
-            {
-                let mut d = draft.draft_mut();
-                d.enable_auto_launch = Some(false);
-            }
-
-            let _ = draft.apply();
-        });
-    });
-}
-
-/// 基准：修改草稿并 discard()
-fn bench_discard_new(c: &mut Criterion) {
-    c.bench_function("discard_draft_new", |b| {
-        b.iter(|| {
-            let verge = Box::new(IVerge::default());
-            let draft = DraftNew::from(black_box(verge));
-
-            {
-                let mut d = draft.draft_mut();
-                d.enable_auto_launch = Some(false);
-            }
-
-            let _ = draft.discard();
-        });
-    });
-}
-
-criterion_group!(
-    benches,
-    // bench_apply_old,
-    // bench_discard_old,
-    bench_apply_new,
-    bench_discard_new
-);
-criterion_main!(benches);

src-tauri/capabilities/desktop.json

@@ -17,13 +17,6 @@
     "autostart:allow-enable",
     "autostart:allow-disable",
     "autostart:allow-is-enabled",
-    "core:window:allow-set-theme",
-    "notification:default",
-    "http:default",
-    "http:allow-fetch",
-    {
-      "identifier": "http:default",
-      "allow": [{ "url": "https://*/*" }, { "url": "http://*/*" }]
-    }
+    "core:window:allow-set-theme"
   ]
 }

src-tauri/deny.toml

@@ -1,236 +0,0 @@
-# This template contains all of the possible sections and their default values
-
-# Note that all fields that take a lint level have these possible values:
-# * deny - An error will be produced and the check will fail
-# * warn - A warning will be produced, but the check will not fail
-# * allow - No warning or error will be produced, though in some cases a note
-# will be
-
-# The values provided in this template are the default values that will be used
-# when any section or field is not specified in your own configuration
-
-# Root options
-
-# The graph table configures how the dependency graph is constructed and thus
-# which crates the checks are performed against
-[graph]
-# If 1 or more target triples (and optionally, target_features) are specified,
-# only the specified targets will be checked when running `cargo deny check`.
-# This means, if a particular package is only ever used as a target specific
-# dependency, such as, for example, the `nix` crate only being used via the
-# `target_family = "unix"` configuration, that only having windows targets in
-# this list would mean the nix crate, as well as any of its exclusive
-# dependencies not shared by any other crates, would be ignored, as the target
-# list here is effectively saying which targets you are building for.
-targets = [
-    # The triple can be any string, but only the target triples built in to
-    # rustc (as of 1.40) can be checked against actual config expressions
-    #"x86_64-unknown-linux-musl",
-    # You can also specify which target_features you promise are enabled for a
-    # particular target. target_features are currently not validated against
-    # the actual valid features supported by the target architecture.
-    #{ triple = "wasm32-unknown-unknown", features = ["atomics"] },
-]
-# When creating the dependency graph used as the source of truth when checks are
-# executed, this field can be used to prune crates from the graph, removing them
-# from the view of cargo-deny. This is an extremely heavy hammer, as if a crate
-# is pruned from the graph, all of its dependencies will also be pruned unless
-# they are connected to another crate in the graph that hasn't been pruned,
-# so it should be used with care. The identifiers are [Package ID Specifications]
-# (https://doc.rust-lang.org/cargo/reference/pkgid-spec.html)
-#exclude = []
-# If true, metadata will be collected with `--all-features`. Note that this can't
-# be toggled off if true, if you want to conditionally enable `--all-features` it
-# is recommended to pass `--all-features` on the cmd line instead
-all-features = false
-# If true, metadata will be collected with `--no-default-features`. The same
-# caveat with `all-features` applies
-no-default-features = false
-# If set, these feature will be enabled when collecting metadata. If `--features`
-# is specified on the cmd line they will take precedence over this option.
-#features = []
-
-# The output table provides options for how/if diagnostics are outputted
-[output]
-# When outputting inclusion graphs in diagnostics that include features, this
-# option can be used to specify the depth at which feature edges will be added.
-# This option is included since the graphs can be quite large and the addition
-# of features from the crate(s) to all of the graph roots can be far too verbose.
-# This option can be overridden via `--feature-depth` on the cmd line
-feature-depth = 1
-
-# This section is considered when running `cargo deny check advisories`
-# More documentation for the advisories section can be found here:
-# https://embarkstudios.github.io/cargo-deny/checks/advisories/cfg.html
-[advisories]
-# The path where the advisory databases are cloned/fetched into
-#db-path = "$CARGO_HOME/advisory-dbs"
-# The url(s) of the advisory databases to use
-#db-urls = ["https://github.com/rustsec/advisory-db"]
-# A list of advisory IDs to ignore. Note that ignored advisories will still
-# output a note when they are encountered.
-ignore = [
-    #"RUSTSEC-0000-0000",
-    #{ id = "RUSTSEC-0000-0000", reason = "you can specify a reason the advisory is ignored" },
-    #"a-crate-that-is-yanked@0.1.1", # you can also ignore yanked crate versions if you wish
-    #{ crate = "a-crate-that-is-yanked@0.1.1", reason = "you can specify why you are ignoring the yanked crate" },
-    "RUSTSEC-2024-0415",
-]
-# If this is true, then cargo deny will use the git executable to fetch advisory database.
-# If this is false, then it uses a built-in git library.
-# Setting this to true can be helpful if you have special authentication requirements that cargo-deny does not support.
-# See Git Authentication for more information about setting up git authentication.
-#git-fetch-with-cli = true
-
-# This section is considered when running `cargo deny check licenses`
-# More documentation for the licenses section can be found here:
-# https://embarkstudios.github.io/cargo-deny/checks/licenses/cfg.html
-[licenses]
-# List of explicitly allowed licenses
-# See https://spdx.org/licenses/ for list of possible licenses
-# [possible values: any SPDX 3.11 short identifier (+ optional exception)].
-allow = [
-    #"MIT",
-    #"Apache-2.0",
-    #"Apache-2.0 WITH LLVM-exception",
-]
-# The confidence threshold for detecting a license from license text.
-# The higher the value, the more closely the license text must be to the
-# canonical license text of a valid SPDX license file.
-# [possible values: any between 0.0 and 1.0].
-confidence-threshold = 0.85
-# Allow 1 or more licenses on a per-crate basis, so that particular licenses
-# aren't accepted for every possible crate as with the normal allow list
-exceptions = [
-    # Each entry is the crate and version constraint, and its specific allow
-    # list
-    #{ allow = ["Zlib"], crate = "adler32" },
-]
-
-# Some crates don't have (easily) machine readable licensing information,
-# adding a clarification entry for it allows you to manually specify the
-# licensing information
-#[[licenses.clarify]]
-# The package spec the clarification applies to
-#crate = "ring"
-# The SPDX expression for the license requirements of the crate
-#expression = "MIT AND ISC AND OpenSSL"
-# One or more files in the crate's source used as the "source of truth" for
-# the license expression. If the contents match, the clarification will be used
-# when running the license check, otherwise the clarification will be ignored
-# and the crate will be checked normally, which may produce warnings or errors
-# depending on the rest of your configuration
-#license-files = [
-# Each entry is a crate relative path, and the (opaque) hash of its contents
-#{ path = "LICENSE", hash = 0xbd0eed23 }
-#]
-
-[licenses.private]
-# If true, ignores workspace crates that aren't published, or are only
-# published to private registries.
-# To see how to mark a crate as unpublished (to the official registry),
-# visit https://doc.rust-lang.org/cargo/reference/manifest.html#the-publish-field.
-ignore = false
-# One or more private registries that you might publish crates to, if a crate
-# is only published to private registries, and ignore is true, the crate will
-# not have its license(s) checked
-registries = [
-    #"https://sekretz.com/registry
-]
-
-# This section is considered when running `cargo deny check bans`.
-# More documentation about the 'bans' section can be found here:
-# https://embarkstudios.github.io/cargo-deny/checks/bans/cfg.html
-[bans]
-# Lint level for when multiple versions of the same crate are detected
-multiple-versions = "warn"
-# Lint level for when a crate version requirement is `*`
-wildcards = "allow"
-# The graph highlighting used when creating dotgraphs for crates
-# with multiple versions
-# * lowest-version - The path to the lowest versioned duplicate is highlighted
-# * simplest-path - The path to the version with the fewest edges is highlighted
-# * all - Both lowest-version and simplest-path are used
-highlight = "all"
-# The default lint level for `default` features for crates that are members of
-# the workspace that is being checked. This can be overridden by allowing/denying
-# `default` on a crate-by-crate basis if desired.
-workspace-default-features = "allow"
-# The default lint level for `default` features for external crates that are not
-# members of the workspace. This can be overridden by allowing/denying `default`
-# on a crate-by-crate basis if desired.
-external-default-features = "allow"
-# List of crates that are allowed. Use with care!
-allow = [
-    #"ansi_term@0.11.0",
-    #{ crate = "ansi_term@0.11.0", reason = "you can specify a reason it is allowed" },
-]
-# List of crates to deny
-deny = [
-    #"ansi_term@0.11.0",
-    #{ crate = "ansi_term@0.11.0", reason = "you can specify a reason it is banned" },
-    # Wrapper crates can optionally be specified to allow the crate when it
-    # is a direct dependency of the otherwise banned crate
-    #{ crate = "ansi_term@0.11.0", wrappers = ["this-crate-directly-depends-on-ansi_term"] },
-]
-
-# List of features to allow/deny
-# Each entry the name of a crate and a version range. If version is
-# not specified, all versions will be matched.
-#[[bans.features]]
-#crate = "reqwest"
-# Features to not allow
-#deny = ["json"]
-# Features to allow
-#allow = [
-#    "rustls",
-#    "__rustls",
-#    "__tls",
-#    "hyper-rustls",
-#    "rustls",
-#    "rustls-pemfile",
-#    "rustls-tls-webpki-roots",
-#    "tokio-rustls",
-#    "webpki-roots",
-#]
-# If true, the allowed features must exactly match the enabled feature set. If
-# this is set there is no point setting `deny`
-#exact = true
-
-# Certain crates/versions that will be skipped when doing duplicate detection.
-skip = [
-    #"ansi_term@0.11.0",
-    #{ crate = "ansi_term@0.11.0", reason = "you can specify a reason why it can't be updated/removed" },
-]
-# Similarly to `skip` allows you to skip certain crates during duplicate
-# detection. Unlike skip, it also includes the entire tree of transitive
-# dependencies starting at the specified crate, up to a certain depth, which is
-# by default infinite.
-skip-tree = [
-    #"ansi_term@0.11.0", # will be skipped along with _all_ of its direct and transitive dependencies
-    #{ crate = "ansi_term@0.11.0", depth = 20 },
-]
-
-# This section is considered when running `cargo deny check sources`.
-# More documentation about the 'sources' section can be found here:
-# https://embarkstudios.github.io/cargo-deny/checks/sources/cfg.html
-[sources]
-# Lint level for what to happen when a crate from a crate registry that is not
-# in the allow list is encountered
-unknown-registry = "warn"
-# Lint level for what to happen when a crate from a git repository that is not
-# in the allow list is encountered
-unknown-git = "warn"
-# List of URLs for allowed crate registries. Defaults to the crates.io index
-# if not specified. If it is specified but empty, no registries are allowed.
-allow-registry = ["https://github.com/rust-lang/crates.io-index"]
-# List of URLs for allowed Git repositories
-allow-git = []
-
-[sources.allow-org]
-# github.com organizations to allow git sources for
-github = []
-# gitlab.com organizations to allow git sources for
-gitlab = []
-# bitbucket.org organizations to allow git sources for
-bitbucket = []

src-tauri/packages/windows/installer.nsi

@@ -523,7 +523,7 @@ FunctionEnd
     ${If} $0 == 0
       Push $0
       ${If} $1 == 0
-            DetailPrint "Restart ${PRODUCTNAME} Service..."
+            DetailPrint "Restart Clash Verge Service..."
             SimpleSC::StartService "clash_verge_service" "" 30
       ${EndIf}
     ${ElseIf} $0 != 0
@@ -549,20 +549,20 @@ FunctionEnd
     ${If} $0 == 0
       Push $0
       ${If} $1 == 1
-        DetailPrint "Stop ${PRODUCTNAME} Service..."
+        DetailPrint "Stop Clash Verge Service..."
         SimpleSC::StopService "clash_verge_service" 1 30
         Pop $0 ; returns an errorcode (<>0) otherwise success (0)
         ${If} $0 == 0
-              DetailPrint "Removing ${PRODUCTNAME} Service..."
+              DetailPrint "Removing Clash Verge Service..."
               SimpleSC::RemoveService "clash_verge_service"
         ${ElseIf} $0 != 0
                   Push $0
                   SimpleSC::GetErrorMessage
                   Pop $0
-                  MessageBox MB_OK|MB_ICONSTOP "${PRODUCTNAME} Service Stop Error ($0)"
+                  MessageBox MB_OK|MB_ICONSTOP "Clash Verge Service Stop Error ($0)"
         ${EndIf}
   ${ElseIf} $1 == 0
-        DetailPrint "Removing ${PRODUCTNAME} Service..."
+        DetailPrint "Removing Clash Verge Service..."
         SimpleSC::RemoveService "clash_verge_service"
   ${EndIf}
     ${ElseIf} $0 != 0
@@ -661,7 +661,7 @@ SectionEnd
   Pop $R0
   ${If} $R0 = 0
       IfSilent kill 0
-      ${IfThen} $PassiveMode != 1 ${|} MessageBox MB_OKCANCEL "${PRODUCTNAME} 正在运行 $\n点击确定以终止运行" IDOK kill IDCANCEL cancel ${|}
+      ${IfThen} $PassiveMode != 1 ${|} MessageBox MB_OKCANCEL "$(appRunningOkKill)" IDOK kill IDCANCEL cancel ${|}
       kill:
         !if "${INSTALLMODE}" == "currentUser"
           nsis_tauri_utils::KillProcessCurrentUser "${MAINBINARYNAME}.exe"
@@ -691,6 +691,8 @@ SectionEnd
   app_check_done:
 !macroend
 
+
+
 Var VC_REDIST_URL
 Var VC_REDIST_EXE
 
@@ -699,25 +701,25 @@ Section CheckAndInstallVSRuntime
     ${If} ${IsNativeARM64}
         StrCpy $VC_REDIST_URL "https://aka.ms/vs/17/release/vc_redist.arm64.exe"
         StrCpy $VC_REDIST_EXE "vc_redist.arm64.exe"
-
+        
         ; 检查关键DLL
         IfFileExists "$SYSDIR\vcruntime140.dll" 0 checkInstall
         IfFileExists "$SYSDIR\msvcp140.dll" Done checkInstall
-
+        
     ${ElseIf} ${RunningX64}
         StrCpy $VC_REDIST_URL "https://aka.ms/vs/17/release/vc_redist.x64.exe"
         StrCpy $VC_REDIST_EXE "vc_redist.x64.exe"
-
+        
         ; 检查关键DLL
         IfFileExists "$SYSDIR\vcruntime140.dll" 0 checkInstall
         IfFileExists "$SYSDIR\msvcp140.dll" Done checkInstall
-
+        
     ${Else}
         StrCpy $VC_REDIST_URL "https://aka.ms/vs/17/release/vc_redist.x86.exe"
         StrCpy $VC_REDIST_EXE "vc_redist.x86.exe"
-
+        
         ; 检查关键DLL
-        IfFileExists "$SYSDIR\vcruntime140.dll" 0 checkInstall
+        IfFileExists "$SYSDIR\vcruntime140.dll" 0 checkInstall  
         IfFileExists "$SYSDIR\msvcp140.dll" Done checkInstall
     ${EndIf}
 
@@ -752,44 +754,30 @@ Section CheckAndInstallVSRuntime
     ${Else}
         DetailPrint "Visual C++ Redistributable 下载失败"
     ${EndIf}
-
+    
     Done:
 SectionEnd
 
+
+
 Section Install
   SetOutPath $INSTDIR
   nsExec::Exec 'netsh int tcp res'
   !insertmacro CheckIfAppIsRunning
   !insertmacro CheckAllVergeProcesses
 
-  ; 修复系统级启动文件夹
-  CreateDirectory "C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Startup"
-  DetailPrint "系统级启动文件夹已确保存在"
-
-  ; 修复用户级启动文件夹
-  SetShellVarContext current
-  StrCpy $0 "$SMPROGRAMS\Startup"
-  CreateDirectory "$0"
-  DetailPrint "已确保用户级启动文件夹存在: $0"
-
-  ; 删除 window-state.json 文件 .window-state.json 文件
-  DetailPrint "开始删除 window-state.json or .window-state.json"
-  SetShellVarContext current
-  Delete "$APPDATA\io.github.clash-verge-rev.clash-verge-rev\window-state.json"
-  Delete "$APPDATA\io.github.clash-verge-rev.clash-verge-rev\.window-state.json"
-
   ; 清理自启动注册表项
   DetailPrint "Cleaning auto-launch registry entries..."
 
   StrCpy $R1 "Software\Microsoft\Windows\CurrentVersion\Run"
-
-  SetRegView 64
+  
+  SetRegView 64  
   ; 清理旧版本的注册表项 (Clash Verge)
   ReadRegStr $R2 HKCU "$R1" "Clash Verge"
   ${If} $R2 != ""
     DeleteRegValue HKCU "$R1" "Clash Verge"
   ${EndIf}
-
+  
   ReadRegStr $R2 HKLM "$R1" "Clash Verge"
   ${If} $R2 != ""
     DeleteRegValue HKLM "$R1" "Clash Verge"
@@ -800,7 +788,7 @@ Section Install
   ${If} $R2 != ""
     DeleteRegValue HKCU "$R1" "clash-verge"
   ${EndIf}
-
+  
   ReadRegStr $R2 HKLM "$R1" "clash-verge"
   ${If} $R2 != ""
     DeleteRegValue HKLM "$R1" "clash-verge"
@@ -810,7 +798,7 @@ Section Install
     ; Delete clash-verge.desktop
   IfFileExists "$INSTDIR\Clash Verge.exe" 0 +2
     Delete "$INSTDIR\Clash Verge.exe"
-
+  
   ; Copy main executable
   File "${MAINBINARYSRCPATH}"
 
@@ -928,29 +916,26 @@ FunctionEnd
 !macroend
 
 Section Uninstall
+  ;删除 .window-state.json 文件
+  SetShellVarContext current
+  Delete "$APPDATA\io.github.clash-verge-rev.clash-verge-rev\.window-state.json"
 
   !insertmacro CheckIfAppIsRunning
   !insertmacro CheckAllVergeProcesses
   !insertmacro RemoveVergeService
 
-  ; 删除 window-state.json 文件 .window-state.json 文件
-  DetailPrint "开始删除 window-state.json or .window-state.json"
-  SetShellVarContext current
-  Delete "$APPDATA\io.github.clash-verge-rev.clash-verge-rev\window-state.json"
-  Delete "$APPDATA\io.github.clash-verge-rev.clash-verge-rev\.window-state.json"
-
   ; 清理自启动注册表项
   DetailPrint "Cleaning auto-launch registry entries..."
-
+  
   StrCpy $R1 "Software\Microsoft\Windows\CurrentVersion\Run"
-
+  
   SetRegView 64
   ; 清理旧版本的注册表项 (Clash Verge)
   ReadRegStr $R2 HKCU "$R1" "Clash Verge"
   ${If} $R2 != ""
     DeleteRegValue HKCU "$R1" "Clash Verge"
   ${EndIf}
-
+  
   ReadRegStr $R2 HKLM "$R1" "Clash Verge"
   ${If} $R2 != ""
     DeleteRegValue HKLM "$R1" "Clash Verge"
@@ -961,7 +946,7 @@ Section Uninstall
   ${If} $R2 != ""
     DeleteRegValue HKCU "$R1" "clash-verge"
   ${EndIf}
-
+  
   ReadRegStr $R2 HKLM "$R1" "clash-verge"
   ${If} $R2 != ""
     DeleteRegValue HKLM "$R1" "clash-verge"
@@ -993,146 +978,24 @@ Section Uninstall
   {{/each}}
   RMDir "$INSTDIR"
 
-  ; 删除固定栏
   !insertmacro DeleteAppUserModelId
   !insertmacro UnpinShortcut "$SMPROGRAMS\$AppStartMenuFolder\${PRODUCTNAME}.lnk"
   !insertmacro UnpinShortcut "$DESKTOP\${PRODUCTNAME}.lnk"
-  !insertmacro UnpinShortcut "$SMPROGRAMS\$AppStartMenuFolder\${MAINBINARYNAME}.lnk"
-  !insertmacro UnpinShortcut "$DESKTOP\${MAINBINARYNAME}.lnk"
+  ; 兼容旧名称快捷方式
+  !insertmacro UnpinShortcut "$SMPROGRAMS\$AppStartMenuFolder\clash-verge.lnk"
+  !insertmacro UnpinShortcut "$DESKTOP\clash-verge.lnk"
 
-  ; 删除所有用户的桌面快捷方式
-  DetailPrint "开始删除所有用户桌面的 ${PRODUCTNAME} 快捷方式..."
-
-  ; 删除公共桌面快捷方式
-  Delete "C:\Users\Public\Desktop\Clash Verge.lnk"
-  Delete "C:\Users\Public\Desktop\clash-verge.lnk"
-
-  ; 枚举所有用户配置文件目录
-  SetRegView 64
-  ReadRegStr $R0 HKLM "SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProfileList" ""
-
-  ; 初始化循环
-  StrCpy $R1 0
-  Loop:
-    EnumRegKey $R2 HKLM "SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProfileList" $R1
-    ${If} $R2 == ""
-      Goto Done
-    ${EndIf}
-
-    ; 读取用户配置文件路径
-    ReadRegStr $R3 HKLM "SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProfileList\$R2" "ProfileImagePath"
-    ${If} $R3 != ""
-      ; 构建用户桌面路径
-      StrCpy $R4 "$R3\Desktop"
-
-      ; 删除该用户桌面的快捷方式
-      Delete "$R4\Clash Verge.lnk"
-      Delete "$R4\clash-verge.lnk"
-
-      DetailPrint "尝试删除用户 '$R3' 桌面的 ${PRODUCTNAME} 快捷方式"
-    ${EndIf}
-
-    ; 递增循环计数器
-    IntOp $R1 $R1 + 1
-    Goto Loop
-  Done:
-
-  DetailPrint "所有用户桌面快捷方式删除完成"
-
-  ; 删除用户级开始菜单中的应用程序文件夹和快捷方式
-  DetailPrint "删除用户级开始菜单中的应用程序文件夹和快捷方式..."
-  RMDir /r /REBOOTOK "$SMPROGRAMS\Clash Verge"
-  RMDir /r /REBOOTOK "$SMPROGRAMS\clash-verge"
-  DetailPrint "删除用户级开始菜单中的应用程序文件夹和快捷方式完成"
-
-  ; 删除系统级开始菜单中的应用程序文件夹和快捷方式
-  DetailPrint "删除系统级开始菜单中的应用程序文件夹和快捷方式..."
-  RMDir /r /REBOOTOK "C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Clash Verge"
-  RMDir /r /REBOOTOK "C:\ProgramData\Microsoft\Windows\Start Menu\Programs\clash-verge"
-  DetailPrint "删除系统级开始菜单中的应用程序文件夹和快捷方式完成"
-
-  ; 删除所有带 Clash Verge 或 clash-verge 的注册表项
-  DetailPrint "开始清理所有 ${PRODUCTNAME} 相关的注册表项..."
-
-  ; 设置注册表查看模式 (64位)
-  SetRegView 64
-
-  ; 清理 CurrentVersion\Run 中的自启动项
-  StrCpy $R1 "Software\Microsoft\Windows\CurrentVersion\Run"
-  DeleteRegValue HKCU "$R1" "Clash Verge"
-  DeleteRegValue HKCU "$R1" "clash-verge"
-  DeleteRegValue HKLM "$R1" "Clash Verge"
-  DeleteRegValue HKLM "$R1" "clash-verge"
-
-  ; 清理 App Paths
-  DeleteRegKey HKLM "SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\Clash Verge.exe"
-  DeleteRegKey HKLM "SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\clash-verge.exe"
-
-  ; 删除指定的注册表路径
-  DeleteRegKey HKLM "Software\Clash Verge Rev"
-  DeleteRegKey HKCU "Software\Clash Verge Rev"
-  DeleteRegKey HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\ClashVerge"
-  DeleteRegKey HKCU "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\Clash Verge"
-
-  ; 清理 Uninstall 信息
-  StrCpy $R1 0
-  EnumUninstallLoop:
-    EnumRegKey $R2 HKLM "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall" $R1
-    ${If} $R2 == ""
-      Goto EnumUninstallDone
-    ${EndIf}
-
-    ReadRegStr $R3 HKLM "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\$R2" "DisplayName"
-    ${If} $R3 != ""
-      StrCmp $R3 "Clash Verge" 0 +3
-      StrCmp $R3 "clash-verge" 0 +2
-      DeleteRegKey HKLM "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\$R2"
-    ${EndIf}
-
-    IntOp $R1 $R1 + 1
-    Goto EnumUninstallLoop
-  EnumUninstallDone:
-
-  ; 清理用户特定的注册表项
-  StrCpy $R1 0
-  EnumHKCULoop:
-    EnumRegKey $R2 HKCU "SOFTWARE" $R1
-    ${If} $R2 == ""
-      Goto EnumHKCUDone
-    ${EndIf}
-
-    ReadRegStr $R3 HKCU "SOFTWARE\$R2" ""
-    ${If} $R3 != ""
-      StrCmp $R3 "Clash Verge" 0 +3
-      StrCmp $R3 "clash-verge" 0 +2
-      DeleteRegKey HKCU "SOFTWARE\$R2"
-    ${EndIf}
-
-    IntOp $R1 $R1 + 1
-    Goto EnumHKCULoop
-  EnumHKCUDone:
-
-  ; 清理系统范围的注册表项
-  StrCpy $R1 0
-  EnumHKLMLoop:
-    EnumRegKey $R2 HKLM "SOFTWARE" $R1
-    ${If} $R2 == ""
-      Goto EnumHKLMDone
-    ${EndIf}
-
-    ReadRegStr $R3 HKLM "SOFTWARE\$R2" ""
-    ${If} $R3 != ""
-      StrCmp $R3 "Clash Verge" 0 +3
-      StrCmp $R3 "clash-verge" 0 +2
-      DeleteRegKey HKLM "SOFTWARE\$R2"
-    ${EndIf}
-
-    IntOp $R1 $R1 + 1
-    Goto EnumHKLMLoop
-  EnumHKLMDone:
-
-  DetailPrint "注册表清理完成"
+  ; Remove start menu shortcut
+  !insertmacro MUI_STARTMENU_GETFOLDER Application $AppStartMenuFolder
+  Delete "$SMPROGRAMS\$AppStartMenuFolder\${PRODUCTNAME}.lnk"
+  ; 兼容旧名称快捷方式
+  Delete "$SMPROGRAMS\$AppStartMenuFolder\clash-verge.lnk"
+  RMDir "$SMPROGRAMS\$AppStartMenuFolder"
 
+  ; Remove desktop shortcuts
+  Delete "$DESKTOP\${PRODUCTNAME}.lnk"
+  ; 兼容旧名称快捷方式
+  Delete "$DESKTOP\clash-verge.lnk"
 
   ; Remove registry information for add/remove programs
   !if "${INSTALLMODE}" == "both"
@@ -1152,6 +1015,10 @@ Section Uninstall
     RmDir /r "$LOCALAPPDATA\${BUNDLEID}"
   ${EndIf}
 
+  ;删除 .window-state.json 文件
+  SetShellVarContext current
+  Delete "$APPDATA\io.github.clash-verge-rev.clash-verge-rev\.window-state.json"
+
   ${GetOptions} $CMDLINE "/P" $R0
   IfErrors +2 0
     SetAutoClose true
@@ -1184,6 +1051,7 @@ FunctionEnd
         System::Free $4
         System::Free $5
         ${IPropertyStore::Commit} $2 ""
+        ${IUnknown::Release} $2 ""
         ${IPersistFile::Save} $1 '("${shortcut}",1)'
       ${EndIf}
       ${IUnknown::Release} $1 ""

src-tauri/rustfmt.toml

@@ -11,3 +11,4 @@ merge_derives = true
 use_try_shorthand = false
 use_field_init_shorthand = false
 force_explicit_abi = true
+imports_granularity = "Crate"

src-tauri/src/cache/mod.rs

@@ -1,111 +0,0 @@
-use crate::singleton;
-use anyhow::Result;
-use dashmap::DashMap;
-use serde_json::Value;
-use std::sync::Arc;
-use std::time::{Duration, Instant};
-use tokio::sync::OnceCell;
-
-pub const SHORT_TERM_TTL: Duration = Duration::from_millis(4_250);
-
-pub struct CacheEntry<T> {
-    pub value: Arc<T>,
-    pub expires_at: Instant,
-}
-
-pub struct Cache<T> {
-    pub map: DashMap<String, Arc<OnceCell<Box<CacheEntry<T>>>>>,
-}
-
-impl<T> Cache<T> {
-    fn new() -> Self {
-        Cache {
-            map: DashMap::new(),
-        }
-    }
-
-    pub fn make_key(prefix: &str, id: &str) -> String {
-        format!("{prefix}:{id}")
-    }
-
-    pub async fn get_or_fetch<F, Fut>(&self, key: String, ttl: Duration, fetch_fn: F) -> Arc<T>
-    where
-        F: Fn() -> Fut + Send + Sync + 'static,
-        Fut: std::future::Future<Output = T> + Send + 'static,
-        T: Send + Sync + 'static,
-    {
-        loop {
-            let now = Instant::now();
-            let key_cloned = key.clone();
-
-            // Get or create the cell
-            let cell = self
-                .map
-                .entry(key_cloned.clone())
-                .or_insert_with(|| Arc::new(OnceCell::new()))
-                .clone();
-
-            // Check if we have a valid cached entry
-            if let Some(entry) = cell.get() {
-                if entry.expires_at > now {
-                    return Arc::clone(&entry.value);
-                }
-                // Entry is expired, remove it
-                self.map
-                    .remove_if(&key_cloned, |_, v| Arc::ptr_eq(v, &cell));
-                continue; // Retry with fresh cell
-            }
-
-            // Try to set a new value
-            let value = fetch_fn().await;
-            let entry = Box::new(CacheEntry {
-                value: Arc::new(value),
-                expires_at: Instant::now() + ttl,
-            });
-
-            match cell.set(entry) {
-                Ok(_) => {
-                    // Successfully set the value, it must exist now
-                    if let Some(set_entry) = cell.get() {
-                        return Arc::clone(&set_entry.value);
-                    }
-                }
-                Err(_) => {
-                    if let Some(existing_entry) = cell.get() {
-                        if existing_entry.expires_at > Instant::now() {
-                            return Arc::clone(&existing_entry.value);
-                        }
-                        self.map
-                            .remove_if(&key_cloned, |_, v| Arc::ptr_eq(v, &cell));
-                    }
-                }
-            }
-        }
-    }
-
-    // pub fn clean_key(&self, key: &str) {
-    //     self.map.remove(key);
-    // }
-
-    // TODO
-    pub fn clean_default_keys(&self) {
-        // logging!(info, Type::Cache, "Cleaning proxies keys");
-        // let proxies_key = Self::make_key("proxies", "default");
-        // self.map.remove(&proxies_key);
-
-        // logging!(info, Type::Cache, "Cleaning providers keys");
-        // let providers_key = Self::make_key("providers", "default");
-        // self.map.remove(&providers_key);
-
-        // !The frontend goes crash if we clean the clash_config cache
-        // logging!(info, Type::Cache, "Cleaning clash config keys");
-        // let clash_config_key = Self::make_key("clash_config", "default");
-        // self.map.remove(&clash_config_key);
-    }
-}
-
-pub type CacheService = Cache<Result<String>>;
-pub type CacheProxy = Cache<Value>;
-
-singleton!(Cache<Value>, PROXY_INSTANCE);
-singleton!(Cache<Result<String>>, SERVICE_INSTANCE);

src-tauri/src/cmd/app.rs

@@ -4,18 +4,18 @@ use crate::{
     utils::{dirs, logging::Type},
     wrap_err,
 };
-use tauri::{AppHandle, Manager};
+use tauri::Manager;
 
 /// 打开应用程序所在目录
 #[tauri::command]
-pub async fn open_app_dir() -> CmdResult<()> {
+pub fn open_app_dir() -> CmdResult<()> {
     let app_dir = wrap_err!(dirs::app_home_dir())?;
     wrap_err!(open::that(app_dir))
 }
 
 /// 打开核心所在目录
 #[tauri::command]
-pub async fn open_core_dir() -> CmdResult<()> {
+pub fn open_core_dir() -> CmdResult<()> {
     let core_dir = wrap_err!(tauri::utils::platform::current_exe())?;
     let core_dir = core_dir.parent().ok_or("failed to get core dir")?;
     wrap_err!(open::that(core_dir))
@@ -23,7 +23,7 @@ pub async fn open_core_dir() -> CmdResult<()> {
 
 /// 打开日志目录
 #[tauri::command]
-pub async fn open_logs_dir() -> CmdResult<()> {
+pub fn open_logs_dir() -> CmdResult<()> {
     let log_dir = wrap_err!(dirs::app_logs_dir())?;
     wrap_err!(open::that(log_dir))
 }
@@ -36,7 +36,7 @@ pub fn open_web_url(url: String) -> CmdResult<()> {
 
 /// 打开/关闭开发者工具
 #[tauri::command]
-pub fn open_devtools(app_handle: AppHandle) {
+pub fn open_devtools(app_handle: tauri::AppHandle) {
     if let Some(window) = app_handle.get_webview_window("main") {
         if !window.is_devtools_open() {
             window.open_devtools();
@@ -48,14 +48,14 @@ pub fn open_devtools(app_handle: AppHandle) {
 
 /// 退出应用
 #[tauri::command]
-pub async fn exit_app() {
-    feat::quit().await;
+pub fn exit_app() {
+    feat::quit();
 }
 
 /// 重启应用
 #[tauri::command]
 pub async fn restart_app() -> CmdResult<()> {
-    feat::restart_app().await;
+    feat::restart_app();
     Ok(())
 }
 
@@ -121,8 +121,9 @@ pub async fn download_icon_cache(url: String, name: String) -> CmdResult<String>
                 Err(_) => {
                     if icon_path.exists() {
                         return Ok(icon_path.to_string_lossy().to_string());
+                    } else {
+                        return Err("Failed to create temporary file".into());
                     }
-                    return Err("Failed to create temporary file".into());
                 }
             };
 
@@ -146,7 +147,7 @@ pub async fn download_icon_cache(url: String, name: String) -> CmdResult<String>
         Ok(icon_path.to_string_lossy().to_string())
     } else {
         let _ = std::fs::remove_file(&temp_path);
-        Err(format!("下载的内容不是有效图片: {url}"))
+        Err(format!("下载的内容不是有效图片: {}", url))
     }
 }
 
@@ -209,16 +210,16 @@ pub fn copy_icon_file(path: String, icon_info: IconInfo) -> CmdResult<String> {
 #[tauri::command]
 pub fn notify_ui_ready() -> CmdResult<()> {
     log::info!(target: "app", "前端UI已准备就绪");
-    crate::utils::resolve::ui::mark_ui_ready();
+    crate::utils::resolve::mark_ui_ready();
     Ok(())
 }
 
 /// UI加载阶段
 #[tauri::command]
 pub fn update_ui_stage(stage: String) -> CmdResult<()> {
-    log::info!(target: "app", "UI加载阶段更新: {stage}");
+    log::info!(target: "app", "UI加载阶段更新: {}", stage);
 
-    use crate::utils::resolve::ui::UiReadyStage;
+    use crate::utils::resolve::UiReadyStage;
 
     let stage_enum = match stage.as_str() {
         "NotStarted" => UiReadyStage::NotStarted,
@@ -227,11 +228,19 @@ pub fn update_ui_stage(stage: String) -> CmdResult<()> {
         "ResourcesLoaded" => UiReadyStage::ResourcesLoaded,
         "Ready" => UiReadyStage::Ready,
         _ => {
-            log::warn!(target: "app", "未知的UI加载阶段: {stage}");
-            return Err(format!("未知的UI加载阶段: {stage}"));
+            log::warn!(target: "app", "未知的UI加载阶段: {}", stage);
+            return Err(format!("未知的UI加载阶段: {}", stage));
         }
     };
 
-    crate::utils::resolve::ui::update_ui_ready_stage(stage_enum);
+    crate::utils::resolve::update_ui_ready_stage(stage_enum);
+    Ok(())
+}
+
+/// 重置UI就绪状态
+#[tauri::command]
+pub fn reset_ui_ready_state() -> CmdResult<()> {
+    log::info!(target: "app", "重置UI就绪状态");
+    crate::utils::resolve::reset_ui_ready();
     Ok(())
 }

src-tauri/src/cmd/clash.rs

@@ -1,33 +1,20 @@
 use super::CmdResult;
 use crate::{
-    cache::CacheProxy,
-    config::Config,
-    core::{CoreManager, handle},
+    config::*, core::*, feat, module::mihomo::MihomoManager, process::AsyncHandler, wrap_err,
 };
-use crate::{
-    config::*,
-    feat,
-    ipc::{self, IpcManager},
-    logging,
-    utils::logging::Type,
-    wrap_err,
-};
-use serde_yaml_ng::Mapping;
-use std::time::Duration;
-
-const CONFIG_REFRESH_INTERVAL: Duration = Duration::from_secs(60);
+use serde_yaml::Mapping;
 
 /// 复制Clash环境变量
 #[tauri::command]
-pub async fn copy_clash_env() -> CmdResult {
-    feat::copy_clash_env().await;
+pub fn copy_clash_env() -> CmdResult {
+    feat::copy_clash_env();
     Ok(())
 }
 
 /// 获取Clash信息
 #[tauri::command]
-pub async fn get_clash_info() -> CmdResult<ClashInfo> {
-    Ok(Config::clash().await.latest_ref().get_client_info())
+pub fn get_clash_info() -> CmdResult<ClashInfo> {
+    Ok(Config::clash().latest().get_client_info())
 }
 
 /// 修改Clash配置
@@ -39,14 +26,14 @@ pub async fn patch_clash_config(payload: Mapping) -> CmdResult {
 /// 修改Clash模式
 #[tauri::command]
 pub async fn patch_clash_mode(payload: String) -> CmdResult {
-    feat::change_clash_mode(payload).await;
+    feat::change_clash_mode(payload);
     Ok(())
 }
 
 /// 切换Clash核心
 #[tauri::command]
 pub async fn change_clash_core(clash_core: String) -> CmdResult<Option<String>> {
-    logging!(info, Type::Config, "changing core to {clash_core}");
+    log::info!(target: "app", "changing core to {clash_core}");
 
     match CoreManager::global()
         .change_core(Some(clash_core.clone()))
@@ -56,18 +43,14 @@ pub async fn change_clash_core(clash_core: String) -> CmdResult<Option<String>>
             // 切换内核后重启内核
             match CoreManager::global().restart_core().await {
                 Ok(_) => {
-                    logging!(
-                        info,
-                        Type::Core,
-                        "core changed and restarted to {clash_core}"
-                    );
+                    log::info!(target: "app", "core changed and restarted to {clash_core}");
                     handle::Handle::notice_message("config_core::change_success", &clash_core);
                     handle::Handle::refresh_clash();
                     Ok(None)
                 }
                 Err(err) => {
-                    let error_msg = format!("Core changed but failed to restart: {err}");
-                    logging!(error, Type::Core, "{error_msg}");
+                    let error_msg = format!("Core changed but failed to restart: {}", err);
+                    log::error!(target: "app", "{}", error_msg);
                     handle::Handle::notice_message("config_core::change_error", &error_msg);
                     Ok(Some(error_msg))
                 }
@@ -75,7 +58,7 @@ pub async fn change_clash_core(clash_core: String) -> CmdResult<Option<String>>
         }
         Err(err) => {
             let error_msg = err.to_string();
-            logging!(error, Type::Core, "failed to change core: {error_msg}");
+            log::error!(target: "app", "failed to change core: {error_msg}");
             handle::Handle::notice_message("config_core::change_error", &error_msg);
             Ok(Some(error_msg))
         }
@@ -85,31 +68,19 @@ pub async fn change_clash_core(clash_core: String) -> CmdResult<Option<String>>
 /// 启动核心
 #[tauri::command]
 pub async fn start_core() -> CmdResult {
-    let result = wrap_err!(CoreManager::global().start_core().await);
-    if result.is_ok() {
-        handle::Handle::refresh_clash();
-    }
-    result
+    wrap_err!(CoreManager::global().start_core().await)
 }
 
 /// 关闭核心
 #[tauri::command]
 pub async fn stop_core() -> CmdResult {
-    let result = wrap_err!(CoreManager::global().stop_core().await);
-    if result.is_ok() {
-        handle::Handle::refresh_clash();
-    }
-    result
+    wrap_err!(CoreManager::global().stop_core().await)
 }
 
 /// 重启核心
 #[tauri::command]
 pub async fn restart_core() -> CmdResult {
-    let result = wrap_err!(CoreManager::global().restart_core().await);
-    if result.is_ok() {
-        handle::Handle::refresh_clash();
-    }
-    result
+    wrap_err!(CoreManager::global().restart_core().await)
 }
 
 /// 获取代理延迟
@@ -119,32 +90,23 @@ pub async fn clash_api_get_proxy_delay(
     url: Option<String>,
     timeout: i32,
 ) -> CmdResult<serde_json::Value> {
-    wrap_err!(
-        IpcManager::global()
-            .test_proxy_delay(&name, url, timeout)
-            .await
-    )
+    MihomoManager::global()
+        .test_proxy_delay(&name, url, timeout)
+        .await
 }
 
 /// 测试URL延迟
 #[tauri::command]
 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);
-            10000u32
-        }
-    };
-    Ok(result)
+    Ok(feat::test_delay(url).await.unwrap_or(10000u32))
 }
 
 /// 保存DNS配置到单独文件
 #[tauri::command]
 pub async fn save_dns_config(dns_config: Mapping) -> CmdResult {
     use crate::utils::dirs;
-    use serde_yaml_ng;
-    use tokio::fs;
+    use serde_yaml;
+    use std::fs;
 
     // 获取DNS配置文件路径
     let dns_path = dirs::app_home_dir()
@@ -152,103 +114,104 @@ pub async fn save_dns_config(dns_config: Mapping) -> CmdResult {
         .join("dns_config.yaml");
 
     // 保存DNS配置到文件
-    let yaml_str = serde_yaml_ng::to_string(&dns_config).map_err(|e| e.to_string())?;
-    fs::write(&dns_path, yaml_str)
-        .await
-        .map_err(|e| e.to_string())?;
-    logging!(info, Type::Config, "DNS config saved to {dns_path:?}");
+    let yaml_str = serde_yaml::to_string(&dns_config).map_err(|e| e.to_string())?;
+    fs::write(&dns_path, yaml_str).map_err(|e| e.to_string())?;
+    log::info!(target: "app", "DNS config saved to {:?}", dns_path);
 
     Ok(())
 }
 
 /// 应用或撤销DNS配置
 #[tauri::command]
-pub async fn apply_dns_config(apply: bool) -> CmdResult {
+pub fn apply_dns_config(apply: bool) -> CmdResult {
     use crate::{
         config::Config,
-        core::{CoreManager, handle},
+        core::{handle, CoreManager},
         utils::dirs,
     };
 
-    if apply {
-        // 读取DNS配置文件
-        let dns_path = dirs::app_home_dir()
-            .map_err(|e| e.to_string())?
-            .join("dns_config.yaml");
+    // 使用spawn来处理异步操作
+    AsyncHandler::spawn(move || async move {
+        if apply {
+            // 读取DNS配置文件
+            let dns_path = match dirs::app_home_dir() {
+                Ok(path) => path.join("dns_config.yaml"),
+                Err(e) => {
+                    log::error!(target: "app", "Failed to get home dir: {}", e);
+                    return;
+                }
+            };
 
-        if !dns_path.exists() {
-            logging!(warn, Type::Config, "DNS config file not found");
-            return Err("DNS config file not found".into());
+            if !dns_path.exists() {
+                log::warn!(target: "app", "DNS config file not found");
+                return;
+            }
+
+            let dns_yaml = match std::fs::read_to_string(&dns_path) {
+                Ok(content) => content,
+                Err(e) => {
+                    log::error!(target: "app", "Failed to read DNS config: {}", e);
+                    return;
+                }
+            };
+
+            // 解析DNS配置并创建patch
+            let patch_config = match serde_yaml::from_str::<serde_yaml::Mapping>(&dns_yaml) {
+                Ok(config) => {
+                    let mut patch = serde_yaml::Mapping::new();
+                    patch.insert("dns".into(), config.into());
+                    patch
+                }
+                Err(e) => {
+                    log::error!(target: "app", "Failed to parse DNS config: {}", e);
+                    return;
+                }
+            };
+
+            log::info!(target: "app", "Applying DNS config from file");
+
+            // 重新生成配置，确保DNS配置被正确应用
+            // 这里不调用patch_clash以避免将DNS配置写入config.yaml
+            Config::runtime()
+                .latest()
+                .patch_config(patch_config.clone());
+
+            // 首先重新生成配置
+            if let Err(err) = Config::generate().await {
+                log::error!(target: "app", "Failed to regenerate config with DNS: {}", err);
+                return;
+            }
+
+            // 然后应用新配置
+            if let Err(err) = CoreManager::global().update_config().await {
+                log::error!(target: "app", "Failed to apply config with DNS: {}", err);
+            } else {
+                log::info!(target: "app", "DNS config successfully applied");
+                handle::Handle::refresh_clash();
+            }
+        } else {
+            // 当关闭DNS设置时，不需要对配置进行任何修改
+            // 直接重新生成配置，让enhance函数自动跳过DNS配置的加载
+            log::info!(target: "app", "DNS settings disabled, regenerating config");
+
+            // 重新生成配置
+            if let Err(err) = Config::generate().await {
+                log::error!(target: "app", "Failed to regenerate config: {}", err);
+                return;
+            }
+
+            // 应用新配置
+            match CoreManager::global().update_config().await {
+                Ok(_) => {
+                    log::info!(target: "app", "Config regenerated successfully");
+                    handle::Handle::refresh_clash();
+                }
+                Err(err) => {
+                    log::error!(target: "app", "Failed to apply regenerated config: {}", err);
+                }
+            }
         }
-
-        let dns_yaml = tokio::fs::read_to_string(&dns_path).await.map_err(|e| {
-            logging!(error, Type::Config, "Failed to read DNS config: {e}");
-            e.to_string()
-        })?;
-
-        // 解析DNS配置
-        let patch_config =
-            serde_yaml_ng::from_str::<serde_yaml_ng::Mapping>(&dns_yaml).map_err(|e| {
-                logging!(error, Type::Config, "Failed to parse DNS config: {e}");
-                e.to_string()
-            })?;
-
-        logging!(info, Type::Config, "Applying DNS config from file");
-
-        // 创建包含DNS配置的patch
-        let mut patch = serde_yaml_ng::Mapping::new();
-        patch.insert("dns".into(), patch_config.into());
-
-        // 应用DNS配置到运行时配置
-        Config::runtime().await.draft_mut().patch_config(patch);
-
-        // 重新生成配置
-        Config::generate().await.map_err(|err| {
-            logging!(
-                error,
-                Type::Config,
-                "Failed to regenerate config with DNS: {err}"
-            );
-            "Failed to regenerate config with DNS".to_string()
-        })?;
-
-        // 应用新配置
-        CoreManager::global().update_config().await.map_err(|err| {
-            logging!(
-                error,
-                Type::Config,
-                "Failed to apply config with DNS: {err}"
-            );
-            "Failed to apply config with DNS".to_string()
-        })?;
-
-        logging!(info, Type::Config, "DNS config successfully applied");
-        handle::Handle::refresh_clash();
-    } else {
-        // 当关闭DNS设置时，重新生成配置（不加载DNS配置文件）
-        logging!(
-            info,
-            Type::Config,
-            "DNS settings disabled, regenerating config"
-        );
-
-        Config::generate().await.map_err(|err| {
-            logging!(error, Type::Config, "Failed to regenerate config: {err}");
-            "Failed to regenerate config".to_string()
-        })?;
-
-        CoreManager::global().update_config().await.map_err(|err| {
-            logging!(
-                error,
-                Type::Config,
-                "Failed to apply regenerated config: {err}"
-            );
-            "Failed to apply regenerated config".to_string()
-        })?;
-
-        logging!(info, Type::Config, "Config regenerated successfully");
-        handle::Handle::refresh_clash();
-    }
+    });
 
     Ok(())
 }
@@ -269,19 +232,17 @@ pub fn check_dns_config_exists() -> CmdResult<bool> {
 #[tauri::command]
 pub async fn get_dns_config_content() -> CmdResult<String> {
     use crate::utils::dirs;
-    use tokio::fs;
+    use std::fs;
 
     let dns_path = dirs::app_home_dir()
         .map_err(|e| e.to_string())?
         .join("dns_config.yaml");
 
-    if !fs::try_exists(&dns_path).await.map_err(|e| e.to_string())? {
+    if !dns_path.exists() {
         return Err("DNS config file not found".into());
     }
 
-    let content = fs::read_to_string(&dns_path)
-        .await
-        .map_err(|e| e.to_string())?;
+    let content = fs::read_to_string(&dns_path).map_err(|e| e.to_string())?;
     Ok(content)
 }
 
@@ -306,318 +267,3 @@ pub async fn validate_dns_config() -> CmdResult<(bool, String)> {
         Err(e) => Err(e.to_string()),
     }
 }
-
-/// 获取Clash版本信息
-#[tauri::command]
-pub async fn get_clash_version() -> CmdResult<serde_json::Value> {
-    wrap_err!(IpcManager::global().get_version().await)
-}
-
-/// 获取Clash配置
-#[tauri::command]
-pub async fn get_clash_config() -> CmdResult<serde_json::Value> {
-    let manager = IpcManager::global();
-    let cache = CacheProxy::global();
-    let key = CacheProxy::make_key("clash_config", "default");
-    let value = cache
-        .get_or_fetch(key, CONFIG_REFRESH_INTERVAL, || async {
-            manager.get_config().await.unwrap_or_else(|e| {
-                logging!(error, Type::Cmd, "Failed to fetch clash config: {e}");
-                serde_json::Value::Object(serde_json::Map::new())
-            })
-        })
-        .await;
-    Ok((*value).clone())
-}
-
-/// 强制刷新Clash配置缓存
-#[tauri::command]
-pub async fn force_refresh_clash_config() -> CmdResult<serde_json::Value> {
-    let cache = CacheProxy::global();
-    let key = CacheProxy::make_key("clash_config", "default");
-    cache.map.remove(&key);
-    get_clash_config().await
-}
-
-/// 更新地理数据
-#[tauri::command]
-pub async fn update_geo_data() -> CmdResult {
-    wrap_err!(IpcManager::global().update_geo_data().await)
-}
-
-/// 升级Clash核心
-#[tauri::command]
-pub async fn upgrade_clash_core() -> CmdResult {
-    wrap_err!(IpcManager::global().upgrade_core().await)
-}
-
-/// 获取规则
-#[tauri::command]
-pub async fn get_clash_rules() -> CmdResult<serde_json::Value> {
-    wrap_err!(IpcManager::global().get_rules().await)
-}
-
-/// 更新代理选择
-#[tauri::command]
-pub async fn update_proxy_choice(group: String, proxy: String) -> CmdResult {
-    wrap_err!(IpcManager::global().update_proxy(&group, &proxy).await)
-}
-
-/// 获取代理提供者
-#[tauri::command]
-pub async fn get_proxy_providers() -> CmdResult<serde_json::Value> {
-    wrap_err!(IpcManager::global().get_providers_proxies().await)
-}
-
-/// 获取规则提供者
-#[tauri::command]
-pub async fn get_rule_providers() -> CmdResult<serde_json::Value> {
-    wrap_err!(IpcManager::global().get_rule_providers().await)
-}
-
-/// 代理提供者健康检查
-#[tauri::command]
-pub async fn proxy_provider_health_check(name: String) -> CmdResult {
-    wrap_err!(
-        IpcManager::global()
-            .proxy_provider_health_check(&name)
-            .await
-    )
-}
-
-/// 更新代理提供者
-#[tauri::command]
-pub async fn update_proxy_provider(name: String) -> CmdResult {
-    wrap_err!(IpcManager::global().update_proxy_provider(&name).await)
-}
-
-/// 更新规则提供者
-#[tauri::command]
-pub async fn update_rule_provider(name: String) -> CmdResult {
-    wrap_err!(IpcManager::global().update_rule_provider(&name).await)
-}
-
-/// 获取连接
-#[tauri::command]
-pub async fn get_clash_connections() -> CmdResult<serde_json::Value> {
-    wrap_err!(IpcManager::global().get_connections().await)
-}
-
-/// 删除连接
-#[tauri::command]
-pub async fn delete_clash_connection(id: String) -> CmdResult {
-    wrap_err!(IpcManager::global().delete_connection(&id).await)
-}
-
-/// 关闭所有连接
-#[tauri::command]
-pub async fn close_all_clash_connections() -> CmdResult {
-    wrap_err!(IpcManager::global().close_all_connections().await)
-}
-
-/// 获取流量数据 (使用新的IPC流式监控)
-#[tauri::command]
-pub async fn get_traffic_data() -> CmdResult<serde_json::Value> {
-    let traffic = crate::ipc::get_current_traffic().await;
-    let result = serde_json::json!({
-        "up": traffic.total_up,
-        "down": traffic.total_down,
-        "up_rate": traffic.up_rate,
-        "down_rate": traffic.down_rate,
-        "last_updated": traffic.last_updated.elapsed().as_secs()
-    });
-    Ok(result)
-}
-
-/// 获取内存数据 (使用新的IPC流式监控)
-#[tauri::command]
-pub async fn get_memory_data() -> CmdResult<serde_json::Value> {
-    let memory = crate::ipc::get_current_memory().await;
-    let usage_percent = if memory.oslimit > 0 {
-        (memory.inuse as f64 / memory.oslimit as f64) * 100.0
-    } else {
-        0.0
-    };
-    let result = serde_json::json!({
-        "inuse": memory.inuse,
-        "oslimit": memory.oslimit,
-        "usage_percent": usage_percent,
-        "last_updated": memory.last_updated.elapsed().as_secs()
-    });
-    Ok(result)
-}
-
-/// 启动流量监控服务 (IPC流式监控自动启动，此函数为兼容性保留)
-#[tauri::command]
-pub async fn start_traffic_service() -> CmdResult {
-    logging!(trace, Type::Ipc, "启动流量监控服务 (IPC流式监控)");
-    // 新的IPC监控在首次访问时自动启动
-    // 触发一次访问以确保监控器已初始化
-    let _ = crate::ipc::get_current_traffic().await;
-    let _ = crate::ipc::get_current_memory().await;
-    logging!(info, Type::Ipc, "IPC流式监控已激活");
-    Ok(())
-}
-
-/// 停止流量监控服务 (IPC流式监控无需显式停止，此函数为兼容性保留)
-#[tauri::command]
-pub async fn stop_traffic_service() -> CmdResult {
-    logging!(trace, Type::Ipc, "停止流量监控服务请求 (IPC流式监控)");
-    // 新的IPC监控是持久的，无需显式停止
-    logging!(info, Type::Ipc, "IPC流式监控继续运行");
-    Ok(())
-}
-
-/// 获取格式化的流量数据 (包含单位，便于前端显示)
-#[tauri::command]
-pub async fn get_formatted_traffic_data() -> CmdResult<serde_json::Value> {
-    logging!(trace, Type::Ipc, "获取格式化流量数据");
-    let (up_rate, down_rate, total_up, total_down, is_fresh) =
-        crate::ipc::get_formatted_traffic().await;
-    let result = serde_json::json!({
-        "up_rate_formatted": up_rate,
-        "down_rate_formatted": down_rate,
-        "total_up_formatted": total_up,
-        "total_down_formatted": total_down,
-        "is_fresh": is_fresh
-    });
-    logging!(
-        debug,
-        Type::Ipc,
-        "格式化流量数据: ↑{up_rate}/s ↓{down_rate}/s (总计: ↑{total_up} ↓{total_down})"
-    );
-    Ok(result)
-}
-
-/// 获取格式化的内存数据 (包含单位，便于前端显示)
-#[tauri::command]
-pub async fn get_formatted_memory_data() -> CmdResult<serde_json::Value> {
-    logging!(info, Type::Ipc, "获取格式化内存数据");
-    let (inuse, oslimit, usage_percent, is_fresh) = crate::ipc::get_formatted_memory().await;
-    let result = serde_json::json!({
-        "inuse_formatted": inuse,
-        "oslimit_formatted": oslimit,
-        "usage_percent": usage_percent,
-        "is_fresh": is_fresh
-    });
-    logging!(
-        debug,
-        Type::Ipc,
-        "格式化内存数据: {inuse} / {oslimit} ({usage_percent:.1}%)"
-    );
-    Ok(result)
-}
-
-/// 获取系统监控概览 (流量+内存，便于前端一次性获取所有状态)
-#[tauri::command]
-pub async fn get_system_monitor_overview() -> CmdResult<serde_json::Value> {
-    logging!(debug, Type::Ipc, "获取系统监控概览");
-
-    // 并发获取流量和内存数据
-    let (traffic, memory) = tokio::join!(
-        crate::ipc::get_current_traffic(),
-        crate::ipc::get_current_memory()
-    );
-
-    let (traffic_formatted, memory_formatted) = tokio::join!(
-        crate::ipc::get_formatted_traffic(),
-        crate::ipc::get_formatted_memory()
-    );
-
-    let traffic_is_fresh = traffic.last_updated.elapsed().as_secs() < 5;
-    let memory_is_fresh = memory.last_updated.elapsed().as_secs() < 10;
-
-    let result = serde_json::json!({
-        "traffic": {
-            "raw": {
-                "up": traffic.total_up,
-                "down": traffic.total_down,
-                "up_rate": traffic.up_rate,
-                "down_rate": traffic.down_rate
-            },
-            "formatted": {
-                "up_rate": traffic_formatted.0,
-                "down_rate": traffic_formatted.1,
-                "total_up": traffic_formatted.2,
-                "total_down": traffic_formatted.3
-            },
-            "is_fresh": traffic_is_fresh
-        },
-        "memory": {
-            "raw": {
-                "inuse": memory.inuse,
-                "oslimit": memory.oslimit,
-                "usage_percent": if memory.oslimit > 0 {
-                    (memory.inuse as f64 / memory.oslimit as f64) * 100.0
-                } else {
-                    0.0
-                }
-            },
-            "formatted": {
-                "inuse": memory_formatted.0,
-                "oslimit": memory_formatted.1,
-                "usage_percent": memory_formatted.2
-            },
-            "is_fresh": memory_is_fresh
-        },
-        "overall_status": if traffic_is_fresh && memory_is_fresh { "healthy" } else { "stale" }
-    });
-
-    Ok(result)
-}
-
-/// 获取代理组延迟
-#[tauri::command]
-pub async fn get_group_proxy_delays(
-    group_name: String,
-    url: Option<String>,
-    timeout: Option<i32>,
-) -> CmdResult<serde_json::Value> {
-    wrap_err!(
-        IpcManager::global()
-            .get_group_proxy_delays(&group_name, url, timeout.unwrap_or(10000))
-            .await
-    )
-}
-
-/// 检查调试是否启用
-#[tauri::command]
-pub async fn is_clash_debug_enabled() -> CmdResult<bool> {
-    match IpcManager::global().is_debug_enabled().await {
-        Ok(enabled) => Ok(enabled),
-        Err(_) => Ok(false),
-    }
-}
-
-/// 垃圾回收
-#[tauri::command]
-pub async fn clash_gc() -> CmdResult {
-    wrap_err!(IpcManager::global().gc().await)
-}
-
-/// 获取日志 (使用新的流式实现)
-#[tauri::command]
-pub async fn get_clash_logs() -> CmdResult<serde_json::Value> {
-    Ok(ipc::get_logs_json().await)
-}
-
-/// 启动日志监控
-#[tauri::command]
-pub async fn start_logs_monitoring(level: Option<String>) -> CmdResult {
-    ipc::start_logs_monitoring(level).await;
-    Ok(())
-}
-
-/// 停止日志监控
-#[tauri::command]
-pub async fn stop_logs_monitoring() -> CmdResult {
-    ipc::stop_logs_monitoring().await;
-    Ok(())
-}
-
-/// 清除日志
-#[tauri::command]
-pub async fn clear_logs() -> CmdResult {
-    ipc::clear_logs().await;
-    Ok(())
-}

src-tauri/src/cmd/lightweight.rs

@@ -4,12 +4,12 @@ use super::CmdResult;
 
 #[tauri::command]
 pub async fn entry_lightweight_mode() -> CmdResult {
-    lightweight::entry_lightweight_mode().await;
+    lightweight::entry_lightweight_mode();
     Ok(())
 }
 
 #[tauri::command]
 pub async fn exit_lightweight_mode() -> CmdResult {
-    lightweight::exit_lightweight_mode().await;
+    lightweight::exit_lightweight_mode();
     Ok(())
 }

src-tauri/src/cmd/media_unlock_checker.rs

@@ -1,4 +1,3 @@
-use crate::{logging, utils::logging::Type};
 use chrono::Local;
 use regex::Regex;
 use reqwest::Client;
@@ -38,7 +37,7 @@ fn country_code_to_emoji(country_code: &str) -> String {
     let c2 = 0x1F1E6 + (bytes[1] as u32) - ('A' as u32);
 
     char::from_u32(c1)
-        .and_then(|c1| char::from_u32(c2).map(|c2| format!("{c1}{c2}")))
+        .and_then(|c1| char::from_u32(c2).map(|c2| format!("{}{}", c1, c2)))
         .unwrap_or_default()
 }
 
@@ -164,7 +163,7 @@ async fn check_chatgpt_combined(client: &Client) -> Vec<UnlockItem> {
 
                 map.get("loc").map(|loc| {
                     let emoji = country_code_to_emoji(loc);
-                    format!("{emoji}{loc}")
+                    format!("{}{}", emoji, loc)
                 })
             } else {
                 None
@@ -251,28 +250,12 @@ async fn check_gemini(client: &Client) -> UnlockItem {
                 let status = if is_ok { "Yes" } else { "No" };
 
                 // 尝试提取国家代码
-                let re = match Regex::new(r#",2,1,200,"([A-Z]{3})""#) {
-                    Ok(re) => re,
-                    Err(e) => {
-                        logging!(
-                            error,
-                            Type::Network,
-                            "Failed to compile Gemini regex: {}",
-                            e
-                        );
-                        return UnlockItem {
-                            name: "Gemini".to_string(),
-                            status: "Failed".to_string(),
-                            region: None,
-                            check_time: Some(get_local_date_string()),
-                        };
-                    }
-                };
+                let re = Regex::new(r#",2,1,200,"([A-Z]{3})""#).unwrap();
                 let region = re.captures(&body).and_then(|caps| {
                     caps.get(1).map(|m| {
                         let country_code = m.as_str();
                         let emoji = country_code_to_emoji(country_code);
-                        format!("{emoji}{country_code}")
+                        format!("{}{}", emoji, country_code)
                     })
                 });
 
@@ -320,28 +303,12 @@ async fn check_youtube_premium(client: &Client) -> UnlockItem {
                     }
                 } else if body_lower.contains("ad-free") {
                     // 尝试解析国家代码
-                    let re = match Regex::new(r#"id="country-code"[^>]*>([^<]+)<"#) {
-                        Ok(re) => re,
-                        Err(e) => {
-                            logging!(
-                                error,
-                                Type::Network,
-                                "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 re = Regex::new(r#"id="country-code"[^>]*>([^<]+)<"#).unwrap();
                     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}")
+                            format!("{}{}", emoji, country_code)
                         })
                     });
 
@@ -383,16 +350,11 @@ async fn check_bahamut_anime(client: &Client) -> UnlockItem {
     let cookie_store = Arc::new(reqwest::cookie::Jar::default());
 
     // 使用带Cookie的客户端
-    let client_with_cookies = match reqwest::Client::builder()
+    let client_with_cookies = reqwest::Client::builder()
         .user_agent("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36")
         .cookie_provider(Arc::clone(&cookie_store))
-        .build() {
-        Ok(client) => client,
-        Err(e) => {
-            logging!(error, Type::Network, "Failed to create client with cookies for Bahamut Anime: {}", e);
-            client.clone()
-        }
-    };
+        .build()
+        .unwrap_or_else(|_| client.clone());
 
     // 第一步：获取设备ID (会自动保存Cookie)
     let device_url = "https://ani.gamer.com.tw/ajax/getdeviceid.php";
@@ -401,21 +363,10 @@ async fn check_bahamut_anime(client: &Client) -> UnlockItem {
             match response.text().await {
                 Ok(text) => {
                     // 使用正则提取deviceid
-                    match Regex::new(r#""deviceid"\s*:\s*"([^"]+)"#) {
-                        Ok(re) => re
-                            .captures(&text)
-                            .and_then(|caps| caps.get(1).map(|m| m.as_str().to_string()))
-                            .unwrap_or_default(),
-                        Err(e) => {
-                            logging!(
-                                error,
-                                Type::Network,
-                                "Failed to compile deviceid regex for Bahamut Anime: {}",
-                                e
-                            );
-                            String::new()
-                        }
-                    }
+                    let re = Regex::new(r#""deviceid"\s*:\s*"([^"]+)"#).unwrap();
+                    re.captures(&text)
+                        .and_then(|caps| caps.get(1).map(|m| m.as_str().to_string()))
+                        .unwrap_or_default()
                 }
                 Err(_) => String::new(),
             }
@@ -433,8 +384,10 @@ async fn check_bahamut_anime(client: &Client) -> UnlockItem {
     }
 
     // 第二步：使用设备ID检查访问权限 (使用相同的Cookie)
-    let url =
-        format!("https://ani.gamer.com.tw/ajax/token.php?adID=89422&sn=37783&device={device_id}");
+    let url = format!(
+        "https://ani.gamer.com.tw/ajax/token.php?adID=89422&sn=37783&device={}",
+        device_id
+    );
 
     let token_result = match client_with_cookies.get(&url).send().await {
         Ok(response) => {
@@ -470,25 +423,17 @@ async fn check_bahamut_anime(client: &Client) -> UnlockItem {
         .await
     {
         Ok(response) => match response.text().await {
-            Ok(body) => match Regex::new(r#"data-geo="([^"]+)"#) {
-                Ok(region_re) => region_re
+            Ok(body) => {
+                let region_re = Regex::new(r#"data-geo="([^"]+)"#).unwrap();
+                region_re
                     .captures(&body)
                     .and_then(|caps| caps.get(1))
                     .map(|m| {
                         let country_code = m.as_str();
                         let emoji = country_code_to_emoji(country_code);
-                        format!("{emoji}{country_code}")
-                    }),
-                Err(e) => {
-                    logging!(
-                        error,
-                        Type::Network,
-                        "Failed to compile region regex for Bahamut Anime: {}",
-                        e
-                    );
-                    None
-                }
-            },
+                        format!("{}{}", emoji, country_code)
+                    })
+            }
             Err(_) => None,
         },
         Err(_) => None,
@@ -525,7 +470,7 @@ async fn check_netflix(client: &Client) -> UnlockItem {
 
     // 检查连接失败情况
     if let Err(e) = &result1 {
-        eprintln!("Netflix请求错误: {e}");
+        eprintln!("Netflix请求错误: {}", e);
         return UnlockItem {
             name: "Netflix".to_string(),
             status: "Failed".to_string(),
@@ -542,7 +487,7 @@ async fn check_netflix(client: &Client) -> UnlockItem {
         .await;
 
     if let Err(e) = &result2 {
-        eprintln!("Netflix请求错误: {e}");
+        eprintln!("Netflix请求错误: {}", e);
         return UnlockItem {
             name: "Netflix".to_string(),
             status: "Failed".to_string(),
@@ -552,40 +497,8 @@ async fn check_netflix(client: &Client) -> UnlockItem {
     }
 
     // 获取状态码
-    let status1 = match result1 {
-        Ok(response) => response.status().as_u16(),
-        Err(e) => {
-            logging!(
-                error,
-                Type::Network,
-                "Failed to get Netflix response 1: {}",
-                e
-            );
-            return UnlockItem {
-                name: "Netflix".to_string(),
-                status: "Failed".to_string(),
-                region: None,
-                check_time: Some(get_local_date_string()),
-            };
-        }
-    };
-    let status2 = match result2 {
-        Ok(response) => response.status().as_u16(),
-        Err(e) => {
-            logging!(
-                error,
-                Type::Network,
-                "Failed to get Netflix response 2: {}",
-                e
-            );
-            return UnlockItem {
-                name: "Netflix".to_string(),
-                status: "Failed".to_string(),
-                region: None,
-                check_time: Some(get_local_date_string()),
-            };
-        }
-    };
+    let status1 = result1.unwrap().status().as_u16();
+    let status2 = result2.unwrap().status().as_u16();
 
     // 根据状态码判断解锁状况
     if status1 == 404 && status2 == 404 {
@@ -618,20 +531,20 @@ async fn check_netflix(client: &Client) -> UnlockItem {
         {
             Ok(response) => {
                 // 检查重定向位置
-                if let Some(location) = response.headers().get("location")
-                    && let Ok(location_str) = location.to_str()
-                {
-                    // 解析位置获取区域
-                    let parts: Vec<&str> = location_str.split('/').collect();
-                    if parts.len() >= 4 {
-                        let region_code = parts[3].split('-').next().unwrap_or("unknown");
-                        let emoji = country_code_to_emoji(region_code);
-                        return UnlockItem {
-                            name: "Netflix".to_string(),
-                            status: "Yes".to_string(),
-                            region: Some(format!("{emoji}{region_code}")),
-                            check_time: Some(get_local_date_string()),
-                        };
+                if let Some(location) = response.headers().get("location") {
+                    if let Ok(location_str) = location.to_str() {
+                        // 解析位置获取区域
+                        let parts: Vec<&str> = location_str.split('/').collect();
+                        if parts.len() >= 4 {
+                            let region_code = parts[3].split('-').next().unwrap_or("unknown");
+                            let emoji = country_code_to_emoji(region_code);
+                            return UnlockItem {
+                                name: "Netflix".to_string(),
+                                status: "Yes".to_string(),
+                                region: Some(format!("{}{}", emoji, region_code)),
+                                check_time: Some(get_local_date_string()),
+                            };
+                        }
                     }
                 }
                 // 如果没有重定向，假设是美国
@@ -644,7 +557,7 @@ async fn check_netflix(client: &Client) -> UnlockItem {
                 }
             }
             Err(e) => {
-                eprintln!("获取Netflix区域信息失败: {e}");
+                eprintln!("获取Netflix区域信息失败: {}", e);
                 UnlockItem {
                     name: "Netflix".to_string(),
                     status: "Yes (但无法获取区域)".to_string(),
@@ -657,7 +570,7 @@ async fn check_netflix(client: &Client) -> UnlockItem {
         // 其他未知错误状态
         UnlockItem {
             name: "Netflix".to_string(),
-            status: format!("Failed (状态码: {status1}_{status2}"),
+            status: format!("Failed (状态码: {}_{}", status1, status2),
             region: None,
             check_time: Some(get_local_date_string()),
         }
@@ -691,18 +604,22 @@ async fn check_netflix_cdn(client: &Client) -> UnlockItem {
             match response.json::<serde_json::Value>().await {
                 Ok(data) => {
                     // 尝试从数据中提取区域信息
-                    if let Some(targets) = data.get("targets").and_then(|t| t.as_array())
-                        && !targets.is_empty()
-                        && let Some(location) = targets[0].get("location")
-                        && let Some(country) = location.get("country").and_then(|c| c.as_str())
-                    {
-                        let emoji = country_code_to_emoji(country);
-                        return UnlockItem {
-                            name: "Netflix".to_string(),
-                            status: "Yes".to_string(),
-                            region: Some(format!("{emoji}{country}")),
-                            check_time: Some(get_local_date_string()),
-                        };
+                    if let Some(targets) = data.get("targets").and_then(|t| t.as_array()) {
+                        if !targets.is_empty() {
+                            if let Some(location) = targets[0].get("location") {
+                                if let Some(country) =
+                                    location.get("country").and_then(|c| c.as_str())
+                                {
+                                    let emoji = country_code_to_emoji(country);
+                                    return UnlockItem {
+                                        name: "Netflix".to_string(),
+                                        status: "Yes".to_string(),
+                                        region: Some(format!("{}{}", emoji, country)),
+                                        check_time: Some(get_local_date_string()),
+                                    };
+                                }
+                            }
+                        }
                     }
 
                     // 如果无法解析区域信息
@@ -714,7 +631,7 @@ async fn check_netflix_cdn(client: &Client) -> UnlockItem {
                     }
                 }
                 Err(e) => {
-                    eprintln!("解析Fast.com API响应失败: {e}");
+                    eprintln!("解析Fast.com API响应失败: {}", e);
                     UnlockItem {
                         name: "Netflix".to_string(),
                         status: "Failed (解析错误)".to_string(),
@@ -725,7 +642,7 @@ async fn check_netflix_cdn(client: &Client) -> UnlockItem {
             }
         }
         Err(e) => {
-            eprintln!("Fast.com API请求失败: {e}");
+            eprintln!("Fast.com API请求失败: {}", e);
             UnlockItem {
                 name: "Netflix".to_string(),
                 status: "Failed (CDN API)".to_string(),
@@ -770,23 +687,7 @@ async fn check_disney_plus(client: &Client) -> UnlockItem {
         };
     }
 
-    let device_response = match device_result {
-        Ok(response) => response,
-        Err(e) => {
-            logging!(
-                error,
-                Type::Network,
-                "Failed to get Disney+ device response: {}",
-                e
-            );
-            return UnlockItem {
-                name: "Disney+".to_string(),
-                status: "Failed (Network Connection)".to_string(),
-                region: None,
-                check_time: Some(get_local_date_string()),
-            };
-        }
-    };
+    let device_response = device_result.unwrap();
 
     // 检查是否 403 错误
     if device_response.status().as_u16() == 403 {
@@ -811,23 +712,7 @@ async fn check_disney_plus(client: &Client) -> UnlockItem {
     };
 
     // 提取 assertion
-    let re = match Regex::new(r#""assertion"\s*:\s*"([^"]+)"#) {
-        Ok(re) => re,
-        Err(e) => {
-            logging!(
-                error,
-                Type::Network,
-                "Failed to compile assertion regex for Disney+: {}",
-                e
-            );
-            return UnlockItem {
-                name: "Disney+".to_string(),
-                status: "Failed (Regex Error)".to_string(),
-                region: None,
-                check_time: Some(get_local_date_string()),
-            };
-        }
-    };
+    let re = Regex::new(r#""assertion"\s*:\s*"([^"]+)"#).unwrap();
     let assertion = match re.captures(&device_body) {
         Some(caps) => caps.get(1).map(|m| m.as_str().to_string()),
         None => None,
@@ -846,18 +731,7 @@ async fn check_disney_plus(client: &Client) -> UnlockItem {
     let token_url = "https://disney.api.edge.bamgrid.com/token";
 
     // 构建请求体 - 使用表单数据格式而非 JSON
-    let assertion_str = match assertion {
-        Some(assertion) => assertion,
-        None => {
-            logging!(error, Type::Network, "No assertion found for Disney+");
-            return UnlockItem {
-                name: "Disney+".to_string(),
-                status: "Failed (No Assertion)".to_string(),
-                region: None,
-                check_time: Some(get_local_date_string()),
-            };
-        }
-    };
+    let assertion_str = assertion.unwrap();
     let token_body = [
         (
             "grant_type",
@@ -890,23 +764,7 @@ async fn check_disney_plus(client: &Client) -> UnlockItem {
         };
     }
 
-    let token_response = match token_result {
-        Ok(response) => response,
-        Err(e) => {
-            logging!(
-                error,
-                Type::Network,
-                "Failed to get Disney+ token response: {}",
-                e
-            );
-            return UnlockItem {
-                name: "Disney+".to_string(),
-                status: "Failed (Network Connection)".to_string(),
-                region: None,
-                check_time: Some(get_local_date_string()),
-            };
-        }
-    };
+    let token_response = token_result.unwrap();
     let token_status = token_response.status();
 
     // 保存原始响应用于调试
@@ -942,20 +800,10 @@ async fn check_disney_plus(client: &Client) -> UnlockItem {
             .map(|s| s.to_string()),
         Err(_) => {
             // 如果 JSON 解析失败，尝试使用正则表达式
-            match Regex::new(r#""refresh_token"\s*:\s*"([^"]+)"#) {
-                Ok(refresh_token_re) => refresh_token_re
-                    .captures(&token_body_text)
-                    .and_then(|caps| caps.get(1).map(|m| m.as_str().to_string())),
-                Err(e) => {
-                    logging!(
-                        error,
-                        Type::Network,
-                        "Failed to compile refresh_token regex for Disney+: {}",
-                        e
-                    );
-                    None
-                }
-            }
+            let refresh_token_re = Regex::new(r#""refresh_token"\s*:\s*"([^"]+)"#).unwrap();
+            refresh_token_re
+                .captures(&token_body_text)
+                .and_then(|caps| caps.get(1).map(|m| m.as_str().to_string()))
         }
     };
 
@@ -979,7 +827,7 @@ async fn check_disney_plus(client: &Client) -> UnlockItem {
     // GraphQL API 通常接受 JSON 格式
     let graphql_payload = format!(
         r#"{{"query":"mutation refreshToken($input: RefreshTokenInput!) {{ refreshToken(refreshToken: $input) {{ activeSession {{ sessionId }} }} }}","variables":{{"input":{{"refreshToken":"{}"}}}}}}"#,
-        refresh_token.unwrap_or_default()
+        refresh_token.unwrap()
     );
 
     let graphql_result = client
@@ -1011,56 +859,21 @@ async fn check_disney_plus(client: &Client) -> UnlockItem {
     };
 
     // 解析 GraphQL 响应获取区域信息
-    let graphql_response = match graphql_result {
-        Ok(response) => response,
-        Err(e) => {
-            logging!(
-                error,
-                Type::Network,
-                "Failed to get Disney+ GraphQL response: {}",
-                e
-            );
-            return UnlockItem {
-                name: "Disney+".to_string(),
-                status: "Failed (Network Connection)".to_string(),
-                region: None,
-                check_time: Some(get_local_date_string()),
-            };
-        }
-    };
+    let graphql_response = graphql_result.unwrap();
     let graphql_status = graphql_response.status();
-    let graphql_body_text = match graphql_response.text().await {
-        Ok(text) => text,
-        Err(e) => {
-            logging!(
-                error,
-                Type::Network,
-                "Failed to read Disney+ GraphQL response text: {}",
-                e
-            );
-            String::new()
-        }
-    };
+    let graphql_body_text = (graphql_response.text().await).unwrap_or_default();
 
     // 如果 GraphQL 响应为空或明显错误，尝试直接获取区域信息
     if graphql_body_text.is_empty() || graphql_status.as_u16() >= 400 {
         // 尝试直接从主页获取区域信息
         let region_from_main = match client.get("https://www.disneyplus.com/").send().await {
             Ok(response) => match response.text().await {
-                Ok(body) => match Regex::new(r#"region"\s*:\s*"([^"]+)"#) {
-                    Ok(region_re) => region_re
+                Ok(body) => {
+                    let region_re = Regex::new(r#"region"\s*:\s*"([^"]+)"#).unwrap();
+                    region_re
                         .captures(&body)
-                        .and_then(|caps| caps.get(1).map(|m| m.as_str().to_string())),
-                    Err(e) => {
-                        logging!(
-                            error,
-                            Type::Network,
-                            "Failed to compile Disney+ main page region regex: {}",
-                            e
-                        );
-                        None
-                    }
-                },
+                        .and_then(|caps| caps.get(1).map(|m| m.as_str().to_string()))
+                }
                 Err(_) => None,
             },
             Err(_) => None,
@@ -1071,7 +884,7 @@ async fn check_disney_plus(client: &Client) -> UnlockItem {
             return UnlockItem {
                 name: "Disney+".to_string(),
                 status: "Yes".to_string(),
-                region: Some(format!("{emoji}{region} (from main page)")),
+                region: Some(format!("{}{} (from main page)", emoji, region)),
                 check_time: Some(get_local_date_string()),
             };
         }
@@ -1087,59 +900,28 @@ async fn check_disney_plus(client: &Client) -> UnlockItem {
                 region: None,
                 check_time: Some(get_local_date_string()),
             };
-        }
-        return UnlockItem {
-            name: "Disney+".to_string(),
-            status: format!(
-                "Failed (GraphQL error: {}, status: {})",
-                graphql_body_text.chars().take(50).collect::<String>() + "...",
-                graphql_status.as_u16()
-            ),
-            region: None,
-            check_time: Some(get_local_date_string()),
-        };
-    }
-
-    // 提取国家代码
-    let region_re = match Regex::new(r#""countryCode"\s*:\s*"([^"]+)"#) {
-        Ok(re) => re,
-        Err(e) => {
-            logging!(
-                error,
-                Type::Network,
-                "Failed to compile Disney+ countryCode regex: {}",
-                e
-            );
+        } else {
             return UnlockItem {
                 name: "Disney+".to_string(),
-                status: "Failed (Regex Error)".to_string(),
+                status: format!(
+                    "Failed (GraphQL error: {}, status: {})",
+                    graphql_body_text.chars().take(50).collect::<String>() + "...",
+                    graphql_status.as_u16()
+                ),
                 region: None,
                 check_time: Some(get_local_date_string()),
             };
         }
-    };
+    }
+
+    // 提取国家代码
+    let region_re = Regex::new(r#""countryCode"\s*:\s*"([^"]+)"#).unwrap();
     let region_code = region_re
         .captures(&graphql_body_text)
         .and_then(|caps| caps.get(1).map(|m| m.as_str().to_string()));
 
     // 提取支持状态
-    let supported_re = match Regex::new(r#""inSupportedLocation"\s*:\s*(false|true)"#) {
-        Ok(re) => re,
-        Err(e) => {
-            logging!(
-                error,
-                Type::Network,
-                "Failed to compile Disney+ supported location regex: {}",
-                e
-            );
-            return UnlockItem {
-                name: "Disney+".to_string(),
-                status: "Failed (Regex Error)".to_string(),
-                region: None,
-                check_time: Some(get_local_date_string()),
-            };
-        }
-    };
+    let supported_re = Regex::new(r#""inSupportedLocation"\s*:\s*(false|true)"#).unwrap();
     let in_supported_location = supported_re
         .captures(&graphql_body_text)
         .and_then(|caps| caps.get(1).map(|m| m.as_str() == "true"));
@@ -1149,20 +931,12 @@ async fn check_disney_plus(client: &Client) -> UnlockItem {
         // 尝试直接从主页获取区域信息
         let region_from_main = match client.get("https://www.disneyplus.com/").send().await {
             Ok(response) => match response.text().await {
-                Ok(body) => match Regex::new(r#"region"\s*:\s*"([^"]+)"#) {
-                    Ok(region_re) => region_re
+                Ok(body) => {
+                    let region_re = Regex::new(r#"region"\s*:\s*"([^"]+)"#).unwrap();
+                    region_re
                         .captures(&body)
-                        .and_then(|caps| caps.get(1).map(|m| m.as_str().to_string())),
-                    Err(e) => {
-                        logging!(
-                            error,
-                            Type::Network,
-                            "Failed to compile Disney+ main page region regex: {}",
-                            e
-                        );
-                        None
-                    }
-                },
+                        .and_then(|caps| caps.get(1).map(|m| m.as_str().to_string()))
+                }
                 Err(_) => None,
             },
             Err(_) => None,
@@ -1173,7 +947,7 @@ async fn check_disney_plus(client: &Client) -> UnlockItem {
             return UnlockItem {
                 name: "Disney+".to_string(),
                 status: "Yes".to_string(),
-                region: Some(format!("{emoji}{region} (from main page)")),
+                region: Some(format!("{}{} (from main page)", emoji, region)),
                 check_time: Some(get_local_date_string()),
             };
         }
@@ -1186,18 +960,7 @@ async fn check_disney_plus(client: &Client) -> UnlockItem {
         };
     }
 
-    let region = match region_code {
-        Some(code) => code,
-        None => {
-            logging!(error, Type::Network, "No region code found for Disney+");
-            return UnlockItem {
-                name: "Disney+".to_string(),
-                status: "No".to_string(),
-                region: None,
-                check_time: Some(get_local_date_string()),
-            };
-        }
-    };
+    let region = region_code.unwrap();
 
     // 判断日本地区
     if region == "JP" {
@@ -1205,7 +968,7 @@ async fn check_disney_plus(client: &Client) -> UnlockItem {
         return UnlockItem {
             name: "Disney+".to_string(),
             status: "Yes".to_string(),
-            region: Some(format!("{emoji}{region}")),
+            region: Some(format!("{}{}", emoji, region)),
             check_time: Some(get_local_date_string()),
         };
     }
@@ -1227,7 +990,7 @@ async fn check_disney_plus(client: &Client) -> UnlockItem {
             UnlockItem {
                 name: "Disney+".to_string(),
                 status: "Soon".to_string(),
-                region: Some(format!("{emoji}{region}（即将上线）")),
+                region: Some(format!("{}{}（即将上线）", emoji, region)),
                 check_time: Some(get_local_date_string()),
             }
         }
@@ -1236,13 +999,13 @@ async fn check_disney_plus(client: &Client) -> UnlockItem {
             UnlockItem {
                 name: "Disney+".to_string(),
                 status: "Yes".to_string(),
-                region: Some(format!("{emoji}{region}")),
+                region: Some(format!("{}{}", emoji, region)),
                 check_time: Some(get_local_date_string()),
             }
         }
         None => UnlockItem {
             name: "Disney+".to_string(),
-            status: format!("Failed (Error: Unknown region status for {region})"),
+            status: format!("Failed (Error: Unknown region status for {})", region),
             region: None,
             check_time: Some(get_local_date_string()),
         },
@@ -1267,47 +1030,13 @@ async fn check_prime_video(client: &Client) -> UnlockItem {
     }
 
     // 解析响应内容
-    let response = match result {
-        Ok(response) => response,
-        Err(e) => {
-            logging!(
-                error,
-                Type::Network,
-                "Failed to get Prime Video response: {}",
-                e
-            );
-            return UnlockItem {
-                name: "Prime Video".to_string(),
-                status: "Failed (Network Connection)".to_string(),
-                region: None,
-                check_time: Some(get_local_date_string()),
-            };
-        }
-    };
-
-    match response.text().await {
+    match result.unwrap().text().await {
         Ok(body) => {
             // 检查是否被地区限制
             let is_blocked = body.contains("isServiceRestricted");
 
             // 提取地区信息
-            let region_re = match Regex::new(r#""currentTerritory":"([^"]+)"#) {
-                Ok(re) => re,
-                Err(e) => {
-                    logging!(
-                        error,
-                        Type::Network,
-                        "Failed to compile Prime Video region regex: {}",
-                        e
-                    );
-                    return UnlockItem {
-                        name: "Prime Video".to_string(),
-                        status: "Failed (Regex Error)".to_string(),
-                        region: None,
-                        check_time: Some(get_local_date_string()),
-                    };
-                }
-            };
+            let region_re = Regex::new(r#""currentTerritory":"([^"]+)"#).unwrap();
             let region_code = region_re
                 .captures(&body)
                 .and_then(|caps| caps.get(1).map(|m| m.as_str().to_string()));
@@ -1327,7 +1056,7 @@ async fn check_prime_video(client: &Client) -> UnlockItem {
                 return UnlockItem {
                     name: "Prime Video".to_string(),
                     status: "Yes".to_string(),
-                    region: Some(format!("{emoji}{region}")),
+                    region: Some(format!("{}{}", emoji, region)),
                     check_time: Some(get_local_date_string()),
                 };
             }
@@ -1441,7 +1170,7 @@ pub async fn check_media_unlock() -> Result<Vec<UnlockItem>, String> {
         .connection_verbose(true) // 详细连接信息
         .build() {
         Ok(client) => client,
-        Err(e) => return Err(format!("创建HTTP客户端失败: {e}")),
+        Err(e) => return Err(format!("创建HTTP客户端失败: {}", e)),
     };
 
     // 创建共享的结果集
@@ -1455,8 +1184,8 @@ pub async fn check_media_unlock() -> Result<Vec<UnlockItem>, String> {
 
     // 添加哔哩哔哩大陆检测任务
     {
-        let client = Arc::clone(&client_arc);
-        let results = Arc::clone(&results);
+        let client = client_arc.clone();
+        let results = results.clone();
         tasks.spawn(async move {
             let result = check_bilibili_china_mainland(&client).await;
             let mut results = results.lock().await;
@@ -1466,8 +1195,8 @@ pub async fn check_media_unlock() -> Result<Vec<UnlockItem>, String> {
 
     // 添加哔哩哔哩港澳台检测任务
     {
-        let client = Arc::clone(&client_arc);
-        let results = Arc::clone(&results);
+        let client = client_arc.clone();
+        let results = results.clone();
         tasks.spawn(async move {
             let result = check_bilibili_hk_mc_tw(&client).await;
             let mut results = results.lock().await;
@@ -1477,8 +1206,8 @@ pub async fn check_media_unlock() -> Result<Vec<UnlockItem>, String> {
 
     // 添加合并的ChatGPT检测任务
     {
-        let client = Arc::clone(&client_arc);
-        let results = Arc::clone(&results);
+        let client = client_arc.clone();
+        let results = results.clone();
         tasks.spawn(async move {
             let chatgpt_results = check_chatgpt_combined(&client).await;
             let mut results = results.lock().await;
@@ -1488,8 +1217,8 @@ pub async fn check_media_unlock() -> Result<Vec<UnlockItem>, String> {
 
     // 添加Gemini检测任务
     {
-        let client = Arc::clone(&client_arc);
-        let results = Arc::clone(&results);
+        let client = client_arc.clone();
+        let results = results.clone();
         tasks.spawn(async move {
             let result = check_gemini(&client).await;
             let mut results = results.lock().await;
@@ -1499,8 +1228,8 @@ pub async fn check_media_unlock() -> Result<Vec<UnlockItem>, String> {
 
     // 添加YouTube Premium检测任务
     {
-        let client = Arc::clone(&client_arc);
-        let results = Arc::clone(&results);
+        let client = client_arc.clone();
+        let results = results.clone();
         tasks.spawn(async move {
             let result = check_youtube_premium(&client).await;
             let mut results = results.lock().await;
@@ -1510,8 +1239,8 @@ pub async fn check_media_unlock() -> Result<Vec<UnlockItem>, String> {
 
     // 添加动画疯检测任务
     {
-        let client = Arc::clone(&client_arc);
-        let results = Arc::clone(&results);
+        let client = client_arc.clone();
+        let results = results.clone();
         tasks.spawn(async move {
             let result = check_bahamut_anime(&client).await;
             let mut results = results.lock().await;
@@ -1521,8 +1250,8 @@ pub async fn check_media_unlock() -> Result<Vec<UnlockItem>, String> {
 
     // 添加 Netflix 检测任务
     {
-        let client = Arc::clone(&client_arc);
-        let results = Arc::clone(&results);
+        let client = client_arc.clone();
+        let results = results.clone();
         tasks.spawn(async move {
             let result = check_netflix(&client).await;
             let mut results = results.lock().await;
@@ -1532,8 +1261,8 @@ pub async fn check_media_unlock() -> Result<Vec<UnlockItem>, String> {
 
     // 添加 Disney+ 检测任务
     {
-        let client = Arc::clone(&client_arc);
-        let results = Arc::clone(&results);
+        let client = client_arc.clone();
+        let results = results.clone();
         tasks.spawn(async move {
             let result = check_disney_plus(&client).await;
             let mut results = results.lock().await;
@@ -1543,8 +1272,8 @@ pub async fn check_media_unlock() -> Result<Vec<UnlockItem>, String> {
 
     // 添加 Prime Video 检测任务
     {
-        let client = Arc::clone(&client_arc);
-        let results = Arc::clone(&results);
+        let client = client_arc.clone();
+        let results = results.clone();
         tasks.spawn(async move {
             let result = check_prime_video(&client).await;
             let mut results = results.lock().await;
@@ -1555,22 +1284,14 @@ pub async fn check_media_unlock() -> Result<Vec<UnlockItem>, String> {
     // 等待所有任务完成
     while let Some(res) = tasks.join_next().await {
         if let Err(e) = res {
-            eprintln!("任务执行失败: {e}");
+            eprintln!("任务执行失败: {}", e);
         }
     }
 
     // 获取所有结果
-    let results = match Arc::try_unwrap(results) {
-        Ok(mutex) => mutex.into_inner(),
-        Err(_) => {
-            logging!(
-                error,
-                Type::Network,
-                "Failed to unwrap results Arc, references still exist"
-            );
-            return Err("Failed to collect results".to_string());
-        }
-    };
+    let results = Arc::try_unwrap(results)
+        .expect("无法获取结果，可能仍有引用存在")
+        .into_inner();
 
     Ok(results)
 }

src-tauri/src/cmd/mod.rs

@@ -1,5 +1,6 @@
 use anyhow::Result;
 
+// Common result type used by command functions
 pub type CmdResult<T = ()> = Result<T, String>;
 
 // Command modules

src-tauri/src/cmd/network.rs

@@ -1,16 +1,17 @@
 use super::CmdResult;
-use crate::core::{EventDrivenProxyManager, async_proxy_query::AsyncProxyQuery};
-use crate::process::AsyncHandler;
 use crate::wrap_err;
 use network_interface::NetworkInterface;
-use serde_yaml_ng::Mapping;
+use serde_yaml::Mapping;
+use sysproxy::{Autoproxy, Sysproxy};
+use tokio::task::spawn_blocking;
 
 /// get the system proxy
 #[tauri::command]
 pub async fn get_sys_proxy() -> CmdResult<Mapping> {
-    log::debug!(target: "app", "异步获取系统代理配置");
-
-    let current = AsyncProxyQuery::get_system_proxy().await;
+    let current = spawn_blocking(Sysproxy::get_system_proxy)
+        .await
+        .map_err(|e| format!("Failed to spawn blocking task for sysproxy: {}", e))?
+        .map_err(|e| format!("Failed to get system proxy: {}", e))?;
 
     let mut map = Mapping::new();
     map.insert("enable".into(), current.enable.into());
@@ -20,28 +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);
     Ok(map)
 }
 
-/// 获取自动代理配置
+/// get the system proxy
 #[tauri::command]
 pub async fn get_auto_proxy() -> CmdResult<Mapping> {
-    log::debug!(target: "app", "开始获取自动代理配置（事件驱动）");
-
-    let proxy_manager = EventDrivenProxyManager::global();
-
-    let current = proxy_manager.get_auto_proxy_cached().await;
-    // 异步请求更新，立即返回缓存数据
-    AsyncHandler::spawn(move || async move {
-        let _ = proxy_manager.get_auto_proxy_async().await;
-    });
+    let current = spawn_blocking(Autoproxy::get_auto_proxy)
+        .await
+        .map_err(|e| format!("Failed to spawn blocking task for autoproxy: {}", e))?
+        .map_err(|e| format!("Failed to get auto proxy: {}", e))?;
 
     let mut map = Mapping::new();
     map.insert("enable".into(), current.enable.into());
-    map.insert("url".into(), current.url.clone().into());
+    map.insert("url".into(), current.url.into());
 
-    log::debug!(target: "app", "返回自动代理配置（缓存）: enable={}, url={}", current.enable, current.url);
     Ok(map)
 }
 
@@ -55,7 +49,7 @@ pub fn get_system_hostname() -> CmdResult<String> {
         Ok(name) => name,
         Err(os_string) => {
             // 对于包含非UTF-8的主机名，使用调试格式化
-            let fallback = format!("{os_string:?}");
+            let fallback = format!("{:?}", os_string);
             // 去掉可能存在的引号
             fallback.trim_matches('"').to_string()
         }

src-tauri/src/cmd/profile.rs

@@ -1,99 +1,64 @@
 use super::CmdResult;
 use crate::{
-    config::{
-        Config, IProfiles, PrfItem, PrfOption,
-        profiles::{
-            profiles_append_item_with_filedata_safe, profiles_delete_item_safe,
-            profiles_patch_item_safe, profiles_reorder_safe, profiles_save_file_safe,
-        },
-        profiles_append_item_safe,
-    },
-    core::{CoreManager, handle, timer::Timer, tray::Tray},
-    feat, logging,
-    process::AsyncHandler,
-    ret_err,
+    config::{Config, IProfiles, PrfItem, PrfOption},
+    core::{handle, timer::Timer, tray::Tray, CoreManager},
+    feat, logging, ret_err,
     utils::{dirs, help, logging::Type},
     wrap_err,
 };
-use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use std::time::Duration;
+use tokio::sync::Mutex;
 
-// 全局请求序列号跟踪，用于避免队列化执行
-static CURRENT_REQUEST_SEQUENCE: AtomicU64 = AtomicU64::new(0);
-
-static CURRENT_SWITCHING_PROFILE: AtomicBool = AtomicBool::new(false);
+// 添加全局互斥锁防止并发配置更新
+static PROFILE_UPDATE_MUTEX: Mutex<()> = Mutex::const_new(());
 
+/// 获取配置文件列表
 #[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(),
-        }
-    })
+    let profiles_result = tokio::time::timeout(
+        Duration::from_secs(3), // 3秒超时
+        tokio::task::spawn_blocking(move || Config::profiles().data().clone()),
+    )
     .await;
 
-    match latest_result {
-        Ok(profiles) => {
-            logging!(info, Type::Cmd, false, "快速获取配置列表成功");
-            return Ok(profiles);
+    match profiles_result {
+        Ok(Ok(profiles)) => Ok(profiles),
+        Ok(Err(join_err)) => {
+            logging!(error, Type::Cmd, true, "获取配置列表任务失败: {}", join_err);
+            Ok(IProfiles {
+                current: None,
+                items: Some(vec![]),
+            })
         }
         Err(_) => {
-            logging!(warn, Type::Cmd, true, "快速获取配置超时(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, false, "获取draft配置列表成功");
-            return Ok(profiles);
-        }
-        Err(join_err) => {
+            // 超时情况
             logging!(
                 error,
                 Type::Cmd,
                 true,
-                "获取draft配置任务失败或超时: {}",
-                join_err
+                "获取配置列表超时(3秒)，可能存在锁竞争"
             );
+            match tokio::task::spawn_blocking(move || Config::profiles().latest().clone()).await {
+                Ok(profiles) => {
+                    logging!(info, Type::Cmd, true, "使用latest()成功获取配置");
+                    Ok(profiles)
+                }
+                Err(_) => {
+                    logging!(error, Type::Cmd, true, "fallback获取配置也失败，返回空配置");
+                    Ok(IProfiles {
+                        current: None,
+                        items: Some(vec![]),
+                    })
+                }
+            }
         }
     }
-
-    // 策略3: fallback，尝试重新创建配置
-    logging!(
-        warn,
-        Type::Cmd,
-        true,
-        "所有获取配置策略都失败，尝试fallback"
-    );
-
-    Ok(IProfiles::new().await)
 }
 
 /// 增强配置文件
 #[tauri::command]
 pub async fn enhance_profiles() -> CmdResult {
-    match feat::enhance_profiles().await {
-        Ok(_) => {}
-        Err(e) => {
-            log::error!(target: "app", "{}", e);
-            return Err(e.to_string());
-        }
-    }
+    wrap_err!(feat::enhance_profiles().await)?;
     handle::Handle::refresh_clash();
     Ok(())
 }
@@ -101,152 +66,36 @@ pub async fn enhance_profiles() -> CmdResult {
 /// 导入配置文件
 #[tauri::command]
 pub async fn import_profile(url: String, option: Option<PrfOption>) -> CmdResult {
-    logging!(info, Type::Cmd, true, "[导入订阅] 开始导入: {}", url);
-
-    let import_result = tokio::time::timeout(Duration::from_secs(60), async {
-        let item = PrfItem::from_url(&url, None, None, option).await?;
-        logging!(info, Type::Cmd, true, "[导入订阅] 下载完成，开始保存配置");
-
-        let profiles = Config::profiles().await;
-        let pre_count = profiles
-            .latest_ref()
-            .items
-            .as_ref()
-            .map_or(0, |items| items.len());
-
-        let result = profiles_append_item_safe(item.clone()).await;
-        result?;
-
-        let post_count = profiles
-            .latest_ref()
-            .items
-            .as_ref()
-            .map_or(0, |items| items.len());
-        if post_count <= pre_count {
-            logging!(
-                error,
-                Type::Cmd,
-                true,
-                "[导入订阅] 配置未增加，导入可能失败"
-            );
-            return Err(anyhow::anyhow!("配置导入后数量未增加"));
-        }
-
-        logging!(
-            info,
-            Type::Cmd,
-            true,
-            "[导入订阅] 配置保存成功，数量: {} -> {}",
-            pre_count,
-            post_count
-        );
-
-        // 立即发送配置变更通知
-        if let Some(uid) = &item.uid {
-            logging!(
-                info,
-                Type::Cmd,
-                true,
-                "[导入订阅] 发送配置变更通知: {}",
-                uid
-            );
-            handle::Handle::notify_profile_changed(uid.clone());
-        }
-
-        // 异步保存配置文件并发送全局通知
-        let uid_clone = item.uid.clone();
-        crate::process::AsyncHandler::spawn(move || async move {
-            // 使用Send-safe helper函数
-            if let Err(e) = profiles_save_file_safe().await {
-                logging!(error, Type::Cmd, true, "[导入订阅] 保存配置文件失败: {}", e);
-            } else {
-                logging!(info, Type::Cmd, true, "[导入订阅] 配置文件保存成功");
-
-                // 发送全局配置更新通知
-                if let Some(uid) = uid_clone {
-                    // 延迟发送，确保文件已完全写入
-                    tokio::time::sleep(Duration::from_millis(100)).await;
-                    handle::Handle::notify_profile_changed(uid);
-                }
-            }
-        });
-
-        Ok(())
-    })
-    .await;
-
-    match import_result {
-        Ok(Ok(())) => {
-            logging!(info, Type::Cmd, true, "[导入订阅] 导入完成: {}", url);
-            Ok(())
-        }
-        Ok(Err(e)) => {
-            logging!(error, Type::Cmd, true, "[导入订阅] 导入失败: {}", e);
-            Err(format!("导入订阅失败: {e}"))
-        }
-        Err(_) => {
-            logging!(error, Type::Cmd, true, "[导入订阅] 导入超时(60秒): {}", url);
-            Err("导入订阅超时，请检查网络连接".into())
-        }
-    }
+    let item = wrap_err!(PrfItem::from_url(&url, None, None, option).await)?;
+    wrap_err!(Config::profiles().data().append_item(item))
 }
 
-/// 调整profile的顺序
+/// 重新排序配置文件
 #[tauri::command]
 pub async fn reorder_profile(active_id: String, over_id: String) -> CmdResult {
-    match profiles_reorder_safe(active_id, over_id).await {
-        Ok(_) => {
-            log::info!(target: "app", "重新排序配置文件");
-            Ok(())
-        }
-        Err(err) => {
-            log::error!(target: "app", "重新排序配置文件失败: {}", err);
-            Err(format!("重新排序配置文件失败: {}", err))
-        }
-    }
+    wrap_err!(Config::profiles().data().reorder(active_id, over_id))
 }
 
-/// 创建新的profile
-/// 创建一个新的配置文件
+/// 创建配置文件
 #[tauri::command]
 pub async fn create_profile(item: PrfItem, file_data: Option<String>) -> CmdResult {
-    match profiles_append_item_with_filedata_safe(item, file_data).await {
-        Ok(_) => 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}")),
-        },
-    }
+    let item = wrap_err!(PrfItem::from(item, file_data).await)?;
+    wrap_err!(Config::profiles().data().append_item(item))
 }
 
 /// 更新配置文件
 #[tauri::command]
 pub async fn update_profile(index: String, option: Option<PrfOption>) -> CmdResult {
-    match feat::update_profile(index, option, Some(true)).await {
-        Ok(_) => Ok(()),
-        Err(e) => {
-            log::error!(target: "app", "{}", e);
-            Err(e.to_string())
-        }
-    }
+    wrap_err!(feat::update_profile(index, option, Some(true)).await)
 }
 
 /// 删除配置文件
 #[tauri::command]
 pub async fn delete_profile(index: String) -> CmdResult {
-    // 使用Send-safe helper函数
-    let should_update = wrap_err!(profiles_delete_item_safe(index).await)?;
-
+    let should_update = wrap_err!({ Config::profiles().data().delete_item(index) })?;
     if should_update {
-        match CoreManager::global().update_config().await {
-            Ok(_) => {
-                handle::Handle::refresh_clash();
-            }
-            Err(e) => {
-                log::error!(target: "app", "{}", e);
-                return Err(e.to_string());
-            }
-        }
+        wrap_err!(CoreManager::global().update_config().await)?;
+        handle::Handle::refresh_clash();
     }
     Ok(())
 }
@@ -254,198 +103,132 @@ pub async fn delete_profile(index: String) -> CmdResult {
 /// 修改profiles的配置
 #[tauri::command]
 pub async fn patch_profiles_config(profiles: IProfiles) -> CmdResult<bool> {
-    if CURRENT_SWITCHING_PROFILE.load(Ordering::SeqCst) {
-        logging!(info, Type::Cmd, true, "当前正在切换配置，放弃请求");
-        return Ok(false);
-    }
-    CURRENT_SWITCHING_PROFILE.store(true, Ordering::SeqCst);
+    // 获取互斥锁，防止并发执行
+    let _guard = PROFILE_UPDATE_MUTEX.lock().await;
 
-    // 为当前请求分配序列号
-    let current_sequence = CURRENT_REQUEST_SEQUENCE.fetch_add(1, Ordering::SeqCst) + 1;
-    let target_profile = profiles.current.clone();
-
-    logging!(
-        info,
-        Type::Cmd,
-        true,
-        "开始修改配置文件，请求序列号: {}, 目标profile: {:?}",
-        current_sequence,
-        target_profile
-    );
-
-    let latest_sequence = CURRENT_REQUEST_SEQUENCE.load(Ordering::SeqCst);
-    if current_sequence < latest_sequence {
-        logging!(
-            info,
-            Type::Cmd,
-            true,
-            "获取锁后发现更新的请求 (序列号: {} < {})，放弃当前请求",
-            current_sequence,
-            latest_sequence
-        );
-        return Ok(false);
-    }
+    logging!(info, Type::Cmd, true, "开始修改配置文件");
 
     // 保存当前配置，以便在验证失败时恢复
-    let current_profile = Config::profiles().await.latest_ref().current.clone();
+    let current_profile = Config::profiles().latest().current.clone();
     logging!(info, Type::Cmd, true, "当前配置: {:?}", current_profile);
 
     // 如果要切换配置，先检查目标配置文件是否有语法错误
-    if let Some(new_profile) = profiles.current.as_ref()
-        && current_profile.as_ref() != Some(new_profile)
-    {
-        logging!(info, Type::Cmd, true, "正在切换到新配置: {}", new_profile);
+    if let Some(new_profile) = profiles.current.as_ref() {
+        if current_profile.as_ref() != Some(new_profile) {
+            logging!(info, Type::Cmd, true, "正在切换到新配置: {}", new_profile);
 
-        // 获取目标配置文件路径
-        let config_file_result = {
-            let profiles_config = Config::profiles().await;
-            let profiles_data = profiles_config.latest_ref();
-            match profiles_data.get_item(new_profile) {
-                Ok(item) => {
-                    if let Some(file) = &item.file {
-                        let path = dirs::app_profiles_dir().map(|dir| dir.join(file));
-                        path.ok()
-                    } else {
+            // 获取目标配置文件路径
+            let config_file_result = {
+                let profiles_config = Config::profiles();
+                let profiles_data = profiles_config.latest();
+                match profiles_data.get_item(new_profile) {
+                    Ok(item) => {
+                        if let Some(file) = &item.file {
+                            let path = dirs::app_profiles_dir().map(|dir| dir.join(file));
+                            path.ok()
+                        } else {
+                            None
+                        }
+                    }
+                    Err(e) => {
+                        logging!(error, Type::Cmd, true, "获取目标配置信息失败: {}", e);
                         None
                     }
                 }
-                Err(e) => {
-                    logging!(error, Type::Cmd, true, "获取目标配置信息失败: {}", e);
-                    None
-                }
-            }
-        };
+            };
 
-        // 如果获取到文件路径，检查YAML语法
-        if let Some(file_path) = config_file_result {
-            if !file_path.exists() {
-                logging!(
-                    error,
-                    Type::Cmd,
-                    true,
-                    "目标配置文件不存在: {}",
-                    file_path.display()
-                );
-                handle::Handle::notice_message(
-                    "config_validate::file_not_found",
-                    format!("{}", file_path.display()),
-                );
-                return Ok(false);
-            }
-
-            // 超时保护
-            let file_read_result = tokio::time::timeout(
-                Duration::from_secs(5),
-                tokio::fs::read_to_string(&file_path),
-            )
-            .await;
-
-            match file_read_result {
-                Ok(Ok(content)) => {
-                    let yaml_parse_result = AsyncHandler::spawn_blocking(move || {
-                        serde_yaml_ng::from_str::<serde_yaml_ng::Value>(&content)
-                    })
-                    .await;
-
-                    match yaml_parse_result {
-                        Ok(Ok(_)) => {
-                            logging!(info, Type::Cmd, true, "目标配置文件语法正确");
-                        }
-                        Ok(Err(err)) => {
-                            let error_msg = format!(" {err}");
-                            logging!(
-                                error,
-                                Type::Cmd,
-                                true,
-                                "目标配置文件存在YAML语法错误:{}",
-                                error_msg
-                            );
-                            handle::Handle::notice_message(
-                                "config_validate::yaml_syntax_error",
-                                &error_msg,
-                            );
-                            return Ok(false);
-                        }
-                        Err(join_err) => {
-                            let error_msg = format!("YAML解析任务失败: {join_err}");
-                            logging!(error, Type::Cmd, true, "{}", error_msg);
-                            handle::Handle::notice_message(
-                                "config_validate::yaml_parse_error",
-                                &error_msg,
-                            );
-                            return Ok(false);
-                        }
-                    }
-                }
-                Ok(Err(err)) => {
-                    let error_msg = format!("无法读取目标配置文件: {err}");
-                    logging!(error, Type::Cmd, true, "{}", error_msg);
-                    handle::Handle::notice_message("config_validate::file_read_error", &error_msg);
-                    return Ok(false);
-                }
-                Err(_) => {
-                    let error_msg = "读取配置文件超时(5秒)".to_string();
-                    logging!(error, Type::Cmd, true, "{}", error_msg);
+            // 如果获取到文件路径，检查YAML语法
+            if let Some(file_path) = config_file_result {
+                if !file_path.exists() {
+                    logging!(
+                        error,
+                        Type::Cmd,
+                        true,
+                        "目标配置文件不存在: {}",
+                        file_path.display()
+                    );
                     handle::Handle::notice_message(
-                        "config_validate::file_read_timeout",
-                        &error_msg,
+                        "config_validate::file_not_found",
+                        format!("{}", file_path.display()),
                     );
                     return Ok(false);
                 }
+
+                // 超时保护
+                let file_read_result = tokio::time::timeout(
+                    Duration::from_secs(5),
+                    tokio::fs::read_to_string(&file_path),
+                )
+                .await;
+
+                match file_read_result {
+                    Ok(Ok(content)) => {
+                        let yaml_parse_result = tokio::task::spawn_blocking(move || {
+                            serde_yaml::from_str::<serde_yaml::Value>(&content)
+                        })
+                        .await;
+
+                        match yaml_parse_result {
+                            Ok(Ok(_)) => {
+                                logging!(info, Type::Cmd, true, "目标配置文件语法正确");
+                            }
+                            Ok(Err(err)) => {
+                                let error_msg = format!(" {}", err);
+                                logging!(
+                                    error,
+                                    Type::Cmd,
+                                    true,
+                                    "目标配置文件存在YAML语法错误:{}",
+                                    error_msg
+                                );
+                                handle::Handle::notice_message(
+                                    "config_validate::yaml_syntax_error",
+                                    &error_msg,
+                                );
+                                return Ok(false);
+                            }
+                            Err(join_err) => {
+                                let error_msg = format!("YAML解析任务失败: {}", join_err);
+                                logging!(error, Type::Cmd, true, "{}", error_msg);
+                                handle::Handle::notice_message(
+                                    "config_validate::yaml_parse_error",
+                                    &error_msg,
+                                );
+                                return Ok(false);
+                            }
+                        }
+                    }
+                    Ok(Err(err)) => {
+                        let error_msg = format!("无法读取目标配置文件: {}", err);
+                        logging!(error, Type::Cmd, true, "{}", error_msg);
+                        handle::Handle::notice_message(
+                            "config_validate::file_read_error",
+                            &error_msg,
+                        );
+                        return Ok(false);
+                    }
+                    Err(_) => {
+                        let error_msg = "读取配置文件超时(5秒)".to_string();
+                        logging!(error, Type::Cmd, true, "{}", error_msg);
+                        handle::Handle::notice_message(
+                            "config_validate::file_read_timeout",
+                            &error_msg,
+                        );
+                        return Ok(false);
+                    }
+                }
             }
         }
     }
 
-    // 检查请求有效性
-    let latest_sequence = CURRENT_REQUEST_SEQUENCE.load(Ordering::SeqCst);
-    if current_sequence < latest_sequence {
-        logging!(
-            info,
-            Type::Cmd,
-            true,
-            "在核心操作前发现更新的请求 (序列号: {} < {})，放弃当前请求",
-            current_sequence,
-            latest_sequence
-        );
-        return Ok(false);
-    }
-
     // 更新profiles配置
-    logging!(
-        info,
-        Type::Cmd,
-        true,
-        "正在更新配置草稿，序列号: {}",
-        current_sequence
-    );
+    logging!(info, Type::Cmd, true, "正在更新配置草稿");
 
     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,
-            true,
-            "在内核交互前发现更新的请求 (序列号: {} < {})，放弃当前请求",
-            current_sequence,
-            latest_sequence
-        );
-        Config::profiles().await.discard();
-        return Ok(false);
-    }
+    let _ = Config::profiles().draft().patch_config(profiles);
 
     // 为配置更新添加超时保护
-    logging!(
-        info,
-        Type::Cmd,
-        true,
-        "开始内核配置更新，序列号: {}",
-        current_sequence
-    );
     let update_result = tokio::time::timeout(
         Duration::from_secs(30), // 30秒超时
         CoreManager::global().update_config(),
@@ -455,70 +238,36 @@ pub async fn patch_profiles_config(profiles: IProfiles) -> CmdResult<bool> {
     // 更新配置并进行验证
     match update_result {
         Ok(Ok((true, _))) => {
-            // 内核操作完成后再次检查请求有效性
-            let latest_sequence = CURRENT_REQUEST_SEQUENCE.load(Ordering::SeqCst);
-            if current_sequence < latest_sequence {
-                logging!(
-                    info,
-                    Type::Cmd,
-                    true,
-                    "内核操作后发现更新的请求 (序列号: {} < {})，忽略当前结果",
-                    current_sequence,
-                    latest_sequence
-                );
-                Config::profiles().await.discard();
-                return Ok(false);
-            }
-
-            logging!(
-                info,
-                Type::Cmd,
-                true,
-                "配置更新成功，序列号: {}",
-                current_sequence
-            );
-            Config::profiles().await.apply();
+            logging!(info, Type::Cmd, true, "配置更新成功");
+            Config::profiles().apply();
             handle::Handle::refresh_clash();
 
-            // 强制刷新代理缓存，确保profile切换后立即获取最新节点数据
             crate::process::AsyncHandler::spawn(|| async move {
-                if let Err(e) = super::proxy::force_refresh_proxies().await {
-                    log::warn!(target: "app", "强制刷新代理缓存失败: {e}");
+                if let Err(e) = Tray::global().update_tooltip() {
+                    log::warn!(target: "app", "异步更新托盘提示失败: {}", e);
+                }
+
+                if let Err(e) = Tray::global().update_menu() {
+                    log::warn!(target: "app", "异步更新托盘菜单失败: {}", e);
+                }
+
+                // 保存配置文件
+                if let Err(e) = Config::profiles().data().save_file() {
+                    log::warn!(target: "app", "异步保存配置文件失败: {}", e);
                 }
             });
 
-            if let Err(e) = Tray::global().update_tooltip().await {
-                log::warn!(target: "app", "异步更新托盘提示失败: {e}");
-            }
-
-            if let Err(e) = Tray::global().update_menu().await {
-                log::warn!(target: "app", "异步更新托盘菜单失败: {e}");
-            }
-
-            // 保存配置文件
-            if let Err(e) = profiles_save_file_safe().await {
-                log::warn!(target: "app", "异步保存配置文件失败: {e}");
-            }
-
             // 立即通知前端配置变更
             if let Some(current) = &current_value {
-                logging!(
-                    info,
-                    Type::Cmd,
-                    true,
-                    "向前端发送配置变更事件: {}, 序列号: {}",
-                    current,
-                    current_sequence
-                );
+                logging!(info, Type::Cmd, true, "向前端发送配置变更事件: {}", current);
                 handle::Handle::notify_profile_changed(current.clone());
             }
 
-            CURRENT_SWITCHING_PROFILE.store(false, Ordering::SeqCst);
             Ok(true)
         }
         Ok(Ok((false, error_msg))) => {
             logging!(warn, Type::Cmd, true, "配置验证失败: {}", error_msg);
-            Config::profiles().await.discard();
+            Config::profiles().discard();
             // 如果验证失败，恢复到之前的配置
             if let Some(prev_profile) = current_profile {
                 logging!(
@@ -533,17 +282,12 @@ pub async fn patch_profiles_config(profiles: IProfiles) -> CmdResult<bool> {
                     items: None,
                 };
                 // 静默恢复，不触发验证
-                wrap_err!({
-                    Config::profiles()
-                        .await
-                        .draft_mut()
-                        .patch_config(restore_profiles)
-                })?;
-                Config::profiles().await.apply();
+                wrap_err!({ Config::profiles().draft().patch_config(restore_profiles) })?;
+                Config::profiles().apply();
 
                 crate::process::AsyncHandler::spawn(|| async move {
-                    if let Err(e) = profiles_save_file_safe().await {
-                        log::warn!(target: "app", "异步保存恢复配置文件失败: {e}");
+                    if let Err(e) = Config::profiles().data().save_file() {
+                        log::warn!(target: "app", "异步保存恢复配置文件失败: {}", e);
                     }
                 });
 
@@ -552,61 +296,37 @@ pub async fn patch_profiles_config(profiles: IProfiles) -> CmdResult<bool> {
 
             // 发送验证错误通知
             handle::Handle::notice_message("config_validate::error", &error_msg);
-            CURRENT_SWITCHING_PROFILE.store(false, Ordering::SeqCst);
             Ok(false)
         }
         Ok(Err(e)) => {
-            logging!(
-                warn,
-                Type::Cmd,
-                true,
-                "更新过程发生错误: {}, 序列号: {}",
-                e,
-                current_sequence
-            );
-            Config::profiles().await.discard();
+            logging!(warn, Type::Cmd, true, "更新过程发生错误: {}", e);
+            Config::profiles().discard();
             handle::Handle::notice_message("config_validate::boot_error", e.to_string());
-
-            CURRENT_SWITCHING_PROFILE.store(false, Ordering::SeqCst);
             Ok(false)
         }
         Err(_) => {
             // 超时处理
             let timeout_msg = "配置更新超时(30秒)，可能是配置验证或核心通信阻塞";
-            logging!(
-                error,
-                Type::Cmd,
-                true,
-                "{}, 序列号: {}",
-                timeout_msg,
-                current_sequence
-            );
-            Config::profiles().await.discard();
+            logging!(error, Type::Cmd, true, "{}", timeout_msg);
+            Config::profiles().discard();
 
             if let Some(prev_profile) = current_profile {
                 logging!(
                     info,
                     Type::Cmd,
                     true,
-                    "超时后尝试恢复到之前的配置: {}, 序列号: {}",
-                    prev_profile,
-                    current_sequence
+                    "超时后尝试恢复到之前的配置: {}",
+                    prev_profile
                 );
                 let restore_profiles = IProfiles {
                     current: Some(prev_profile),
                     items: None,
                 };
-                wrap_err!({
-                    Config::profiles()
-                        .await
-                        .draft_mut()
-                        .patch_config(restore_profiles)
-                })?;
-                Config::profiles().await.apply();
+                wrap_err!({ Config::profiles().draft().patch_config(restore_profiles) })?;
+                Config::profiles().apply();
             }
 
             handle::Handle::notice_message("config_validate::timeout", timeout_msg);
-            CURRENT_SWITCHING_PROFILE.store(false, Ordering::SeqCst);
             Ok(false)
         }
     }
@@ -614,7 +334,10 @@ pub async fn patch_profiles_config(profiles: IProfiles) -> CmdResult<bool> {
 
 /// 根据profile name修改profiles
 #[tauri::command]
-pub async fn patch_profiles_config_by_profile_index(profile_index: String) -> CmdResult<bool> {
+pub async fn patch_profiles_config_by_profile_index(
+    _app_handle: tauri::AppHandle,
+    profile_index: String,
+) -> CmdResult<bool> {
     logging!(info, Type::Cmd, true, "切换配置到: {}", profile_index);
 
     let profiles = IProfiles {
@@ -626,26 +349,26 @@ pub async fn patch_profiles_config_by_profile_index(profile_index: String) -> Cm
 
 /// 修改某个profile item的
 #[tauri::command]
-pub async fn patch_profile(index: String, profile: PrfItem) -> CmdResult {
+pub fn patch_profile(index: String, profile: PrfItem) -> CmdResult {
     // 保存修改前检查是否有更新 update_interval
-    let profiles = Config::profiles().await;
-    let update_interval_changed = if let Ok(old_profile) = profiles.latest_ref().get_item(&index) {
-        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);
-        old_interval != new_interval
-    } else {
-        false
-    };
+    let update_interval_changed =
+        if let Ok(old_profile) = Config::profiles().latest().get_item(&index) {
+            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);
+            old_interval != new_interval
+        } else {
+            false
+        };
 
     // 保存修改
-    wrap_err!(profiles_patch_item_safe(index.clone(), profile).await)?;
+    wrap_err!(Config::profiles().data().patch_item(index.clone(), profile))?;
 
     // 如果更新间隔变更，异步刷新定时器
     if update_interval_changed {
         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 {
+            if let Err(e) = crate::core::Timer::global().refresh() {
                 logging!(error, Type::Timer, "刷新定时器失败: {}", e);
             } else {
                 // 刷新成功后发送自定义事件，不触发配置重载
@@ -659,11 +382,9 @@ 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();
+pub fn view_profile(app_handle: tauri::AppHandle, index: String) -> CmdResult {
     let file = {
-        wrap_err!(profiles_ref.get_item(&index))?
+        wrap_err!(Config::profiles().latest().get_item(&index))?
             .file
             .clone()
             .ok_or("the file field is null")
@@ -674,23 +395,23 @@ pub async fn view_profile(index: String) -> CmdResult {
         ret_err!("the file not found");
     }
 
-    wrap_err!(help::open_file(path))
+    wrap_err!(help::open_file(app_handle, path))
 }
 
 /// 读取配置文件内容
 #[tauri::command]
-pub async fn read_profile_file(index: String) -> CmdResult<String> {
-    let profiles = Config::profiles().await;
-    let profiles_ref = profiles.latest_ref();
-    let item = wrap_err!(profiles_ref.get_item(&index))?;
+pub fn read_profile_file(index: String) -> CmdResult<String> {
+    let profiles = Config::profiles();
+    let profiles = profiles.latest();
+    let item = wrap_err!(profiles.get_item(&index))?;
     let data = wrap_err!(item.read_file())?;
     Ok(data)
 }
 
 /// 获取下一次更新时间
 #[tauri::command]
-pub async fn get_next_update_time(uid: String) -> CmdResult<Option<i64>> {
+pub fn get_next_update_time(uid: String) -> CmdResult<Option<i64>> {
     let timer = Timer::global();
-    let next_time = timer.get_next_update_time(&uid).await;
+    let next_time = timer.get_next_update_time(&uid);
     Ok(next_time)
 }

src-tauri/src/cmd/proxy.rs

@@ -1,123 +1,77 @@
-use tauri::Emitter;
-
 use super::CmdResult;
-use crate::{
-    cache::CacheProxy,
-    core::{handle::Handle, tray::Tray},
-    ipc::IpcManager,
-    logging,
-    utils::logging::Type,
+use crate::{core::handle, module::mihomo::MihomoManager, state::proxy::CmdProxyState};
+use std::{
+    sync::Mutex,
+    time::{Duration, Instant},
 };
-use std::time::Duration;
+use tauri::Manager;
 
-const PROXIES_REFRESH_INTERVAL: Duration = Duration::from_secs(60);
-const PROVIDERS_REFRESH_INTERVAL: Duration = Duration::from_secs(60);
+const PROVIDERS_REFRESH_INTERVAL: Duration = Duration::from_secs(3);
+const PROXIES_REFRESH_INTERVAL: Duration = Duration::from_secs(1);
 
 #[tauri::command]
 pub async fn get_proxies() -> CmdResult<serde_json::Value> {
-    let cache = CacheProxy::global();
-    let key = CacheProxy::make_key("proxies", "default");
-    let value = cache
-        .get_or_fetch(key, PROXIES_REFRESH_INTERVAL, || async {
-            let manager = IpcManager::global();
-            manager.get_proxies().await.unwrap_or_else(|e| {
-                logging!(error, Type::Cmd, "Failed to fetch proxies: {e}");
-                serde_json::Value::Object(serde_json::Map::new())
-            })
-        })
-        .await;
-    Ok((*value).clone())
-}
+    let manager = MihomoManager::global();
 
-/// 强制刷新代理缓存用于profile切换
-#[tauri::command]
-pub async fn force_refresh_proxies() -> CmdResult<serde_json::Value> {
-    let cache = CacheProxy::global();
-    let key = CacheProxy::make_key("proxies", "default");
-    cache.map.remove(&key);
-    get_proxies().await
+    let app_handle = handle::Handle::global().app_handle().unwrap();
+    let cmd_proxy_state = app_handle.state::<Mutex<CmdProxyState>>();
+
+    let should_refresh = {
+        let mut state = cmd_proxy_state.lock().unwrap();
+        let now = Instant::now();
+        if now.duration_since(state.last_refresh_time) > PROXIES_REFRESH_INTERVAL {
+            state.need_refresh = true;
+            state.last_refresh_time = now;
+        }
+        state.need_refresh
+    };
+
+    if should_refresh {
+        let proxies = manager.get_refresh_proxies().await?;
+        {
+            let mut state = cmd_proxy_state.lock().unwrap();
+            state.proxies = proxies;
+            state.need_refresh = false;
+        }
+        log::debug!(target: "app", "proxies刷新成功");
+    }
+
+    let proxies = {
+        let state = cmd_proxy_state.lock().unwrap();
+        state.proxies.clone()
+    };
+    Ok(proxies)
 }
 
 #[tauri::command]
 pub async fn get_providers_proxies() -> CmdResult<serde_json::Value> {
-    let cache = CacheProxy::global();
-    let key = CacheProxy::make_key("providers", "default");
-    let value = cache
-        .get_or_fetch(key, PROVIDERS_REFRESH_INTERVAL, || async {
-            let manager = IpcManager::global();
-            manager.get_providers_proxies().await.unwrap_or_else(|e| {
-                logging!(error, Type::Cmd, "Failed to fetch provider proxies: {e}");
-                serde_json::Value::Object(serde_json::Map::new())
-            })
-        })
-        .await;
-    Ok((*value).clone())
-}
+    let app_handle = handle::Handle::global().app_handle().unwrap();
+    let cmd_proxy_state = app_handle.state::<Mutex<CmdProxyState>>();
 
-/// 同步托盘和GUI的代理选择状态
-#[tauri::command]
-pub async fn sync_tray_proxy_selection() -> CmdResult<()> {
-    use crate::core::tray::Tray;
+    let should_refresh = {
+        let mut state = cmd_proxy_state.lock().unwrap();
+        let now = Instant::now();
+        if now.duration_since(state.last_refresh_time) > PROVIDERS_REFRESH_INTERVAL {
+            state.need_refresh = true;
+            state.last_refresh_time = now;
+        }
+        state.need_refresh
+    };
 
-    match Tray::global().update_menu().await {
-        Ok(_) => {
-            logging!(info, Type::Cmd, "Tray proxy selection synced successfully");
-            Ok(())
-        }
-        Err(e) => {
-            logging!(error, Type::Cmd, "Failed to sync tray proxy selection: {e}");
-            Err(e.to_string())
-        }
-    }
-}
-
-/// 更新代理选择并同步托盘和GUI状态
-#[tauri::command]
-pub async fn update_proxy_and_sync(group: String, proxy: String) -> CmdResult<()> {
-    match IpcManager::global().update_proxy(&group, &proxy).await {
-        Ok(_) => {
-            // println!("Proxy updated successfully: {} -> {}", group,proxy);
-            logging!(
-                info,
-                Type::Cmd,
-                "Proxy updated successfully: {} -> {}",
-                group,
-                proxy
-            );
-
-            let cache = CacheProxy::global();
-            let key = CacheProxy::make_key("proxies", "default");
-            cache.map.remove(&key);
-
-            if let Err(e) = Tray::global().update_menu().await {
-                logging!(error, Type::Cmd, "Failed to sync tray menu: {}", e);
-            }
-
-            if let Some(app_handle) = Handle::global().app_handle() {
-                let _ = app_handle.emit("verge://force-refresh-proxies", ());
-                let _ = app_handle.emit("verge://refresh-proxy-config", ());
-            }
-
-            logging!(
-                info,
-                Type::Cmd,
-                "Proxy and sync completed successfully: {} -> {}",
-                group,
-                proxy
-            );
-            Ok(())
-        }
-        Err(e) => {
-            println!("1111111111111111");
-            logging!(
-                error,
-                Type::Cmd,
-                "Failed to update proxy: {} -> {}, error: {}",
-                group,
-                proxy,
-                e
-            );
-            Err(e.to_string())
+    if should_refresh {
+        let manager = MihomoManager::global();
+        let providers = manager.get_providers_proxies().await?;
+        {
+            let mut state = cmd_proxy_state.lock().unwrap();
+            state.providers_proxies = providers;
+            state.need_refresh = false;
         }
+        log::debug!(target: "app", "providers_proxies刷新成功");
     }
+
+    let providers_proxies = {
+        let state = cmd_proxy_state.lock().unwrap();
+        state.providers_proxies.clone()
+    };
+    Ok(providers_proxies)
 }

src-tauri/src/cmd/runtime.rs

@@ -1,125 +1,36 @@
 use super::CmdResult;
-use crate::{config::*, core::CoreManager, log_err, wrap_err};
+use crate::{config::*, wrap_err};
 use anyhow::Context;
-use serde_yaml_ng::Mapping;
+use serde_yaml::Mapping;
 use std::collections::HashMap;
 
 /// 获取运行时配置
 #[tauri::command]
-pub async fn get_runtime_config() -> CmdResult<Option<Mapping>> {
-    Ok(Config::runtime().await.latest_ref().config.clone())
+pub fn get_runtime_config() -> CmdResult<Option<Mapping>> {
+    Ok(Config::runtime().latest().config.clone())
 }
 
 /// 获取运行时YAML配置
 #[tauri::command]
-pub async fn get_runtime_yaml() -> CmdResult<String> {
-    let runtime = Config::runtime().await;
-    let runtime = runtime.latest_ref();
-
+pub fn get_runtime_yaml() -> CmdResult<String> {
+    let runtime = Config::runtime();
+    let runtime = runtime.latest();
     let config = runtime.config.as_ref();
-    wrap_err!(
-        config
-            .ok_or(anyhow::anyhow!("failed to parse config to yaml file"))
-            .and_then(|config| serde_yaml_ng::to_string(config)
-                .context("failed to convert config to yaml"))
-    )
+    wrap_err!(config
+        .ok_or(anyhow::anyhow!("failed to parse config to yaml file"))
+        .and_then(
+            |config| serde_yaml::to_string(config).context("failed to convert config to yaml")
+        ))
 }
 
 /// 获取运行时存在的键
 #[tauri::command]
-pub async fn get_runtime_exists() -> CmdResult<Vec<String>> {
-    Ok(Config::runtime().await.latest_ref().exists_keys.clone())
+pub fn get_runtime_exists() -> CmdResult<Vec<String>> {
+    Ok(Config::runtime().latest().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())
-}
-
-/// 读取运行时链式代理配置
-#[tauri::command]
-pub async fn get_runtime_proxy_chain_config() -> CmdResult<String> {
-    let runtime = Config::runtime().await;
-    let runtime = runtime.latest_ref();
-
-    let config = wrap_err!(
-        runtime
-            .config
-            .as_ref()
-            .ok_or(anyhow::anyhow!("failed to parse config to yaml file"))
-    )?;
-
-    if let (
-        Some(serde_yaml_ng::Value::Sequence(proxies)),
-        Some(serde_yaml_ng::Value::Sequence(proxy_groups)),
-    ) = (config.get("proxies"), config.get("proxy-groups"))
-    {
-        let mut proxy_name = None;
-        let mut proxies_chain = Vec::new();
-
-        let proxy_chain_groups = proxy_groups
-            .iter()
-            .filter_map(
-                |proxy_group| match proxy_group.get("name").and_then(|n| n.as_str()) {
-                    Some("proxy_chain") => {
-                        if let Some(serde_yaml_ng::Value::Sequence(ps)) = proxy_group.get("proxies")
-                            && let Some(x) = ps.first()
-                        {
-                            proxy_name = Some(x); //插入出口节点名字
-                        }
-                        Some(proxy_group.to_owned())
-                    }
-                    _ => None,
-                },
-            )
-            .collect::<Vec<serde_yaml_ng::Value>>();
-
-        while let Some(proxy) = proxies.iter().find(|proxy| {
-            if let serde_yaml_ng::Value::Mapping(proxy_map) = proxy {
-                proxy_map.get("name") == proxy_name && proxy_map.get("dialer-proxy").is_some()
-            } else {
-                false
-            }
-        }) {
-            proxies_chain.push(proxy.to_owned());
-            proxy_name = proxy.get("dialer-proxy");
-        }
-
-        if let Some(entry_proxy) = proxies.iter().find(|proxy| proxy.get("name") == proxy_name) {
-            proxies_chain.push(entry_proxy.to_owned());
-        }
-
-        proxies_chain.reverse();
-
-        let mut config: HashMap<String, Vec<serde_yaml_ng::Value>> = HashMap::new();
-        config.insert("proxies".to_string(), proxies_chain);
-        config.insert("proxy-groups".to_string(), proxy_chain_groups);
-
-        wrap_err!(serde_yaml_ng::to_string(&config).context("YAML generation failed"))
-    } else {
-        wrap_err!(Err(anyhow::anyhow!(
-            "failed to get proxies or proxy-groups".to_string()
-        )))
-    }
-}
-
-/// 更新运行时链式代理配置
-#[tauri::command]
-pub async fn update_proxy_chain_config_in_runtime(
-    proxy_chain_config: Option<serde_yaml_ng::Value>,
-) -> CmdResult<()> {
-    {
-        let runtime = Config::runtime().await;
-        let mut draft = runtime.draft_mut();
-        draft.update_proxy_chain_config(proxy_chain_config);
-        drop(draft);
-        runtime.apply();
-    }
-
-    // 生成新的运行配置文件并通知 Clash 核心重新加载
-    let run_path = wrap_err!(Config::generate_file(ConfigType::Run).await)?;
-    log_err!(CoreManager::global().put_configs_force(run_path).await);
-
-    Ok(())
+pub fn get_runtime_logs() -> CmdResult<HashMap<String, Vec<(String, String)>>> {
+    Ok(Config::runtime().latest().chain_logs.clone())
 }

src-tauri/src/cmd/save_profile.rs

@@ -1,12 +1,6 @@
 use super::CmdResult;
-use crate::{
-    config::*,
-    core::*,
-    logging,
-    utils::{dirs, logging::Type},
-    wrap_err,
-};
-use tokio::fs;
+use crate::{config::*, core::*, utils::dirs, wrap_err};
+use std::fs;
 
 /// 保存profiles的配置
 #[tauri::command]
@@ -17,8 +11,8 @@ pub async fn save_profile_file(index: String, file_data: Option<String>) -> CmdR
 
     // 在异步操作前完成所有文件操作
     let (file_path, original_content, is_merge_file) = {
-        let profiles = Config::profiles().await;
-        let profiles_guard = profiles.latest_ref();
+        let profiles = Config::profiles();
+        let profiles_guard = profiles.latest();
         let item = wrap_err!(profiles_guard.get_item(&index))?;
         // 确定是否为merge类型文件
         let is_merge = item.itype.as_ref().is_some_and(|t| t == "merge");
@@ -29,81 +23,43 @@ pub async fn save_profile_file(index: String, file_data: Option<String>) -> CmdR
     };
 
     // 保存新的配置文件
-    let file_data = file_data.ok_or("file_data is None")?;
-    wrap_err!(fs::write(&file_path, &file_data).await)?;
+    wrap_err!(fs::write(&file_path, file_data.clone().unwrap()))?;
 
     let file_path_str = file_path.to_string_lossy().to_string();
-    logging!(
-        info,
-        Type::Config,
-        true,
+    println!(
         "[cmd配置save] 开始验证配置文件: {}, 是否为merge文件: {}",
-        file_path_str,
-        is_merge_file
+        file_path_str, is_merge_file
     );
 
     // 对于 merge 文件，只进行语法验证，不进行后续内核验证
     if is_merge_file {
-        logging!(
-            info,
-            Type::Config,
-            true,
-            "[cmd配置save] 检测到merge文件，只进行语法验证"
-        );
+        println!("[cmd配置save] 检测到merge文件，只进行语法验证");
         match CoreManager::global()
             .validate_config_file(&file_path_str, Some(true))
             .await
         {
             Ok((true, _)) => {
-                logging!(
-                    info,
-                    Type::Config,
-                    true,
-                    "[cmd配置save] merge文件语法验证通过"
-                );
+                println!("[cmd配置save] merge文件语法验证通过");
                 // 成功后尝试更新整体配置
-                match CoreManager::global().update_config().await {
-                    Ok(_) => {
-                        // 配置更新成功，刷新前端
-                        handle::Handle::refresh_clash();
-                    }
-                    Err(e) => {
-                        logging!(
-                            warn,
-                            Type::Config,
-                            true,
-                            "[cmd配置save] 更新整体配置时发生错误: {}",
-                            e
-                        );
-                    }
+                if let Err(e) = CoreManager::global().update_config().await {
+                    println!("[cmd配置save] 更新整体配置时发生错误: {}", e);
+                    log::warn!(target: "app", "更新整体配置时发生错误: {}", e);
                 }
                 return Ok(());
             }
             Ok((false, error_msg)) => {
-                logging!(
-                    warn,
-                    Type::Config,
-                    true,
-                    "[cmd配置save] merge文件语法验证失败: {}",
-                    error_msg
-                );
+                println!("[cmd配置save] merge文件语法验证失败: {}", error_msg);
                 // 恢复原始配置文件
-                wrap_err!(fs::write(&file_path, original_content).await)?;
+                wrap_err!(fs::write(&file_path, original_content))?;
                 // 发送合并文件专用错误通知
                 let result = (false, error_msg.clone());
                 crate::cmd::validate::handle_yaml_validation_notice(&result, "合并配置文件");
                 return Ok(());
             }
             Err(e) => {
-                logging!(
-                    error,
-                    Type::Config,
-                    true,
-                    "[cmd配置save] 验证过程发生错误: {}",
-                    e
-                );
+                println!("[cmd配置save] 验证过程发生错误: {}", e);
                 // 恢复原始配置文件
-                wrap_err!(fs::write(&file_path, original_content).await)?;
+                wrap_err!(fs::write(&file_path, original_content))?;
                 return Err(e.to_string());
             }
         }
@@ -115,19 +71,13 @@ pub async fn save_profile_file(index: String, file_data: Option<String>) -> CmdR
         .await
     {
         Ok((true, _)) => {
-            logging!(info, Type::Config, true, "[cmd配置save] 验证成功");
+            println!("[cmd配置save] 验证成功");
             Ok(())
         }
         Ok((false, error_msg)) => {
-            logging!(
-                warn,
-                Type::Config,
-                true,
-                "[cmd配置save] 验证失败: {}",
-                error_msg
-            );
+            println!("[cmd配置save] 验证失败: {}", error_msg);
             // 恢复原始配置文件
-            wrap_err!(fs::write(&file_path, original_content).await)?;
+            wrap_err!(fs::write(&file_path, original_content))?;
 
             // 智能判断错误类型
             let is_script_error = file_path_str.ends_with(".js")
@@ -140,44 +90,26 @@ pub async fn save_profile_file(index: String, file_data: Option<String>) -> CmdR
                 || (!file_path_str.ends_with(".js") && !is_script_error)
             {
                 // 普通YAML错误使用YAML通知处理
-                logging!(
-                    info,
-                    Type::Config,
-                    "[cmd配置save] YAML配置文件验证失败，发送通知"
-                );
+                println!("[cmd配置save] YAML配置文件验证失败，发送通知");
                 let result = (false, error_msg.clone());
                 crate::cmd::validate::handle_yaml_validation_notice(&result, "YAML配置文件");
             } else if is_script_error {
                 // 脚本错误使用专门的通知处理
-                logging!(
-                    info,
-                    Type::Config,
-                    "[cmd配置save] 脚本文件验证失败，发送通知"
-                );
+                println!("[cmd配置save] 脚本文件验证失败，发送通知");
                 let result = (false, error_msg.clone());
                 crate::cmd::validate::handle_script_validation_notice(&result, "脚本文件");
             } else {
                 // 普通配置错误使用一般通知
-                logging!(
-                    info,
-                    Type::Config,
-                    "[cmd配置save] 其他类型验证失败，发送一般通知"
-                );
+                println!("[cmd配置save] 其他类型验证失败，发送一般通知");
                 handle::Handle::notice_message("config_validate::error", &error_msg);
             }
 
             Ok(())
         }
         Err(e) => {
-            logging!(
-                error,
-                Type::Config,
-                true,
-                "[cmd配置save] 验证过程发生错误: {}",
-                e
-            );
+            println!("[cmd配置save] 验证过程发生错误: {}", e);
             // 恢复原始配置文件
-            wrap_err!(fs::write(&file_path, original_content).await)?;
+            wrap_err!(fs::write(&file_path, original_content))?;
             Err(e.to_string())
         }
     }

src-tauri/src/cmd/service.rs

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

src-tauri/src/cmd/system.rs

@@ -1,9 +1,7 @@
 use super::CmdResult;
 use crate::{
-    core::{CoreManager, handle},
-    logging,
+    core::{handle, CoreManager},
     module::sysinfo::PlatformSpecification,
-    utils::logging::Type,
 };
 use once_cell::sync::Lazy;
 use std::{
@@ -25,30 +23,28 @@ static APP_START_TIME: Lazy<AtomicI64> = Lazy::new(|| {
 
 #[tauri::command]
 pub async fn export_diagnostic_info() -> CmdResult<()> {
-    let sysinfo = PlatformSpecification::new_sync();
-    let info = format!("{sysinfo:?}");
+    let sysinfo = PlatformSpecification::new_async().await;
+    let info = format!("{:?}", sysinfo);
 
-    let app_handle = handle::Handle::global()
-        .app_handle()
-        .ok_or("Failed to get app handle")?;
+    let app_handle = handle::Handle::global().app_handle().unwrap();
     let cliboard = app_handle.clipboard();
     if cliboard.write_text(info).is_err() {
-        logging!(error, Type::System, "Failed to write to clipboard");
+        log::error!(target: "app", "Failed to write to clipboard");
     }
     Ok(())
 }
 
 #[tauri::command]
 pub async fn get_system_info() -> CmdResult<String> {
-    let sysinfo = PlatformSpecification::new_sync();
-    let info = format!("{sysinfo:?}");
+    let sysinfo = PlatformSpecification::new_async().await;
+    let info = format!("{:?}", sysinfo);
     Ok(info)
 }
 
 /// 获取当前内核运行模式
 #[tauri::command]
 pub async fn get_running_mode() -> Result<String, String> {
-    Ok(CoreManager::global().get_running_mode().to_string())
+    Ok(CoreManager::global().get_running_mode().await.to_string())
 }
 
 /// 获取应用的运行时间（毫秒）

src-tauri/src/cmd/uwp.rs

@@ -6,8 +6,8 @@ mod platform {
     use super::CmdResult;
     use crate::{core::win_uwp, wrap_err};
 
-    pub fn invoke_uwp_tool() -> CmdResult {
-        wrap_err!(win_uwp::invoke_uwptools())
+    pub async fn invoke_uwp_tool() -> CmdResult {
+        wrap_err!(win_uwp::invoke_uwptools().await)
     }
 }
 
@@ -16,7 +16,7 @@ mod platform {
 mod platform {
     use super::CmdResult;
 
-    pub fn invoke_uwp_tool() -> CmdResult {
+    pub async fn invoke_uwp_tool() -> CmdResult {
         Ok(())
     }
 }
@@ -24,5 +24,5 @@ mod platform {
 /// Command exposed to Tauri
 #[tauri::command]
 pub async fn invoke_uwp_tool() -> CmdResult {
-    platform::invoke_uwp_tool()
+    platform::invoke_uwp_tool().await
 }

src-tauri/src/cmd/validate.rs

@@ -1,5 +1,5 @@
 use super::CmdResult;
-use crate::{core::*, logging, utils::logging::Type};
+use crate::core::*;
 
 /// 发送脚本验证通知消息
 #[tauri::command]
@@ -28,14 +28,7 @@ pub fn handle_script_validation_notice(result: &(bool, String), file_type: &str)
             "config_validate::script_error"
         };
 
-        logging!(
-            warn,
-            Type::Config,
-            true,
-            "{} 验证失败: {}",
-            file_type,
-            error_msg
-        );
+        log::warn!(target: "app", "{} 验证失败: {}", file_type, error_msg);
         handle::Handle::notice_message(status, error_msg);
     }
 }
@@ -43,7 +36,7 @@ pub fn handle_script_validation_notice(result: &(bool, String), file_type: &str)
 /// 验证指定脚本文件
 #[tauri::command]
 pub async fn validate_script_file(file_path: String) -> CmdResult<bool> {
-    logging!(info, Type::Config, true, "验证脚本文件: {}", file_path);
+    log::info!(target: "app", "验证脚本文件: {}", file_path);
 
     match CoreManager::global()
         .validate_config_file(&file_path, None)
@@ -55,13 +48,7 @@ pub async fn validate_script_file(file_path: String) -> CmdResult<bool> {
         }
         Err(e) => {
             let error_msg = e.to_string();
-            logging!(
-                error,
-                Type::Config,
-                true,
-                "验证脚本文件过程发生错误: {}",
-                error_msg
-            );
+            log::error!(target: "app", "验证脚本文件过程发生错误: {}", error_msg);
             handle::Handle::notice_message("config_validate::process_terminated", &error_msg);
             Ok(false)
         }
@@ -73,14 +60,7 @@ pub async fn validate_script_file(file_path: String) -> CmdResult<bool> {
 pub fn handle_yaml_validation_notice(result: &(bool, String), file_type: &str) {
     if !result.0 {
         let error_msg = &result.1;
-        logging!(
-            info,
-            Type::Config,
-            true,
-            "[通知] 处理{}验证错误: {}",
-            file_type,
-            error_msg
-        );
+        println!("[通知] 处理{}验证错误: {}", file_type, error_msg);
 
         // 检查是否为merge文件
         let is_merge_file = file_type.contains("合并");
@@ -117,22 +97,8 @@ pub fn handle_yaml_validation_notice(result: &(bool, String), file_type: &str) {
             }
         };
 
-        logging!(
-            warn,
-            Type::Config,
-            true,
-            "{} 验证失败: {}",
-            file_type,
-            error_msg
-        );
-        logging!(
-            info,
-            Type::Config,
-            true,
-            "[通知] 发送通知: status={}, msg={}",
-            status,
-            error_msg
-        );
+        log::warn!(target: "app", "{} 验证失败: {}", file_type, error_msg);
+        println!("[通知] 发送通知: status={}, msg={}", status, error_msg);
         handle::Handle::notice_message(status, error_msg);
     }
 }

src-tauri/src/cmd/verge.rs

@@ -3,14 +3,10 @@ use crate::{config::*, feat, wrap_err};
 
 /// 获取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 fn get_verge_config() -> CmdResult<IVergeResponse> {
+    let verge = Config::verge();
+    let verge_data = verge.data().clone();
+    Ok(IVergeResponse::from(verge_data))
 }
 
 /// 修改Verge配置

src-tauri/src/cmd/webdav.rs

@@ -11,17 +11,11 @@ pub async fn save_webdav_config(url: String, username: String, password: String)
         webdav_password: Some(password),
         ..IVerge::default()
     };
+    Config::verge().draft().patch_config(patch.clone());
+    Config::verge().apply();
     Config::verge()
-        .await
-        .draft_mut()
-        .patch_config(patch.clone());
-    Config::verge().await.apply();
-
-    // 分离数据获取和异步调用
-    let verge_data = Config::verge().await.latest_ref().clone();
-    verge_data
+        .data()
         .save_file()
-        .await
         .map_err(|err| err.to_string())?;
     core::backup::WebDavClient::global().reset();
     Ok(())

src-tauri/src/config/clash.rs

@@ -1,9 +1,7 @@
-use crate::config::Config;
-use crate::utils::dirs::{ipc_path, path_to_str};
 use crate::utils::{dirs, help};
 use anyhow::Result;
 use serde::{Deserialize, Serialize};
-use serde_yaml_ng::{Mapping, Value};
+use serde_yaml::{Mapping, Value};
 use std::{
     net::{IpAddr, Ipv4Addr, SocketAddr},
     str::FromStr,
@@ -13,29 +11,20 @@ use std::{
 pub struct IClashTemp(pub Mapping);
 
 impl IClashTemp {
-    pub async fn new() -> Self {
+    pub fn new() -> Self {
         let template = Self::template();
-        let clash_path_result = dirs::clash_path();
-        let map_result = if let Ok(path) = clash_path_result {
-            help::read_mapping(&path).await
-        } else {
-            Err(anyhow::anyhow!("Failed to get clash path"))
-        };
-
-        match map_result {
+        match dirs::clash_path().and_then(|path| help::read_mapping(&path)) {
             Ok(mut map) => {
                 template.0.keys().for_each(|key| {
-                    if !map.contains_key(key)
-                        && let Some(value) = template.0.get(key)
-                    {
-                        map.insert(key.clone(), value.clone());
+                    if !map.contains_key(key) {
+                        map.insert(key.clone(), template.0.get(key).unwrap().clone());
                     }
                 });
                 // 确保 secret 字段存在且不为空
-                if let Some(Value::String(s)) = map.get_mut("secret")
-                    && s.is_empty()
-                {
-                    *s = "set-your-secret".to_string();
+                if let Some(Value::String(s)) = map.get_mut("secret") {
+                    if s.is_empty() {
+                        *s = "set-your-secret".to_string();
+                    }
                 }
                 Self(Self::guard(map))
             }
@@ -68,24 +57,12 @@ impl IClashTemp {
         map.insert("ipv6".into(), true.into());
         map.insert("mode".into(), "rule".into());
         map.insert("external-controller".into(), "127.0.0.1:9097".into());
-        #[cfg(unix)]
-        map.insert(
-            "external-controller-unix".into(),
-            Self::guard_external_controller_ipc().into(),
-        );
-        #[cfg(windows)]
-        map.insert(
-            "external-controller-pipe".into(),
-            Self::guard_external_controller_ipc().into(),
-        );
         cors_map.insert("allow-private-network".into(), true.into());
         cors_map.insert(
             "allow-origins".into(),
             vec![
                 "tauri://localhost",
                 "http://tauri.localhost",
-                // Only enable this in dev mode
-                #[cfg(feature = "verge-dev")]
                 "http://localhost:3000",
                 "https://yacd.metacubex.one",
                 "https://metacubex.github.io",
@@ -108,12 +85,7 @@ impl IClashTemp {
         let mixed_port = Self::guard_mixed_port(&config);
         let socks_port = Self::guard_socks_port(&config);
         let port = Self::guard_port(&config);
-        let ctrl = Self::guard_external_controller(&config);
-        #[cfg(unix)]
-        let external_controller_unix = Self::guard_external_controller_ipc();
-        #[cfg(windows)]
-        let external_controller_pipe = Self::guard_external_controller_ipc();
-
+        let ctrl = Self::guard_server_ctrl(&config);
         #[cfg(not(target_os = "windows"))]
         config.insert("redir-port".into(), redir_port.into());
         #[cfg(target_os = "linux")]
@@ -123,16 +95,23 @@ impl IClashTemp {
         config.insert("port".into(), port.into());
         config.insert("external-controller".into(), ctrl.into());
 
-        #[cfg(unix)]
-        config.insert(
-            "external-controller-unix".into(),
-            external_controller_unix.into(),
-        );
-        #[cfg(windows)]
-        config.insert(
-            "external-controller-pipe".into(),
-            external_controller_pipe.into(),
+        // 强制覆盖 external-controller-cors 字段，允许本地和 tauri 前端
+        let mut cors_map = Mapping::new();
+        cors_map.insert("allow-private-network".into(), true.into());
+        cors_map.insert(
+            "allow-origins".into(),
+            vec![
+                "tauri://localhost",
+                "http://tauri.localhost",
+                "http://localhost:3000",
+                "https://yacd.metacubex.one",
+                "https://metacubex.github.io",
+                "https://board.zash.run.place",
+            ]
+            .into(),
         );
+        config.insert("external-controller-cors".into(), cors_map.into());
+
         config
     }
 
@@ -142,13 +121,12 @@ impl IClashTemp {
         }
     }
 
-    pub async fn save_config(&self) -> Result<()> {
+    pub fn save_config(&self) -> Result<()> {
         help::save_yaml(
             &dirs::clash_path()?,
             &self.0,
             Some("# Generated by Clash Verge"),
         )
-        .await
     }
 
     pub fn get_mixed_port(&self) -> u16 {
@@ -282,27 +260,6 @@ impl IClashTemp {
             .unwrap_or("127.0.0.1:9097".into())
     }
 
-    pub fn guard_external_controller(config: &Mapping) -> String {
-        // 在初始化阶段，直接返回配置中的值，不进行额外检查
-        // 这样可以避免在配置加载期间的循环依赖
-        Self::guard_server_ctrl(config)
-    }
-
-    pub async fn guard_external_controller_with_setting(config: &Mapping) -> String {
-        // 检查 enable_external_controller 设置，用于运行时配置生成
-        let enable_external_controller = Config::verge()
-            .await
-            .latest_ref()
-            .enable_external_controller
-            .unwrap_or(false);
-
-        if enable_external_controller {
-            Self::guard_server_ctrl(config)
-        } else {
-            "".into()
-        }
-    }
-
     pub fn guard_client_ctrl(config: &Mapping) -> String {
         let value = Self::guard_server_ctrl(config);
         match SocketAddr::from_str(value.as_str()) {
@@ -315,17 +272,6 @@ impl IClashTemp {
             Err(_) => "127.0.0.1:9097".into(),
         }
     }
-
-    pub fn guard_external_controller_ipc() -> String {
-        // 总是使用当前的 IPC 路径，确保配置文件与运行时路径一致
-        ipc_path()
-            .ok()
-            .and_then(|path| path_to_str(&path).ok().map(|s| s.to_string()))
-            .unwrap_or_else(|| {
-                log::error!(target: "app", "Failed to get IPC path, using default");
-                "127.0.0.1:9090".to_string()
-            })
-    }
 }
 
 #[derive(Default, Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]

src-tauri/src/config/config.rs

@@ -1,75 +1,71 @@
 use super::{Draft, IClashTemp, IProfiles, IRuntime, IVerge};
 use crate::{
-    config::{PrfItem, profiles_append_item_safe},
-    core::{CoreManager, handle},
+    config::PrfItem,
+    core::{handle, CoreManager},
     enhance, logging,
+    process::AsyncHandler,
     utils::{dirs, help, logging::Type},
 };
-use anyhow::{Result, anyhow};
+use anyhow::{anyhow, Result};
+use once_cell::sync::OnceCell;
 use std::path::PathBuf;
-use tokio::sync::OnceCell;
-use tokio::time::{Duration, sleep};
+use tokio::time::{sleep, Duration};
 
 pub const RUNTIME_CONFIG: &str = "clash-verge.yaml";
 pub const CHECK_CONFIG: &str = "clash-verge-check.yaml";
 
 pub struct Config {
-    clash_config: Draft<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 {
-        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())),
-                }
-            })
-            .await
+    pub fn global() -> &'static Config {
+        static CONFIG: OnceCell<Config> = OnceCell::new();
+
+        CONFIG.get_or_init(|| Config {
+            clash_config: Draft::from(IClashTemp::new()),
+            verge_config: Draft::from(IVerge::new()),
+            profiles_config: Draft::from(IProfiles::new()),
+            runtime_config: Draft::from(IRuntime::new()),
+        })
     }
 
-    pub async fn clash() -> Draft<Box<IClashTemp>> {
-        Self::global().await.clash_config.clone()
+    pub fn clash() -> Draft<IClashTemp> {
+        Self::global().clash_config.clone()
     }
 
-    pub async fn verge() -> Draft<Box<IVerge>> {
-        Self::global().await.verge_config.clone()
+    pub fn verge() -> Draft<IVerge> {
+        Self::global().verge_config.clone()
     }
 
-    pub async fn profiles() -> Draft<Box<IProfiles>> {
-        Self::global().await.profiles_config.clone()
+    pub fn profiles() -> Draft<IProfiles> {
+        Self::global().profiles_config.clone()
     }
 
-    pub async fn runtime() -> Draft<Box<IRuntime>> {
-        Self::global().await.runtime_config.clone()
+    pub fn runtime() -> Draft<IRuntime> {
+        Self::global().runtime_config.clone()
     }
 
     /// 初始化订阅
     pub async fn init_config() -> Result<()> {
         if Self::profiles()
-            .await
-            .latest_ref()
+            .data()
             .get_item(&"Merge".to_string())
             .is_err()
         {
             let merge_item = PrfItem::from_merge(Some("Merge".to_string()))?;
-            profiles_append_item_safe(merge_item.clone()).await?;
+            Self::profiles().data().append_item(merge_item.clone())?;
         }
         if Self::profiles()
-            .await
-            .latest_ref()
+            .data()
             .get_item(&"Script".to_string())
             .is_err()
         {
             let script_item = PrfItem::from_script(Some("Script".to_string()))?;
-            profiles_append_item_safe(script_item.clone()).await?;
+            Self::profiles().data().append_item(script_item.clone())?;
         }
         // 生成运行时配置
         if let Err(err) = Self::generate().await {
@@ -79,7 +75,7 @@ impl Config {
         }
 
         // 生成运行时配置文件并验证
-        let config_result = Self::generate_file(ConfigType::Run).await;
+        let config_result = Self::generate_file(ConfigType::Run);
 
         let validation_result = if config_result.is_ok() {
             // 验证配置文件
@@ -101,9 +97,7 @@ impl Config {
                         Some(("config_validate::boot_error", error_msg))
                     } else {
                         logging!(info, Type::Config, true, "配置验证成功");
-                        // 前端没有必要知道验证成功的消息，也没有事件驱动
-                        // Some(("config_validate::success", String::new()))
-                        None
+                        Some(("config_validate::success", String::new()))
                     }
                 }
                 Err(err) => {
@@ -124,30 +118,30 @@ impl Config {
 
         // 在单独的任务中发送通知
         if let Some((msg_type, msg_content)) = validation_result {
-            sleep(Duration::from_secs(2)).await;
-            handle::Handle::notice_message(msg_type, &msg_content);
+            AsyncHandler::spawn(move || async move {
+                sleep(Duration::from_secs(2)).await;
+                handle::Handle::notice_message(msg_type, &msg_content);
+            });
         }
 
         Ok(())
     }
 
     /// 将订阅丢到对应的文件中
-    pub async fn generate_file(typ: ConfigType) -> Result<PathBuf> {
+    pub fn generate_file(typ: ConfigType) -> Result<PathBuf> {
         let path = match typ {
             ConfigType::Run => dirs::app_home_dir()?.join(RUNTIME_CONFIG),
             ConfigType::Check => dirs::app_home_dir()?.join(CHECK_CONFIG),
         };
 
-        let runtime = Config::runtime().await;
+        let runtime = Config::runtime();
+        let runtime = runtime.latest();
         let config = runtime
-            .latest_ref()
             .config
             .as_ref()
-            .ok_or(anyhow!("failed to get runtime config"))?
-            .clone();
-        drop(runtime); // 显式释放锁
+            .ok_or(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"))?;
         Ok(path)
     }
 
@@ -155,11 +149,11 @@ impl Config {
     pub async fn generate() -> Result<()> {
         let (config, exists_keys, logs) = enhance::enhance().await;
 
-        *Config::runtime().await.draft_mut() = Box::new(IRuntime {
+        *Config::runtime().draft() = IRuntime {
             config: Some(config),
             exists_keys,
             chain_logs: logs,
-        });
+        };
 
         Ok(())
     }
@@ -170,42 +164,3 @@ pub enum ConfigType {
     Run,
     Check,
 }
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::mem;
-
-    #[test]
-    #[allow(unused_variables)]
-    #[allow(clippy::expect_used)]
-    fn test_prfitem_from_merge_size() {
-        let merge_item = PrfItem::from_merge(Some("Merge".to_string()))
-            .expect("Failed to create merge item in test");
-        let prfitem_size = mem::size_of_val(&merge_item);
-        // Boxed version
-        let boxed_merge_item = Box::new(merge_item);
-        let box_prfitem_size = mem::size_of_val(&boxed_merge_item);
-        // The size of Box<T> is always pointer-sized (usually 8 bytes on 64-bit)
-        // assert_eq!(box_prfitem_size, mem::size_of::<Box<PrfItem>>());
-        assert!(box_prfitem_size < prfitem_size);
-    }
-
-    #[test]
-    #[allow(unused_variables)]
-    fn test_draft_size_non_boxed() {
-        let draft = Draft::from(IRuntime::new());
-        let iruntime_size = std::mem::size_of_val(&draft);
-        assert_eq!(iruntime_size, std::mem::size_of::<Draft<IRuntime>>());
-    }
-
-    #[test]
-    #[allow(unused_variables)]
-    fn test_draft_size_boxed() {
-        let draft = Draft::from(Box::new(IRuntime::new()));
-        let box_iruntime_size = std::mem::size_of_val(&draft);
-        assert_eq!(
-            box_iruntime_size,
-            std::mem::size_of::<Draft<Box<IRuntime>>>()
-        );
-    }
-}

src-tauri/src/config/draft.rs

@@ -1,154 +1,127 @@
+use super::{IClashTemp, IProfiles, IRuntime, IVerge};
+use parking_lot::{MappedMutexGuard, Mutex, MutexGuard};
 use std::sync::Arc;
 
-use parking_lot::{
-    MappedRwLockReadGuard, MappedRwLockWriteGuard, RwLock, RwLockReadGuard,
-    RwLockUpgradableReadGuard, RwLockWriteGuard,
-};
-
 #[derive(Debug, Clone)]
 pub struct Draft<T: Clone + ToOwned> {
-    inner: Arc<RwLock<(T, Option<T>)>>,
+    inner: Arc<Mutex<(T, Option<T>)>>,
 }
 
-impl<T: Clone + ToOwned> From<T> for Draft<T> {
-    fn from(data: T) -> Self {
-        Self {
-            inner: Arc::new(RwLock::new((data, None))),
-        }
-    }
-}
+macro_rules! draft_define {
+    ($id: ident) => {
+        impl Draft<$id> {
+            #[allow(unused)]
+            pub fn data(&self) -> MappedMutexGuard<$id> {
+                MutexGuard::map(self.inner.lock(), |guard| &mut guard.0)
+            }
 
-/// 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)
-    }
-
-    /// 返回正式数据的只读视图（不包含草稿）
-    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")
+            pub fn latest(&self) -> MappedMutexGuard<$id> {
+                MutexGuard::map(self.inner.lock(), |inner| {
+                    if inner.1.is_none() {
+                        &mut inner.0
+                    } else {
+                        inner.1.as_mut().unwrap()
+                    }
                 })
-            });
+            }
+
+            pub fn draft(&self) -> MappedMutexGuard<$id> {
+                MutexGuard::map(self.inner.lock(), |inner| {
+                    if inner.1.is_none() {
+                        inner.1 = Some(inner.0.clone());
+                    }
+
+                    inner.1.as_mut().unwrap()
+                })
+            }
+
+            pub fn apply(&self) -> Option<$id> {
+                let mut inner = self.inner.lock();
+
+                match inner.1.take() {
+                    Some(draft) => {
+                        let old_value = inner.0.to_owned();
+                        inner.0 = draft.to_owned();
+                        Some(old_value)
+                    }
+                    None => None,
+                }
+            }
+
+            pub fn discard(&self) -> Option<$id> {
+                let mut inner = self.inner.lock();
+                inner.1.take()
+            }
         }
-        // 已存在草稿，升级为写锁映射
-        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
-            .1
-            .take()
-            .map(|draft| std::mem::replace(&mut inner.0, draft))
-    }
-
-    /// 丢弃草稿，返回被丢弃的草稿
-    pub fn discard(&self) -> Option<Box<T>> {
-        self.inner.write().1.take()
-    }
+        impl From<$id> for Draft<$id> {
+            fn from(data: $id) -> Self {
+                Draft {
+                    inner: Arc::new(Mutex::new((data, None))),
+                }
+            }
+        }
+    };
 }
 
+// draft_define!(IClash);
+draft_define!(IClashTemp);
+draft_define!(IProfiles);
+draft_define!(IRuntime);
+draft_define!(IVerge);
+
 #[test]
-fn test_draft_box() {
-    use super::IVerge;
-
-    // 1. 创建 Draft<Box<IVerge>>
-    let verge = Box::new(IVerge {
+fn test_draft() {
+    let verge = 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));
-    }
+    assert_eq!(draft.data().enable_auto_launch, Some(true));
+    assert_eq!(draft.data().enable_tun_mode, Some(false));
 
-    // 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));
-    }
+    assert_eq!(draft.draft().enable_auto_launch, Some(true));
+    assert_eq!(draft.draft().enable_tun_mode, Some(false));
 
-    // 4. 修改草稿
-    {
-        let mut d = draft.draft_mut();
-        d.enable_auto_launch = Some(false);
-        d.enable_tun_mode = Some(true);
-    }
+    let mut d = draft.draft();
+    d.enable_auto_launch = Some(false);
+    d.enable_tun_mode = Some(true);
+    drop(d);
 
-    // 正式数据未变
-    assert_eq!(draft.data_mut().enable_auto_launch, Some(true));
-    assert_eq!(draft.data_mut().enable_tun_mode, Some(false));
+    assert_eq!(draft.data().enable_auto_launch, Some(true));
+    assert_eq!(draft.data().enable_tun_mode, Some(false));
 
-    // 草稿已变
-    {
-        let latest = draft.latest_ref();
-        assert_eq!(latest.enable_auto_launch, Some(false));
-        assert_eq!(latest.enable_tun_mode, Some(true));
-    }
+    assert_eq!(draft.draft().enable_auto_launch, Some(false));
+    assert_eq!(draft.draft().enable_tun_mode, Some(true));
 
-    // 5. 提交草稿
-    assert!(draft.apply().is_some()); // 第一次提交应有返回
-    assert!(draft.apply().is_none()); // 第二次提交返回 None
+    assert_eq!(draft.latest().enable_auto_launch, Some(false));
+    assert_eq!(draft.latest().enable_tun_mode, Some(true));
 
-    // 正式数据已更新
-    {
-        let data = draft.data_mut();
-        assert_eq!(data.enable_auto_launch, Some(false));
-        assert_eq!(data.enable_tun_mode, Some(true));
-    }
+    assert!(draft.apply().is_some());
+    assert!(draft.apply().is_none());
 
-    // 6. 新建并修改下一轮草稿
-    {
-        let mut d = draft.draft_mut();
-        d.enable_auto_launch = Some(true);
-    }
-    assert_eq!(draft.draft_mut().enable_auto_launch, Some(true));
+    assert_eq!(draft.data().enable_auto_launch, Some(false));
+    assert_eq!(draft.data().enable_tun_mode, Some(true));
 
-    // 7. 丢弃草稿
-    assert!(draft.discard().is_some()); // 第一次丢弃返回 Some
-    assert!(draft.discard().is_none()); // 再次丢弃返回 None
+    assert_eq!(draft.draft().enable_auto_launch, Some(false));
+    assert_eq!(draft.draft().enable_tun_mode, Some(true));
 
-    // 8. 草稿已被丢弃，新的 draft_mut() 会重新 clone
-    assert_eq!(draft.draft_mut().enable_auto_launch, Some(false));
+    let mut d = draft.draft();
+    d.enable_auto_launch = Some(true);
+    drop(d);
+
+    assert_eq!(draft.data().enable_auto_launch, Some(false));
+
+    assert_eq!(draft.draft().enable_auto_launch, Some(true));
+
+    assert!(draft.discard().is_some());
+
+    assert_eq!(draft.data().enable_auto_launch, Some(false));
+
+    assert!(draft.discard().is_none());
+
+    assert_eq!(draft.draft().enable_auto_launch, Some(false));
 }

src-tauri/src/config/encrypt.rs

@@ -1,9 +1,9 @@
 use crate::utils::dirs::get_encryption_key;
 use aes_gcm::{
-    Aes256Gcm, Key,
     aead::{Aead, KeyInit},
+    Aes256Gcm, Key,
 };
-use base64::{Engine, engine::general_purpose::STANDARD};
+use base64::{engine::general_purpose::STANDARD, Engine};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 const NONCE_LENGTH: usize = 12;
@@ -21,7 +21,7 @@ pub fn encrypt_data(data: &str) -> Result<String, Box<dyn std::error::Error>> {
     // Encrypt data
     let ciphertext = cipher
         .encrypt(nonce.as_slice().into(), data.as_bytes())
-        .map_err(|e| format!("Encryption failed: {e}"))?;
+        .map_err(|e| format!("Encryption failed: {}", e))?;
 
     // Concatenate nonce and ciphertext and encode them in base64
     let mut combined = nonce;
@@ -46,7 +46,7 @@ pub fn decrypt_data(encrypted: &str) -> Result<String, Box<dyn std::error::Error
     // Decrypt data
     let plaintext = cipher
         .decrypt(nonce.into(), ciphertext)
-        .map_err(|e| format!("Decryption failed: {e}"))?;
+        .map_err(|e| format!("Decryption failed: {}", e))?;
 
     String::from_utf8(plaintext).map_err(|e| e.into())
 }

src-tauri/src/config/mod.rs

@@ -4,7 +4,7 @@ mod config;
 mod draft;
 mod encrypt;
 mod prfitem;
-pub mod profiles;
+mod profiles;
 mod runtime;
 mod verge;
 

src-tauri/src/config/prfitem.rs

@@ -3,11 +3,14 @@ use crate::utils::{
     network::{NetworkManager, ProxyType},
     tmpl,
 };
-use anyhow::{Context, Result, bail};
+use anyhow::{bail, Context, Result};
+use reqwest::StatusCode;
 use serde::{Deserialize, Serialize};
-use serde_yaml_ng::Mapping;
+use serde_yaml::Mapping;
 use std::{fs, time::Duration};
 
+use super::Config;
+
 #[derive(Debug, Clone, Deserialize, Serialize, Default)]
 pub struct PrfItem {
     pub uid: Option<String>,
@@ -144,15 +147,12 @@ impl PrfItem {
             bail!("type should not be null");
         }
 
-        let itype = item
-            .itype
-            .ok_or_else(|| anyhow::anyhow!("type should not be null"))?;
-        match itype.as_str() {
+        match item.itype.unwrap().as_str() {
             "remote" => {
-                let url = item
-                    .url
-                    .as_ref()
-                    .ok_or_else(|| anyhow::anyhow!("url should not be null"))?;
+                if item.url.is_none() {
+                    bail!("url should not be null");
+                }
+                let url = item.url.as_ref().unwrap().as_str();
                 let name = item.name;
                 let desc = item.desc;
                 PrfItem::from_url(url, name, desc, item.option).await
@@ -160,7 +160,7 @@ impl PrfItem {
             "local" => {
                 let name = item.name.unwrap_or("Local File".into());
                 let desc = item.desc.unwrap_or("".into());
-                PrfItem::from_local(name, desc, file_data, item.option).await
+                PrfItem::from_local(name, desc, file_data, item.option)
             }
             typ => bail!("invalid profile item type \"{typ}\""),
         }
@@ -168,7 +168,7 @@ impl PrfItem {
 
     /// ## Local type
     /// create a new item from name/desc
-    pub async fn from_local(
+    pub fn from_local(
         name: String,
         desc: String,
         file_data: Option<String>,
@@ -186,27 +186,29 @@ impl PrfItem {
 
         if merge.is_none() {
             let merge_item = PrfItem::from_merge(None)?;
-            crate::config::profiles::profiles_append_item_safe(merge_item.clone()).await?;
+            Config::profiles().data().append_item(merge_item.clone())?;
             merge = merge_item.uid;
         }
         if script.is_none() {
             let script_item = PrfItem::from_script(None)?;
-            crate::config::profiles::profiles_append_item_safe(script_item.clone()).await?;
+            Config::profiles().data().append_item(script_item.clone())?;
             script = script_item.uid;
         }
         if rules.is_none() {
             let rules_item = PrfItem::from_rules()?;
-            crate::config::profiles::profiles_append_item_safe(rules_item.clone()).await?;
+            Config::profiles().data().append_item(rules_item.clone())?;
             rules = rules_item.uid;
         }
         if proxies.is_none() {
             let proxies_item = PrfItem::from_proxies()?;
-            crate::config::profiles::profiles_append_item_safe(proxies_item.clone()).await?;
+            Config::profiles()
+                .data()
+                .append_item(proxies_item.clone())?;
             proxies = proxies_item.uid;
         }
         if groups.is_none() {
             let groups_item = PrfItem::from_groups()?;
-            crate::config::profiles::profiles_append_item_safe(groups_item.clone()).await?;
+            Config::profiles().data().append_item(groups_item.clone())?;
             groups = groups_item.uid;
         }
         Ok(PrfItem {
@@ -265,7 +267,7 @@ impl PrfItem {
         };
 
         // 使用网络管理器发送请求
-        let resp = match NetworkManager::new()
+        let resp = match NetworkManager::global()
             .get_with_interrupt(
                 url,
                 proxy_type,
@@ -283,7 +285,7 @@ impl PrfItem {
         };
 
         let status_code = resp.status();
-        if !status_code.is_success() {
+        if !StatusCode::is_success(&status_code) {
             bail!("failed to fetch remote profile with status {status_code}")
         }
 
@@ -349,13 +351,13 @@ impl PrfItem {
         let uid = help::get_uid("R");
         let file = format!("{uid}.yaml");
         let name = name.unwrap_or(filename.unwrap_or("Remote File".into()));
-        let data = resp.text_with_charset()?;
+        let data = resp.text_with_charset("utf-8").await?;
 
         // process the charset "UTF-8 with BOM"
         let data = data.trim_start_matches('\u{feff}');
 
         // check the data whether the valid yaml format
-        let yaml = serde_yaml_ng::from_str::<Mapping>(data)
+        let yaml = serde_yaml::from_str::<Mapping>(data)
             .context("the remote profile data is invalid yaml")?;
 
         if !yaml.contains_key("proxies") && !yaml.contains_key("proxy-providers") {
@@ -364,27 +366,29 @@ impl PrfItem {
 
         if merge.is_none() {
             let merge_item = PrfItem::from_merge(None)?;
-            crate::config::profiles::profiles_append_item_safe(merge_item.clone()).await?;
+            Config::profiles().data().append_item(merge_item.clone())?;
             merge = merge_item.uid;
         }
         if script.is_none() {
             let script_item = PrfItem::from_script(None)?;
-            crate::config::profiles::profiles_append_item_safe(script_item.clone()).await?;
+            Config::profiles().data().append_item(script_item.clone())?;
             script = script_item.uid;
         }
         if rules.is_none() {
             let rules_item = PrfItem::from_rules()?;
-            crate::config::profiles::profiles_append_item_safe(rules_item.clone()).await?;
+            Config::profiles().data().append_item(rules_item.clone())?;
             rules = rules_item.uid;
         }
         if proxies.is_none() {
             let proxies_item = PrfItem::from_proxies()?;
-            crate::config::profiles::profiles_append_item_safe(proxies_item.clone()).await?;
+            Config::profiles()
+                .data()
+                .append_item(proxies_item.clone())?;
             proxies = proxies_item.uid;
         }
         if groups.is_none() {
             let groups_item = PrfItem::from_groups()?;
-            crate::config::profiles::profiles_append_item_safe(groups_item.clone()).await?;
+            Config::profiles().data().append_item(groups_item.clone())?;
             groups = groups_item.uid;
         }
 
@@ -529,20 +533,22 @@ impl PrfItem {
 
     /// get the file data
     pub fn read_file(&self) -> Result<String> {
-        let file = self
-            .file
-            .clone()
-            .ok_or_else(|| anyhow::anyhow!("could not find the file"))?;
+        if self.file.is_none() {
+            bail!("could not find the file");
+        }
+
+        let file = self.file.clone().unwrap();
         let path = dirs::app_profiles_dir()?.join(file);
         fs::read_to_string(path).context("failed to read the file")
     }
 
     /// save the file data
     pub fn save_file(&self, data: String) -> Result<()> {
-        let file = self
-            .file
-            .clone()
-            .ok_or_else(|| anyhow::anyhow!("could not find the file"))?;
+        if self.file.is_none() {
+            bail!("could not find the file");
+        }
+
+        let file = self.file.clone().unwrap();
         let path = dirs::app_profiles_dir()?.join(file);
         fs::write(path, data.as_bytes()).context("failed to save the file")
     }

src-tauri/src/config/profiles.rs

@@ -1,14 +1,9 @@
-use super::{PrfOption, prfitem::PrfItem};
-use crate::{
-    logging_error,
-    process::AsyncHandler,
-    utils::{dirs, help, logging::Type},
-};
-use anyhow::{Context, Result, bail};
+use super::{prfitem::PrfItem, PrfOption};
+use crate::utils::{dirs, help};
+use anyhow::{bail, Context, Result};
 use serde::{Deserialize, Serialize};
-use serde_yaml_ng::Mapping;
-use std::collections::HashSet;
-use tokio::fs;
+use serde_yaml::Mapping;
+use std::{fs, io::Write};
 
 /// Define the `profiles.yaml` schema
 #[derive(Default, Debug, Clone, Deserialize, Serialize)]
@@ -20,14 +15,6 @@ pub struct IProfiles {
     pub items: Option<Vec<PrfItem>>,
 }
 
-/// 清理结果
-#[derive(Debug, Clone)]
-pub struct CleanupResult {
-    pub total_files: usize,
-    pub deleted_files: Vec<String>,
-    pub failed_deletions: Vec<String>,
-}
-
 macro_rules! patch {
     ($lv: expr, $rv: expr, $key: tt) => {
         if ($rv.$key).is_some() {
@@ -37,28 +24,22 @@ macro_rules! patch {
 }
 
 impl IProfiles {
-    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"));
-                            }
+    pub fn new() -> Self {
+        match dirs::profiles_path().and_then(|path| help::read_yaml::<Self>(&path)) {
+            Ok(mut profiles) => {
+                if profiles.items.is_none() {
+                    profiles.items = Some(vec![]);
+                }
+                // compatible with the old old old version
+                if let Some(items) = profiles.items.as_mut() {
+                    for item in items.iter_mut() {
+                        if item.uid.is_none() {
+                            item.uid = Some(help::get_uid("d"));
                         }
                     }
-                    profiles
                 }
-                Err(err) => {
-                    log::error!(target: "app", "{err}");
-                    Self::template()
-                }
-            },
+                profiles
+            }
             Err(err) => {
                 log::error!(target: "app", "{err}");
                 Self::template()
@@ -73,13 +54,12 @@ impl IProfiles {
         }
     }
 
-    pub async fn save_file(&self) -> Result<()> {
+    pub fn save_file(&self) -> Result<()> {
         help::save_yaml(
             &dirs::profiles_path()?,
             self,
             Some("# Profiles Config for Clash Verge"),
         )
-        .await
     }
 
     /// 只修改current，valid和chain
@@ -88,9 +68,8 @@ impl IProfiles {
             self.items = Some(vec![]);
         }
 
-        if let Some(current) = patch.current
-            && let Some(items) = self.items.as_ref()
-        {
+        if let Some(current) = patch.current {
+            let items = self.items.as_ref().unwrap();
             let some_uid = Some(current);
             if items.iter().any(|e| e.uid == some_uid) {
                 self.current = some_uid;
@@ -127,7 +106,7 @@ impl IProfiles {
     /// 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<()> {
+    pub fn append_item(&mut self, mut item: PrfItem) -> Result<()> {
         if item.uid.is_none() {
             bail!("the uid should not be null");
         }
@@ -140,14 +119,13 @@ impl IProfiles {
                 bail!("the file should not be null");
             }
 
-            let file = item.file.clone().ok_or_else(|| {
-                anyhow::anyhow!("file field is required when file_data is provided")
-            })?;
+            let file = item.file.clone().unwrap();
             let path = dirs::app_profiles_dir()?.join(&file);
 
-            fs::write(&path, file_data.as_bytes())
-                .await
-                .with_context(|| format!("failed to write to file \"{file}\""))?;
+            fs::File::create(path)
+                .with_context(|| format!("failed to create file \"{}\"", file))?
+                .write(file_data.as_bytes())
+                .with_context(|| format!("failed to write to file \"{}\"", file))?;
         }
 
         if self.current.is_none()
@@ -164,11 +142,11 @@ impl IProfiles {
             items.push(item)
         }
 
-        self.save_file().await
+        self.save_file()
     }
 
     /// reorder items
-    pub async fn reorder(&mut self, active_id: String, over_id: String) -> Result<()> {
+    pub fn reorder(&mut self, active_id: String, over_id: String) -> Result<()> {
         let mut items = self.items.take().unwrap_or_default();
         let mut old_index = None;
         let mut new_index = None;
@@ -182,18 +160,17 @@ impl IProfiles {
             }
         }
 
-        let (old_idx, new_idx) = match (old_index, new_index) {
-            (Some(old), Some(new)) => (old, new),
-            _ => return Ok(()),
-        };
-        let item = items.remove(old_idx);
-        items.insert(new_idx, item);
+        if old_index.is_none() || new_index.is_none() {
+            return Ok(());
+        }
+        let item = items.remove(old_index.unwrap());
+        items.insert(new_index.unwrap(), item);
         self.items = Some(items);
-        self.save_file().await
+        self.save_file()
     }
 
     /// update the item value
-    pub async fn patch_item(&mut self, uid: String, item: PrfItem) -> Result<()> {
+    pub fn patch_item(&mut self, uid: String, item: PrfItem) -> Result<()> {
         let mut items = self.items.take().unwrap_or_default();
 
         for each in items.iter_mut() {
@@ -209,7 +186,7 @@ impl IProfiles {
                 patch!(each, item, option);
 
                 self.items = Some(items);
-                return self.save_file().await;
+                return self.save_file();
             }
         }
 
@@ -219,7 +196,7 @@ 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 fn update_item(&mut self, uid: String, mut item: PrfItem) -> Result<()> {
         if self.items.is_none() {
             self.items = Some(vec![]);
         }
@@ -248,9 +225,10 @@ impl IProfiles {
 
                         let path = dirs::app_profiles_dir()?.join(&file);
 
-                        fs::write(&path, file_data.as_bytes())
-                            .await
-                            .with_context(|| format!("failed to write to file \"{file}\""))?;
+                        fs::File::create(path)
+                            .with_context(|| format!("failed to create file \"{}\"", file))?
+                            .write(file_data.as_bytes())
+                            .with_context(|| format!("failed to write to file \"{}\"", file))?;
                     }
 
                     break;
@@ -258,12 +236,12 @@ impl IProfiles {
             }
         }
 
-        self.save_file().await
+        self.save_file()
     }
 
     /// delete item
     /// if delete the current then return true
-    pub async fn delete_item(&mut self, uid: String) -> Result<bool> {
+    pub fn delete_item(&mut self, uid: String) -> Result<bool> {
         let current = self.current.as_ref().unwrap_or(&uid);
         let current = current.clone();
         let item = self.get_item(&uid)?;
@@ -287,24 +265,15 @@ impl IProfiles {
                 break;
             }
         }
-        if let Some(index) = index
-            && let Some(file) = items.remove(index).file
-        {
-            let _ = dirs::app_profiles_dir().map(async move |path| {
-                let path = path.join(file);
-                if path.exists() {
-                    let result = fs::remove_file(path.clone()).await;
-                    if let Err(err) = result {
-                        logging_error!(
-                            Type::Config,
-                            false,
-                            "[配置文件删除] 删除文件 {} 失败: {}",
-                            path.display(),
-                            err
-                        );
+        if let Some(index) = index {
+            if let Some(file) = items.remove(index).file {
+                let _ = dirs::app_profiles_dir().map(|path| {
+                    let path = path.join(file);
+                    if path.exists() {
+                        let _ = fs::remove_file(path);
                     }
-                }
-            });
+                });
+            }
         }
         // get the merge index
         for (i, _) in items.iter().enumerate() {
@@ -313,24 +282,15 @@ impl IProfiles {
                 break;
             }
         }
-        if let Some(index) = merge_index
-            && let Some(file) = items.remove(index).file
-        {
-            let _ = dirs::app_profiles_dir().map(async move |path| {
-                let path = path.join(file);
-                if path.exists() {
-                    let result = fs::remove_file(path.clone()).await;
-                    if let Err(err) = result {
-                        logging_error!(
-                            Type::Config,
-                            false,
-                            "[配置文件删除] 删除文件 {} 失败: {}",
-                            path.display(),
-                            err
-                        );
+        if let Some(index) = merge_index {
+            if let Some(file) = items.remove(index).file {
+                let _ = dirs::app_profiles_dir().map(|path| {
+                    let path = path.join(file);
+                    if path.exists() {
+                        let _ = fs::remove_file(path);
                     }
-                }
-            });
+                });
+            }
         }
         // get the script index
         for (i, _) in items.iter().enumerate() {
@@ -339,24 +299,15 @@ impl IProfiles {
                 break;
             }
         }
-        if let Some(index) = script_index
-            && let Some(file) = items.remove(index).file
-        {
-            let _ = dirs::app_profiles_dir().map(async move |path| {
-                let path = path.join(file);
-                if path.exists() {
-                    let result = fs::remove_file(path.clone()).await;
-                    if let Err(err) = result {
-                        logging_error!(
-                            Type::Config,
-                            false,
-                            "[配置文件删除] 删除文件 {} 失败: {}",
-                            path.display(),
-                            err
-                        );
+        if let Some(index) = script_index {
+            if let Some(file) = items.remove(index).file {
+                let _ = dirs::app_profiles_dir().map(|path| {
+                    let path = path.join(file);
+                    if path.exists() {
+                        let _ = fs::remove_file(path);
                     }
-                }
-            });
+                });
+            }
         }
         // get the rules index
         for (i, _) in items.iter().enumerate() {
@@ -365,24 +316,15 @@ impl IProfiles {
                 break;
             }
         }
-        if let Some(index) = rules_index
-            && let Some(file) = items.remove(index).file
-        {
-            let _ = dirs::app_profiles_dir().map(async move |path| {
-                let path = path.join(file);
-                if path.exists() {
-                    let result = fs::remove_file(path.clone()).await;
-                    if let Err(err) = result {
-                        logging_error!(
-                            Type::Config,
-                            false,
-                            "[配置文件删除] 删除文件 {} 失败: {}",
-                            path.display(),
-                            err
-                        );
+        if let Some(index) = rules_index {
+            if let Some(file) = items.remove(index).file {
+                let _ = dirs::app_profiles_dir().map(|path| {
+                    let path = path.join(file);
+                    if path.exists() {
+                        let _ = fs::remove_file(path);
                     }
-                }
-            });
+                });
+            }
         }
         // get the proxies index
         for (i, _) in items.iter().enumerate() {
@@ -391,24 +333,15 @@ impl IProfiles {
                 break;
             }
         }
-        if let Some(index) = proxies_index
-            && let Some(file) = items.remove(index).file
-        {
-            let _ = dirs::app_profiles_dir().map(async move |path| {
-                let path = path.join(file);
-                if path.exists() {
-                    let result = fs::remove_file(path.clone()).await;
-                    if let Err(err) = result {
-                        logging_error!(
-                            Type::Config,
-                            false,
-                            "[配置文件删除] 删除文件 {} 失败: {}",
-                            path.display(),
-                            err
-                        );
+        if let Some(index) = proxies_index {
+            if let Some(file) = items.remove(index).file {
+                let _ = dirs::app_profiles_dir().map(|path| {
+                    let path = path.join(file);
+                    if path.exists() {
+                        let _ = fs::remove_file(path);
                     }
-                }
-            });
+                });
+            }
         }
         // get the groups index
         for (i, _) in items.iter().enumerate() {
@@ -417,24 +350,15 @@ impl IProfiles {
                 break;
             }
         }
-        if let Some(index) = groups_index
-            && let Some(file) = items.remove(index).file
-        {
-            let _ = dirs::app_profiles_dir().map(async move |path| {
-                let path = path.join(file);
-                if path.exists() {
-                    let result = fs::remove_file(path.clone()).await;
-                    if let Err(err) = result {
-                        logging_error!(
-                            Type::Config,
-                            false,
-                            "[配置文件删除] 删除文件 {} 失败: {}",
-                            path.display(),
-                            err
-                        );
+        if let Some(index) = groups_index {
+            if let Some(file) = items.remove(index).file {
+                let _ = dirs::app_profiles_dir().map(|path| {
+                    let path = path.join(file);
+                    if path.exists() {
+                        let _ = fs::remove_file(path);
                     }
-                }
-            });
+                });
+            }
         }
         // delete the original uid
         if current == uid {
@@ -450,12 +374,12 @@ impl IProfiles {
         }
 
         self.items = Some(items);
-        self.save_file().await?;
+        self.save_file()?;
         Ok(current == uid)
     }
 
     /// 获取current指向的订阅内容
-    pub async fn current_mapping(&self) -> Result<Mapping> {
+    pub fn current_mapping(&self) -> Result<Mapping> {
         match (self.current.as_ref(), self.items.as_ref()) {
             (Some(current), Some(items)) => {
                 if let Some(item) = items.iter().find(|e| e.uid.as_ref() == Some(current)) {
@@ -463,7 +387,7 @@ impl IProfiles {
                         Some(file) => dirs::app_profiles_dir()?.join(file),
                         None => bail!("failed to get the file field"),
                     };
-                    return help::read_mapping(&file_path).await;
+                    return help::read_mapping(&file_path);
                 }
                 bail!("failed to find the current profile \"uid:{current}\"");
             }
@@ -561,263 +485,4 @@ impl IProfiles {
                 .collect()
         })
     }
-
-    /// 以 app 中的 profile 列表为准，删除不再需要的文件
-    pub fn cleanup_orphaned_files(&self) -> Result<CleanupResult> {
-        let profiles_dir = dirs::app_profiles_dir()?;
-
-        if !profiles_dir.exists() {
-            return Ok(CleanupResult {
-                total_files: 0,
-                deleted_files: vec![],
-                failed_deletions: vec![],
-            });
-        }
-
-        // 获取所有 active profile 的文件名集合
-        let active_files = self.get_all_active_files();
-
-        // 添加全局扩展配置文件到保护列表
-        let protected_files = self.get_protected_global_files();
-
-        // 扫描 profiles 目录下的所有文件
-        let mut total_files = 0;
-        let mut deleted_files = vec![];
-        let mut failed_deletions = vec![];
-
-        for entry in std::fs::read_dir(&profiles_dir)? {
-            let entry = entry?;
-            let path = entry.path();
-
-            if !path.is_file() {
-                continue;
-            }
-
-            total_files += 1;
-
-            if let Some(file_name) = path.file_name().and_then(|n| n.to_str())
-                && Self::is_profile_file(file_name)
-            {
-                // 检查是否为全局扩展文件
-                if protected_files.contains(file_name) {
-                    log::debug!(target: "app", "保护全局扩展配置文件: {file_name}");
-                    continue;
-                }
-
-                // 检查是否为活跃文件
-                if !active_files.contains(file_name) {
-                    match std::fs::remove_file(&path) {
-                        Ok(_) => {
-                            deleted_files.push(file_name.to_string());
-                            log::info!(target: "app", "已清理冗余文件: {file_name}");
-                        }
-                        Err(e) => {
-                            failed_deletions.push(format!("{file_name}: {e}"));
-                            log::warn!(target: "app", "清理文件失败: {file_name} - {e}");
-                        }
-                    }
-                }
-            }
-        }
-
-        let result = CleanupResult {
-            total_files,
-            deleted_files,
-            failed_deletions,
-        };
-
-        log::info!(
-            target: "app",
-            "Profile 文件清理完成: 总文件数={}, 删除文件数={}, 失败数={}",
-            result.total_files,
-            result.deleted_files.len(),
-            result.failed_deletions.len()
-        );
-
-        Ok(result)
-    }
-
-    /// 不删除全局扩展配置
-    fn get_protected_global_files(&self) -> HashSet<String> {
-        let mut protected_files = HashSet::new();
-
-        protected_files.insert("Merge.yaml".to_string());
-        protected_files.insert("Script.js".to_string());
-
-        protected_files
-    }
-
-    /// 获取所有 active profile 关联的文件名
-    fn get_all_active_files(&self) -> HashSet<String> {
-        let mut active_files = HashSet::new();
-
-        if let Some(items) = &self.items {
-            for item in items {
-                // 收集所有类型 profile 的文件
-                if let Some(file) = &item.file {
-                    active_files.insert(file.clone());
-                }
-
-                // 对于主 profile 类型（remote/local），还需要收集其关联的扩展文件
-                if let Some(itype) = &item.itype
-                    && (itype == "remote" || itype == "local")
-                    && let Some(option) = &item.option
-                {
-                    // 收集关联的扩展文件
-                    if let Some(merge_uid) = &option.merge
-                        && let Ok(merge_item) = self.get_item(merge_uid)
-                        && let Some(file) = &merge_item.file
-                    {
-                        active_files.insert(file.clone());
-                    }
-
-                    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());
-                    }
-
-                    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());
-                    }
-
-                    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());
-                    }
-
-                    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
-    }
-
-    /// 检查文件名是否符合 profile 文件的命名规则
-    fn is_profile_file(filename: &str) -> bool {
-        // 匹配各种 profile 文件格式
-        // R12345678.yaml (remote)
-        // L12345678.yaml (local)
-        // m12345678.yaml (merge)
-        // s12345678.js (script)
-        // r12345678.yaml (rules)
-        // p12345678.yaml (proxies)
-        // g12345678.yaml (groups)
-
-        let patterns = [
-            r"^[RL][a-zA-Z0-9]+\.yaml$",  // Remote/Local profiles
-            r"^m[a-zA-Z0-9]+\.yaml$",     // Merge files
-            r"^s[a-zA-Z0-9]+\.js$",       // Script files
-            r"^[rpg][a-zA-Z0-9]+\.yaml$", // Rules/Proxies/Groups files
-        ];
-
-        patterns.iter().any(|pattern| {
-            regex::Regex::new(pattern)
-                .map(|re| re.is_match(filename))
-                .unwrap_or(false)
-        })
-    }
-}
-
-// 特殊的Send-safe helper函数，完全避免跨await持有guard
-use crate::config::Config;
-
-pub async fn profiles_append_item_with_filedata_safe(
-    item: PrfItem,
-    file_data: Option<String>,
-) -> Result<()> {
-    AsyncHandler::spawn_blocking(move || {
-        AsyncHandler::handle().block_on(async {
-            let item = PrfItem::from(item, file_data).await?;
-            let profiles = Config::profiles().await;
-            let mut profiles_guard = profiles.data_mut();
-            profiles_guard.append_item(item).await
-        })
-    })
-    .await
-    .map_err(|e| anyhow::anyhow!("Task join error: {}", e))?
-}
-
-pub async fn profiles_append_item_safe(item: PrfItem) -> Result<()> {
-    AsyncHandler::spawn_blocking(move || {
-        AsyncHandler::handle().block_on(async {
-            let profiles = Config::profiles().await;
-            let mut profiles_guard = profiles.data_mut();
-            profiles_guard.append_item(item).await
-        })
-    })
-    .await
-    .map_err(|e| anyhow::anyhow!("Task join error: {}", e))?
-}
-
-pub async fn profiles_patch_item_safe(index: String, item: PrfItem) -> Result<()> {
-    AsyncHandler::spawn_blocking(move || {
-        AsyncHandler::handle().block_on(async {
-            let profiles = Config::profiles().await;
-            let mut profiles_guard = profiles.data_mut();
-            profiles_guard.patch_item(index, item).await
-        })
-    })
-    .await
-    .map_err(|e| anyhow::anyhow!("Task join error: {}", e))?
-}
-
-pub async fn profiles_delete_item_safe(index: String) -> Result<bool> {
-    AsyncHandler::spawn_blocking(move || {
-        AsyncHandler::handle().block_on(async {
-            let profiles = Config::profiles().await;
-            let mut profiles_guard = profiles.data_mut();
-            profiles_guard.delete_item(index).await
-        })
-    })
-    .await
-    .map_err(|e| anyhow::anyhow!("Task join error: {}", e))?
-}
-
-pub async fn profiles_reorder_safe(active_id: String, over_id: String) -> Result<()> {
-    AsyncHandler::spawn_blocking(move || {
-        AsyncHandler::handle().block_on(async {
-            let profiles = Config::profiles().await;
-            let mut profiles_guard = profiles.data_mut();
-            profiles_guard.reorder(active_id, over_id).await
-        })
-    })
-    .await
-    .map_err(|e| anyhow::anyhow!("Task join error: {}", e))?
-}
-
-pub async fn profiles_save_file_safe() -> Result<()> {
-    AsyncHandler::spawn_blocking(move || {
-        AsyncHandler::handle().block_on(async {
-            let profiles = Config::profiles().await;
-            let profiles_guard = profiles.data_mut();
-            profiles_guard.save_file().await
-        })
-    })
-    .await
-    .map_err(|e| anyhow::anyhow!("Task join error: {}", e))?
-}
-
-pub async fn profiles_draft_update_item_safe(index: String, item: PrfItem) -> Result<()> {
-    AsyncHandler::spawn_blocking(move || {
-        AsyncHandler::handle().block_on(async {
-            let profiles = Config::profiles().await;
-            let mut profiles_guard = profiles.draft_mut();
-            profiles_guard.update_item(index, item).await
-        })
-    })
-    .await
-    .map_err(|e| anyhow::anyhow!("Task join error: {}", e))?
 }

src-tauri/src/config/runtime.rs

@@ -1,6 +1,6 @@
 use crate::enhance::field::use_keys;
 use serde::{Deserialize, Serialize};
-use serde_yaml_ng::{Mapping, Value};
+use serde_yaml::{Mapping, Value};
 use std::collections::HashMap;
 #[derive(Default, Debug, Clone, Deserialize, Serialize)]
 pub struct IRuntime {
@@ -46,139 +46,4 @@ impl IRuntime {
             }
         }
     }
-
-    //跟新链式代理配置文件
-    /// {   
-    ///     "proxies":[
-    ///         {
-    ///             name : 入口节点,
-    ///             type: xxx
-    ///             server: xxx
-    ///             port: xxx
-    ///             ports: xxx
-    ///             password: xxx
-    ///             skip-cert-verify: xxx,
-    ///        },
-    ///         {
-    ///             name : hop_node_1_xxxx,
-    ///             type: xxx
-    ///             server: xxx
-    ///             port: xxx
-    ///             ports: xxx
-    ///             password: xxx
-    ///             skip-cert-verify: xxx,
-    ///             dialer-proxy : "入口节点"
-    ///        },
-    ///         {
-    ///             name : 出口节点,
-    ///             type: xxx
-    ///             server: xxx
-    ///             port: xxx
-    ///             ports: xxx
-    ///             password: xxx
-    ///             skip-cert-verify: xxx,
-    ///             dialer-proxy : "hop_node_1_xxxx"
-    ///        }
-    ///     ],
-    ///     "proxy-groups" : [
-    ///         {
-    ///             name : "proxy_chain",
-    ///             type: "select",
-    ///             proxies ["出口节点"]
-    ///         }
-    ///     ]
-    /// }
-    ///
-    /// 传入none 为删除
-    pub fn update_proxy_chain_config(&mut self, proxy_chain_config: Option<Value>) {
-        if let Some(config) = self.config.as_mut() {
-            // 获取 默认第一的代理组的名字
-            let proxy_group_name =
-                if let Some(Value::Sequence(proxy_groups)) = config.get("proxy-groups") {
-                    if let Some(Value::Mapping(proxy_group)) = proxy_groups.first() {
-                        if let Some(Value::String(proxy_group_name)) = proxy_group.get("name") {
-                            proxy_group_name.to_string()
-                        } else {
-                            "".to_string()
-                        }
-                    } else {
-                        "".to_string()
-                    }
-                } else {
-                    "".to_string()
-                };
-
-            if let Some(Value::Sequence(proxies)) = config.get_mut("proxies") {
-                proxies.iter_mut().for_each(|proxy| {
-                    if let Some(proxy) = proxy.as_mapping_mut()
-                        && proxy.get("dialer-proxy").is_some()
-                    {
-                        proxy.remove("dialer-proxy");
-                    }
-                });
-            }
-
-            // 清除proxy_chain代理组
-            if let Some(Value::Sequence(proxy_groups)) = config.get_mut("proxy-groups") {
-                proxy_groups.retain(|proxy_group| {
-                    !matches!(proxy_group.get("name").and_then(|n| n.as_str()), Some(name) if name== "proxy_chain")
-                });
-            }
-
-            // 清除rules
-            if let Some(Value::Sequence(rules)) = config.get_mut("rules") {
-                rules.retain(|rule| rule.as_str() != Some("MATCH,proxy_chain"));
-                rules.push(Value::String(format!("MATCH,{}", proxy_group_name)));
-            }
-
-            // some 则写入新配置
-            // 给proxy添加dialer-proxy字段
-            // 第一个proxy不添加dialer-proxy
-            // 然后第二个开始，dialer-proxy为上一个元素的name
-            if let Some(Value::Sequence(dialer_proxies)) = proxy_chain_config {
-                let mut proxy_chain_group = Mapping::new();
-
-                if let Some(Value::Sequence(proxies)) = config.get_mut("proxies") {
-                    for (i, dialer_proxy) in dialer_proxies.iter().enumerate() {
-                        if let Some(Value::Mapping(proxy)) = proxies
-                            .iter_mut()
-                            .find(|proxy| proxy.get("name") == Some(dialer_proxy))
-                        {
-                            if i != 0
-                                && let Some(dialer_proxy) = dialer_proxies.get(i - 1)
-                            {
-                                proxy.insert("dialer-proxy".into(), dialer_proxy.to_owned());
-                            }
-                            if i == dialer_proxies.len() - 1 {
-                                // 添加proxy-groups
-                                proxy_chain_group
-                                    .insert("name".into(), Value::String("proxy_chain".into()));
-                                proxy_chain_group
-                                    .insert("type".into(), Value::String("select".into()));
-                                proxy_chain_group.insert(
-                                    "proxies".into(),
-                                    Value::Sequence(vec![dialer_proxy.to_owned()]),
-                                );
-                            }
-                        }
-                    }
-                }
-
-                if let Some(Value::Sequence(proxy_groups)) = config.get_mut("proxy-groups") {
-                    proxy_groups.push(Value::Mapping(proxy_chain_group));
-                }
-
-                // 添加rules
-                if let Some(Value::Sequence(rules)) = config.get_mut("rules")
-                    && let Ok(rule) = serde_yaml_ng::to_value("MATCH,proxy_chain")
-                {
-                    rules.retain(|rule| {
-                        rule.as_str() != Some(&format!("MATCH,{}", proxy_group_name))
-                    });
-                    rules.push(rule);
-                    // *rules = vec![rule];
-                }
-            }
-        }
-    }
 }

src-tauri/src/config/verge.rs

@@ -1,7 +1,6 @@
 use crate::{
-    config::{DEFAULT_PAC, deserialize_encrypted, serialize_encrypted},
-    logging,
-    utils::{dirs, help, i18n, logging::Type},
+    config::{deserialize_encrypted, serialize_encrypted, DEFAULT_PAC},
+    utils::{dirs, help, i18n},
 };
 use anyhow::Result;
 use log::LevelFilter;
@@ -138,6 +137,9 @@ pub struct IVerge {
     /// 0: 不清理; 1: 1天；2: 7天; 3: 30天; 4: 90天
     pub auto_log_clean: Option<i32>,
 
+    /// 是否启用随机端口
+    pub enable_random_port: Option<bool>,
+
     /// verge 的各种 port 用于覆盖 clash 的各种 port
     #[cfg(not(target_os = "windows"))]
     pub verge_redir_port: Option<u16>,
@@ -198,11 +200,8 @@ pub struct IVerge {
     /// 自动进入轻量模式的延迟（分钟）
     pub auto_light_weight_minutes: Option<u64>,
 
-    /// 启用代理页面自动滚动
-    pub enable_hover_jump_navigator: Option<bool>,
-
-    /// 启用外部控制器
-    pub enable_external_controller: Option<bool>,
+    /// 服务状态跟踪
+    pub service_state: Option<crate::core::service::ServiceState>,
 }
 
 #[derive(Default, Debug, Clone, Deserialize, Serialize)]
@@ -230,93 +229,6 @@ pub struct IVergeTheme {
 }
 
 impl IVerge {
-    /// 有效的clash核心名称
-    pub const VALID_CLASH_CORES: &'static [&'static str] = &["verge-mihomo", "verge-mihomo-alpha"];
-
-    /// 验证并修正配置文件中的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 {
-            Ok(config) => config,
-            Err(_) => Self::template(),
-        };
-
-        let mut needs_fix = false;
-
-        if let Some(ref core) = config.clash_core {
-            let core_str = core.trim();
-            if core_str.is_empty() || !Self::VALID_CLASH_CORES.contains(&core_str) {
-                logging!(
-                    warn,
-                    Type::Config,
-                    true,
-                    "启动时发现无效的clash_core配置: '{}', 将自动修正为 'verge-mihomo'",
-                    core
-                );
-                config.clash_core = Some("verge-mihomo".to_string());
-                needs_fix = true;
-            }
-        } else {
-            logging!(
-                info,
-                Type::Config,
-                true,
-                "启动时发现未配置clash_core, 将设置为默认值 'verge-mihomo'"
-            );
-            config.clash_core = Some("verge-mihomo".to_string());
-            needs_fix = true;
-        }
-
-        // 修正后保存配置
-        if needs_fix {
-            logging!(info, Type::Config, true, "正在保存修正后的配置文件...");
-            help::save_yaml(&config_path, &config, Some("# Clash Verge Config")).await?;
-            logging!(
-                info,
-                Type::Config,
-                true,
-                "配置文件修正完成，需要重新加载配置"
-            );
-
-            Self::reload_config_after_fix(config).await?;
-        } else {
-            logging!(
-                info,
-                Type::Config,
-                true,
-                "clash_core配置验证通过: {:?}",
-                config.clash_core
-            );
-        }
-
-        Ok(())
-    }
-
-    /// 配置修正后重新加载配置
-    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();
-
-        logging!(
-            info,
-            Type::Config,
-            true,
-            "内存配置已强制更新，新的clash_core: {:?}",
-            updated_config.clash_core
-        );
-
-        Ok(())
-    }
-
-    pub fn get_valid_clash_core(&self) -> String {
-        self.clash_core
-            .clone()
-            .unwrap_or_else(|| "verge-mihomo".to_string())
-    }
-
     fn get_system_language() -> String {
         let sys_lang = sys_locale::get_locale()
             .unwrap_or_else(|| String::from("en"))
@@ -332,15 +244,9 @@ impl IVerge {
         }
     }
 
-    pub async fn new() -> Self {
-        match dirs::verge_path() {
-            Ok(path) => match help::read_yaml::<IVerge>(&path).await {
-                Ok(config) => config,
-                Err(err) => {
-                    log::error!(target: "app", "{err}");
-                    Self::template()
-                }
-            },
+    pub fn new() -> Self {
+        match dirs::verge_path().and_then(|path| help::read_yaml::<IVerge>(&path)) {
+            Ok(config) => config,
             Err(err) => {
                 log::error!(target: "app", "{err}");
                 Self::template()
@@ -369,11 +275,11 @@ impl IVerge {
             tun_tray_icon: Some(false),
             enable_auto_launch: Some(false),
             enable_silent_start: Some(false),
-            enable_hover_jump_navigator: Some(true),
             enable_system_proxy: Some(false),
             proxy_auto_config: Some(false),
             pac_file_content: Some(DEFAULT_PAC.into()),
             proxy_host: Some("127.0.0.1".into()),
+            enable_random_port: Some(false),
             #[cfg(not(target_os = "windows"))]
             verge_redir_port: Some(7895),
             #[cfg(not(target_os = "windows"))]
@@ -393,7 +299,7 @@ impl IVerge {
             auto_close_connection: Some(true),
             auto_check_update: Some(true),
             enable_builtin_enhanced: Some(true),
-            auto_log_clean: Some(2), // 1: 1天, 2: 7天, 3: 30天, 4: 90天
+            auto_log_clean: Some(3),
             webdav_url: None,
             webdav_username: None,
             webdav_password: None,
@@ -404,14 +310,14 @@ impl IVerge {
             auto_light_weight_minutes: Some(10),
             enable_dns_settings: Some(false),
             home_cards: None,
-            enable_external_controller: Some(false),
+            service_state: None,
             ..Self::default()
         }
     }
 
     /// Save IVerge App Config
-    pub async fn save_file(&self) -> Result<()> {
-        help::save_yaml(&dirs::verge_path()?, &self, Some("# Clash Verge Config")).await
+    pub fn save_file(&self) -> Result<()> {
+        help::save_yaml(&dirs::verge_path()?, &self, Some("# Clash Verge Config"))
     }
 
     /// patch verge config
@@ -445,7 +351,7 @@ impl IVerge {
         patch!(enable_tun_mode);
         patch!(enable_auto_launch);
         patch!(enable_silent_start);
-        patch!(enable_hover_jump_navigator);
+        patch!(enable_random_port);
         #[cfg(not(target_os = "windows"))]
         patch!(verge_redir_port);
         #[cfg(not(target_os = "windows"))]
@@ -491,7 +397,7 @@ impl IVerge {
         patch!(auto_light_weight_minutes);
         patch!(enable_dns_settings);
         patch!(home_cards);
-        patch!(enable_external_controller);
+        patch!(service_state);
     }
 
     /// 在初始化前尝试拿到单例端口的值
@@ -563,6 +469,7 @@ pub struct IVergeResponse {
     pub proxy_layout_column: Option<i32>,
     pub test_list: Option<Vec<IVergeTestItem>>,
     pub auto_log_clean: Option<i32>,
+    pub enable_random_port: Option<bool>,
     #[cfg(not(target_os = "windows"))]
     pub verge_redir_port: Option<u16>,
     #[cfg(not(target_os = "windows"))]
@@ -585,14 +492,11 @@ pub struct IVergeResponse {
     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 enable_external_controller: Option<bool>,
+    pub service_state: Option<crate::core::service::ServiceState>,
 }
 
 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,
             language: verge.language,
@@ -624,7 +528,7 @@ impl From<IVerge> for IVergeResponse {
             proxy_host: verge.proxy_host,
             theme_setting: verge.theme_setting,
             web_ui_list: verge.web_ui_list,
-            clash_core: Some(valid_clash_core),
+            clash_core: verge.clash_core,
             hotkeys: verge.hotkeys,
             auto_close_connection: verge.auto_close_connection,
             auto_check_update: verge.auto_check_update,
@@ -634,6 +538,7 @@ impl From<IVerge> for IVergeResponse {
             proxy_layout_column: verge.proxy_layout_column,
             test_list: verge.test_list,
             auto_log_clean: verge.auto_log_clean,
+            enable_random_port: verge.enable_random_port,
             #[cfg(not(target_os = "windows"))]
             verge_redir_port: verge.verge_redir_port,
             #[cfg(not(target_os = "windows"))]
@@ -656,8 +561,7 @@ impl From<IVerge> for IVergeResponse {
             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,
-            enable_external_controller: verge.enable_external_controller,
+            service_state: verge.service_state,
         }
     }
 }

src-tauri/src/core/async_proxy_query.rs

@@ -1,534 +0,0 @@
-#[cfg(target_os = "windows")]
-use crate::process::AsyncHandler;
-use anyhow::Result;
-use serde::{Deserialize, Serialize};
-use tokio::time::{Duration, timeout};
-
-#[cfg(target_os = "linux")]
-use anyhow::anyhow;
-#[cfg(not(target_os = "windows"))]
-use tokio::process::Command;
-
-#[derive(Debug, Clone, Serialize, Deserialize, Default)]
-pub struct AsyncAutoproxy {
-    pub enable: bool,
-    pub url: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct AsyncSysproxy {
-    pub enable: bool,
-    pub host: String,
-    pub port: u16,
-    pub bypass: String,
-}
-
-impl Default for AsyncSysproxy {
-    fn default() -> Self {
-        Self {
-            enable: false,
-            host: "127.0.0.1".to_string(),
-            port: 7897,
-            bypass: String::new(),
-        }
-    }
-}
-
-pub struct AsyncProxyQuery;
-
-impl AsyncProxyQuery {
-    /// 异步获取自动代理配置（PAC）
-    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);
-                proxy
-            }
-            Ok(Err(e)) => {
-                log::warn!(target: "app", "异步获取自动代理失败: {e}");
-                AsyncAutoproxy::default()
-            }
-            Err(_) => {
-                log::warn!(target: "app", "异步获取自动代理超时");
-                AsyncAutoproxy::default()
-            }
-        }
-    }
-
-    /// 异步获取系统代理配置
-    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);
-                proxy
-            }
-            Ok(Err(e)) => {
-                log::warn!(target: "app", "异步获取系统代理失败: {e}");
-                AsyncSysproxy::default()
-            }
-            Err(_) => {
-                log::warn!(target: "app", "异步获取系统代理超时");
-                AsyncSysproxy::default()
-            }
-        }
-    }
-
-    #[cfg(target_os = "windows")]
-    async fn get_auto_proxy_impl() -> Result<AsyncAutoproxy> {
-        // Windows: 从注册表读取PAC配置
-        AsyncHandler::spawn_blocking(move || -> Result<AsyncAutoproxy> {
-            Self::get_pac_config_from_registry()
-        })
-        .await?
-    }
-
-    #[cfg(target_os = "windows")]
-    fn get_pac_config_from_registry() -> Result<AsyncAutoproxy> {
-        use std::ptr;
-        use winapi::shared::minwindef::{DWORD, HKEY};
-        use winapi::um::winnt::{KEY_READ, REG_DWORD, REG_SZ};
-        use winapi::um::winreg::{HKEY_CURRENT_USER, RegCloseKey, RegOpenKeyExW, RegQueryValueExW};
-
-        unsafe {
-            let key_path = "Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\0"
-                .encode_utf16()
-                .collect::<Vec<u16>>();
-
-            let mut hkey: HKEY = ptr::null_mut();
-            let result =
-                RegOpenKeyExW(HKEY_CURRENT_USER, key_path.as_ptr(), 0, KEY_READ, &mut hkey);
-
-            if result != 0 {
-                log::debug!(target: "app", "无法打开注册表项");
-                return Ok(AsyncAutoproxy::default());
-            }
-
-            // 1. 检查自动配置是否启用 (AutoConfigURL 存在且不为空即表示启用)
-            let auto_config_url_name = "AutoConfigURL\0".encode_utf16().collect::<Vec<u16>>();
-            let mut url_buffer = vec![0u16; 1024];
-            let mut url_buffer_size: DWORD = (url_buffer.len() * 2) as DWORD;
-            let mut url_value_type: DWORD = 0;
-
-            let url_query_result = RegQueryValueExW(
-                hkey,
-                auto_config_url_name.as_ptr(),
-                ptr::null_mut(),
-                &mut url_value_type,
-                url_buffer.as_mut_ptr() as *mut u8,
-                &mut url_buffer_size,
-            );
-
-            let mut pac_url = String::new();
-            if url_query_result == 0 && url_value_type == REG_SZ && url_buffer_size > 0 {
-                let end_pos = url_buffer
-                    .iter()
-                    .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}");
-            }
-
-            // 2. 检查自动检测设置是否启用
-            let auto_detect_name = "AutoDetect\0".encode_utf16().collect::<Vec<u16>>();
-            let mut auto_detect: DWORD = 0;
-            let mut detect_buffer_size: DWORD = 4;
-            let mut detect_value_type: DWORD = 0;
-
-            let detect_query_result = RegQueryValueExW(
-                hkey,
-                auto_detect_name.as_ptr(),
-                ptr::null_mut(),
-                &mut detect_value_type,
-                &mut auto_detect as *mut DWORD as *mut u8,
-                &mut detect_buffer_size,
-            );
-
-            RegCloseKey(hkey);
-
-            // PAC 启用的条件：AutoConfigURL 不为空，或 AutoDetect 被启用
-            let pac_enabled = !pac_url.is_empty()
-                || (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}");
-
-                if pac_url.is_empty() && auto_detect != 0 {
-                    pac_url = "auto-detect".to_string();
-                }
-
-                Ok(AsyncAutoproxy {
-                    enable: true,
-                    url: pac_url,
-                })
-            } else {
-                log::debug!(target: "app", "PAC配置未启用");
-                Ok(AsyncAutoproxy::default())
-            }
-        }
-    }
-
-    #[cfg(target_os = "macos")]
-    async fn get_auto_proxy_impl() -> Result<AsyncAutoproxy> {
-        // macOS: 使用 scutil --proxy 命令
-        let output = Command::new("scutil").args(["--proxy"]).output().await?;
-
-        if !output.status.success() {
-            return Ok(AsyncAutoproxy::default());
-        }
-
-        let stdout = String::from_utf8_lossy(&output.stdout);
-        log::debug!(target: "app", "scutil output: {stdout}");
-
-        let mut pac_enabled = false;
-        let mut pac_url = String::new();
-
-        // 解析 scutil 输出
-        for line in stdout.lines() {
-            let line = line.trim();
-            if line.contains("ProxyAutoConfigEnable") && line.contains("1") {
-                pac_enabled = true;
-            } else if line.contains("ProxyAutoConfigURLString") {
-                // 正确解析包含冒号的URL
-                // 格式: "ProxyAutoConfigURLString : http://127.0.0.1:11233/commands/pac"
-                if let Some(colon_pos) = line.find(" : ") {
-                    pac_url = line[colon_pos + 3..].trim().to_string();
-                }
-            }
-        }
-
-        log::debug!(target: "app", "解析结果: pac_enabled={pac_enabled}, pac_url={pac_url}");
-
-        Ok(AsyncAutoproxy {
-            enable: pac_enabled && !pac_url.is_empty(),
-            url: pac_url,
-        })
-    }
-
-    #[cfg(target_os = "linux")]
-    async fn get_auto_proxy_impl() -> Result<AsyncAutoproxy> {
-        // Linux: 检查环境变量和GNOME设置
-
-        // 首先检查环境变量
-        if let Ok(auto_proxy) = std::env::var("auto_proxy")
-            && !auto_proxy.is_empty()
-        {
-            return Ok(AsyncAutoproxy {
-                enable: true,
-                url: auto_proxy,
-            });
-        }
-
-        // 尝试使用 gsettings 获取 GNOME 代理设置
-        let output = Command::new("gsettings")
-            .args(["get", "org.gnome.system.proxy", "mode"])
-            .output()
-            .await;
-
-        if let Ok(output) = output
-            && output.status.success()
-        {
-            let mode = String::from_utf8_lossy(&output.stdout).trim().to_string();
-            if mode.contains("auto") {
-                // 获取 PAC URL
-                let pac_output = Command::new("gsettings")
-                    .args(["get", "org.gnome.system.proxy", "autoconfig-url"])
-                    .output()
-                    .await;
-
-                if let Ok(pac_output) = pac_output
-                    && pac_output.status.success()
-                {
-                    let pac_url = String::from_utf8_lossy(&pac_output.stdout)
-                        .trim()
-                        .trim_matches('\'')
-                        .trim_matches('"')
-                        .to_string();
-
-                    if !pac_url.is_empty() {
-                        return Ok(AsyncAutoproxy {
-                            enable: true,
-                            url: pac_url,
-                        });
-                    }
-                }
-            }
-        }
-
-        Ok(AsyncAutoproxy::default())
-    }
-
-    #[cfg(target_os = "windows")]
-    async fn get_system_proxy_impl() -> Result<AsyncSysproxy> {
-        // Windows: 使用注册表直接读取代理设置
-        AsyncHandler::spawn_blocking(move || -> Result<AsyncSysproxy> {
-            Self::get_system_proxy_from_registry()
-        })
-        .await?
-    }
-
-    #[cfg(target_os = "windows")]
-    fn get_system_proxy_from_registry() -> Result<AsyncSysproxy> {
-        use std::ptr;
-        use winapi::shared::minwindef::{DWORD, HKEY};
-        use winapi::um::winnt::{KEY_READ, REG_DWORD, REG_SZ};
-        use winapi::um::winreg::{HKEY_CURRENT_USER, RegCloseKey, RegOpenKeyExW, RegQueryValueExW};
-
-        unsafe {
-            let key_path = "Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\0"
-                .encode_utf16()
-                .collect::<Vec<u16>>();
-
-            let mut hkey: HKEY = ptr::null_mut();
-            let result =
-                RegOpenKeyExW(HKEY_CURRENT_USER, key_path.as_ptr(), 0, KEY_READ, &mut hkey);
-
-            if result != 0 {
-                return Ok(AsyncSysproxy::default());
-            }
-
-            // 检查代理是否启用
-            let proxy_enable_name = "ProxyEnable\0".encode_utf16().collect::<Vec<u16>>();
-            let mut proxy_enable: DWORD = 0;
-            let mut buffer_size: DWORD = 4;
-            let mut value_type: DWORD = 0;
-
-            let enable_result = RegQueryValueExW(
-                hkey,
-                proxy_enable_name.as_ptr(),
-                ptr::null_mut(),
-                &mut value_type,
-                &mut proxy_enable as *mut DWORD as *mut u8,
-                &mut buffer_size,
-            );
-
-            if enable_result != 0 || value_type != REG_DWORD || proxy_enable == 0 {
-                RegCloseKey(hkey);
-                return Ok(AsyncSysproxy::default());
-            }
-
-            // 读取代理服务器设置
-            let proxy_server_name = "ProxyServer\0".encode_utf16().collect::<Vec<u16>>();
-            let mut buffer = vec![0u16; 1024];
-            let mut buffer_size: DWORD = (buffer.len() * 2) as DWORD;
-            let mut value_type: DWORD = 0;
-
-            let server_result = RegQueryValueExW(
-                hkey,
-                proxy_server_name.as_ptr(),
-                ptr::null_mut(),
-                &mut value_type,
-                buffer.as_mut_ptr() as *mut u8,
-                &mut buffer_size,
-            );
-
-            let mut proxy_server = String::new();
-            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]);
-            }
-
-            // 读取代理绕过列表
-            let proxy_override_name = "ProxyOverride\0".encode_utf16().collect::<Vec<u16>>();
-            let mut bypass_buffer = vec![0u16; 1024];
-            let mut bypass_buffer_size: DWORD = (bypass_buffer.len() * 2) as DWORD;
-            let mut bypass_value_type: DWORD = 0;
-
-            let override_result = RegQueryValueExW(
-                hkey,
-                proxy_override_name.as_ptr(),
-                ptr::null_mut(),
-                &mut bypass_value_type,
-                bypass_buffer.as_mut_ptr() as *mut u8,
-                &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]);
-            }
-
-            RegCloseKey(hkey);
-
-            if !proxy_server.is_empty() {
-                // 解析服务器地址和端口
-                let (host, port) = if let Some(colon_pos) = proxy_server.rfind(':') {
-                    let host = proxy_server[..colon_pos].to_string();
-                    let port = proxy_server[colon_pos + 1..].parse::<u16>().unwrap_or(8080);
-                    (host, port)
-                } else {
-                    (proxy_server, 8080)
-                };
-
-                log::debug!(target: "app", "从注册表读取到代理设置: {host}:{port}, bypass: {bypass_list}");
-
-                Ok(AsyncSysproxy {
-                    enable: true,
-                    host,
-                    port,
-                    bypass: bypass_list,
-                })
-            } else {
-                Ok(AsyncSysproxy::default())
-            }
-        }
-    }
-
-    #[cfg(target_os = "macos")]
-    async fn get_system_proxy_impl() -> Result<AsyncSysproxy> {
-        let output = Command::new("scutil").args(["--proxy"]).output().await?;
-
-        if !output.status.success() {
-            return Ok(AsyncSysproxy::default());
-        }
-
-        let stdout = String::from_utf8_lossy(&output.stdout);
-        log::debug!(target: "app", "scutil proxy output: {stdout}");
-
-        let mut http_enabled = false;
-        let mut http_host = String::new();
-        let mut http_port = 8080u16;
-        let mut exceptions = Vec::new();
-
-        for line in stdout.lines() {
-            let line = line.trim();
-            if line.contains("HTTPEnable") && line.contains("1") {
-                http_enabled = true;
-            } else if line.contains("HTTPProxy") && !line.contains("Port") {
-                if let Some(host_part) = line.split(':').nth(1) {
-                    http_host = host_part.trim().to_string();
-                }
-            } else if line.contains("HTTPPort") {
-                if let Some(port_part) = line.split(':').nth(1)
-                    && let Ok(port) = port_part.trim().parse::<u16>()
-                {
-                    http_port = port;
-                }
-            } else if line.contains("ExceptionsList") {
-                // 解析异常列表
-                if let Some(list_part) = line.split(':').nth(1) {
-                    let list = list_part.trim();
-                    if !list.is_empty() {
-                        exceptions.push(list.to_string());
-                    }
-                }
-            }
-        }
-
-        Ok(AsyncSysproxy {
-            enable: http_enabled && !http_host.is_empty(),
-            host: http_host,
-            port: http_port,
-            bypass: exceptions.join(","),
-        })
-    }
-
-    #[cfg(target_os = "linux")]
-    async fn get_system_proxy_impl() -> Result<AsyncSysproxy> {
-        // Linux: 检查环境变量和桌面环境设置
-
-        // 首先检查环境变量
-        if let Ok(http_proxy) = std::env::var("http_proxy")
-            && let Ok(proxy_info) = Self::parse_proxy_url(&http_proxy)
-        {
-            return Ok(proxy_info);
-        }
-
-        if let Ok(https_proxy) = std::env::var("https_proxy")
-            && let Ok(proxy_info) = Self::parse_proxy_url(&https_proxy)
-        {
-            return Ok(proxy_info);
-        }
-
-        // 尝试使用 gsettings 获取 GNOME 代理设置
-        let mode_output = Command::new("gsettings")
-            .args(["get", "org.gnome.system.proxy", "mode"])
-            .output()
-            .await;
-
-        if let Ok(mode_output) = mode_output
-            && mode_output.status.success()
-        {
-            let mode = String::from_utf8_lossy(&mode_output.stdout)
-                .trim()
-                .to_string();
-            if mode.contains("manual") {
-                // 获取HTTP代理设置
-                let host_result = Command::new("gsettings")
-                    .args(["get", "org.gnome.system.proxy.http", "host"])
-                    .output()
-                    .await;
-
-                let port_result = Command::new("gsettings")
-                    .args(["get", "org.gnome.system.proxy.http", "port"])
-                    .output()
-                    .await;
-
-                if let (Ok(host_output), Ok(port_output)) = (host_result, port_result)
-                    && host_output.status.success()
-                    && port_output.status.success()
-                {
-                    let host = String::from_utf8_lossy(&host_output.stdout)
-                        .trim()
-                        .trim_matches('\'')
-                        .trim_matches('"')
-                        .to_string();
-
-                    let port = String::from_utf8_lossy(&port_output.stdout)
-                        .trim()
-                        .parse::<u16>()
-                        .unwrap_or(8080);
-
-                    if !host.is_empty() {
-                        return Ok(AsyncSysproxy {
-                            enable: true,
-                            host,
-                            port,
-                            bypass: String::new(),
-                        });
-                    }
-                }
-            }
-        }
-
-        Ok(AsyncSysproxy::default())
-    }
-
-    #[cfg(target_os = "linux")]
-    fn parse_proxy_url(proxy_url: &str) -> Result<AsyncSysproxy> {
-        // 解析形如 "http://proxy.example.com:8080" 的URL
-        let url = proxy_url.trim();
-
-        // 移除协议前缀
-        let url = if let Some(stripped) = url.strip_prefix("http://") {
-            stripped
-        } else if let Some(stripped) = url.strip_prefix("https://") {
-            stripped
-        } else {
-            url
-        };
-
-        // 解析主机和端口
-        let (host, port) = if let Some(colon_pos) = url.rfind(':') {
-            let host = url[..colon_pos].to_string();
-            let port = url[colon_pos + 1..].parse::<u16>().unwrap_or(8080);
-            (host, port)
-        } else {
-            (url.to_string(), 8080)
-        };
-
-        if host.is_empty() {
-            return Err(anyhow!("无效的代理URL"));
-        }
-
-        Ok(AsyncSysproxy {
-            enable: true,
-            host,
-            port,
-            bypass: std::env::var("no_proxy").unwrap_or_default(),
-        })
-    }
-}

src-tauri/src/core/backup.rs

@@ -74,14 +74,11 @@ impl WebDavClient {
 
         // 获取或创建配置
         let config = {
-            // 首先检查是否已有配置
-            let existing_config = self.config.lock().as_ref().cloned();
-
-            if let Some(cfg) = existing_config {
-                cfg
+            let mut lock = self.config.lock();
+            if let Some(cfg) = lock.as_ref() {
+                cfg.clone()
             } else {
-                // 释放锁后获取异步配置
-                let verge = Config::verge().await.latest_ref().clone();
+                let verge = Config::verge().latest().clone();
                 if verge.webdav_url.is_none()
                     || verge.webdav_username.is_none()
                     || verge.webdav_password.is_none()
@@ -100,8 +97,7 @@ impl WebDavClient {
                     password: verge.webdav_password.unwrap_or_default(),
                 };
 
-                // 重新获取锁并存储配置
-                *self.config.lock() = Some(config.clone());
+                *lock = Some(config.clone());
                 config
             }
         };
@@ -112,7 +108,10 @@ impl WebDavClient {
                 reqwest::Client::builder()
                     .danger_accept_invalid_certs(true)
                     .timeout(Duration::from_secs(op.timeout()))
-                    .user_agent(format!("clash-verge/{APP_VERSION} ({OS} WebDAV-Client)"))
+                    .user_agent(format!(
+                        "clash-verge/{} ({} WebDAV-Client)",
+                        APP_VERSION, OS
+                    ))
                     .redirect(reqwest::redirect::Policy::custom(|attempt| {
                         // 允许所有请求类型的重定向，包括PUT
                         if attempt.previous().len() >= 5 {
@@ -121,7 +120,8 @@ impl WebDavClient {
                             attempt.follow()
                         }
                     }))
-                    .build()?,
+                    .build()
+                    .unwrap(),
             )
             .set_host(config.url)
             .set_auth(reqwest_dav::Auth::Basic(config.username, config.password))
@@ -177,7 +177,7 @@ impl WebDavClient {
             }
 
             Ok(Err(e)) => {
-                log::warn!("Upload failed, retrying once: {e}");
+                log::warn!("Upload failed, retrying once: {}", e);
                 tokio::time::sleep(Duration::from_millis(500)).await;
                 timeout(
                     Duration::from_secs(TIMEOUT_UPLOAD),
@@ -237,7 +237,7 @@ impl WebDavClient {
 
 pub fn create_backup() -> Result<(String, PathBuf), Error> {
     let now = chrono::Local::now().format("%Y-%m-%d_%H-%M-%S").to_string();
-    let zip_file_name = format!("{OS}-backup-{now}.zip");
+    let zip_file_name = format!("{}-backup-{}.zip", OS, now);
     let zip_path = temp_dir().join(&zip_file_name);
 
     let file = fs::File::create(&zip_path)?;
@@ -246,17 +246,12 @@ pub fn create_backup() -> Result<(String, PathBuf), Error> {
     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?;
+            let entry = entry.unwrap();
             let path = entry.path();
             if path.is_file() {
-                let file_name_os = entry.file_name();
-                let file_name = file_name_os
-                    .to_str()
-                    .ok_or_else(|| anyhow::Error::msg("Invalid file name encoding"))?;
-                let backup_path = format!("profiles/{}", file_name);
+                let backup_path = format!("profiles/{}", entry.file_name().to_str().unwrap());
                 zip.start_file(backup_path, options)?;
-                let file_content = fs::read(&path)?;
-                zip.write_all(&file_content)?;
+                zip.write_all(fs::read(path).unwrap().as_slice())?;
             }
         }
     }
@@ -264,14 +259,14 @@ pub fn create_backup() -> Result<(String, PathBuf), Error> {
     zip.write_all(fs::read(dirs::clash_path()?)?.as_slice())?;
 
     let mut verge_config: serde_json::Value =
-        serde_yaml_ng::from_str(&fs::read_to_string(dirs::verge_path()?)?)?;
+        serde_yaml::from_str(&fs::read_to_string(dirs::verge_path()?)?)?;
     if let Some(obj) = verge_config.as_object_mut() {
         obj.remove("webdav_username");
         obj.remove("webdav_password");
         obj.remove("webdav_url");
     }
     zip.start_file(dirs::VERGE_CONFIG, options)?;
-    zip.write_all(serde_yaml_ng::to_string(&verge_config)?.as_bytes())?;
+    zip.write_all(serde_yaml::to_string(&verge_config)?.as_bytes())?;
 
     zip.start_file(dirs::PROFILE_YAML, options)?;
     zip.write_all(fs::read(dirs::profiles_path()?)?.as_slice())?;

src-tauri/src/core/core.rs

@@ -1,13 +1,13 @@
-#[cfg(target_os = "windows")]
-use crate::AsyncHandler;
+#[cfg(target_os = "macos")]
+use crate::core::tray::Tray;
 use crate::{
     config::*,
     core::{
         handle,
-        service::{self, SERVICE_MANAGER, ServiceStatus},
+        service::{self},
     },
-    ipc::IpcManager,
-    logging, logging_error, singleton_lazy,
+    logging, logging_error,
+    module::mihomo::MihomoManager,
     utils::{
         dirs,
         help::{self},
@@ -16,15 +16,16 @@ use crate::{
 };
 use anyhow::Result;
 use chrono::Local;
-use parking_lot::Mutex;
+use once_cell::sync::OnceCell;
 use std::{
     fmt,
-    fs::{File, create_dir_all},
+    fs::{create_dir_all, File},
     io::Write,
     path::PathBuf,
     sync::Arc,
 };
-use tauri_plugin_shell::{ShellExt, process::CommandChild};
+use tauri_plugin_shell::{process::CommandChild, ShellExt};
+use tokio::sync::Mutex;
 
 #[derive(Debug)]
 pub struct CoreManager {
@@ -53,7 +54,7 @@ impl fmt::Display for RunningMode {
     }
 }
 
-use crate::config::IVerge;
+const CLASH_CORES: [&str; 2] = ["verge-mihomo", "verge-mihomo-alpha"];
 
 impl CoreManager {
     /// 检查文件是否为脚本文件
@@ -139,23 +140,23 @@ impl CoreManager {
     /// 使用默认配置
     pub async fn use_default_config(&self, msg_type: &str, msg_content: &str) -> Result<()> {
         let runtime_path = dirs::app_home_dir()?.join(RUNTIME_CONFIG);
-
-        // Extract clash config before async operations
-        let clash_config = Config::clash().await.latest_ref().0.clone();
-
-        *Config::runtime().await.draft_mut() = Box::new(IRuntime {
-            config: Some(clash_config.clone()),
+        *Config::runtime().draft() = IRuntime {
+            config: Some(Config::clash().latest().0.clone()),
             exists_keys: vec![],
             chain_logs: Default::default(),
-        });
-        help::save_yaml(&runtime_path, &clash_config, Some("# Clash Verge Runtime")).await?;
+        };
+        help::save_yaml(
+            &runtime_path,
+            &Config::clash().latest().0,
+            Some("# Clash Verge Runtime"),
+        )?;
         handle::Handle::notice_message(msg_type, msg_content);
         Ok(())
     }
     /// 验证运行时配置
     pub async fn validate_config(&self) -> Result<(bool, String)> {
         logging!(info, Type::Config, true, "生成临时配置文件用于验证");
-        let config_path = Config::generate_file(ConfigType::Check).await?;
+        let config_path = Config::generate_file(ConfigType::Check)?;
         let config_path = dirs::path_to_str(&config_path)?;
         self.validate_config_internal(config_path).await
     }
@@ -173,7 +174,7 @@ impl CoreManager {
 
         // 检查文件是否存在
         if !std::path::Path::new(config_path).exists() {
-            let error_msg = format!("File not found: {config_path}");
+            let error_msg = format!("File not found: {}", config_path);
             //handle::Handle::notice_message("config_validate::file_not_found", &error_msg);
             return Ok((false, error_msg));
         }
@@ -187,7 +188,7 @@ impl CoreManager {
                 "检测到Merge文件，仅进行语法检查: {}",
                 config_path
             );
-            return self.validate_file_syntax(config_path);
+            return self.validate_file_syntax(config_path).await;
         }
 
         // 检查是否为脚本文件
@@ -219,7 +220,7 @@ impl CoreManager {
                 "检测到脚本文件，使用JavaScript验证: {}",
                 config_path
             );
-            return self.validate_script_file(config_path);
+            return self.validate_script_file(config_path).await;
         }
 
         // 对YAML配置文件使用Clash内核验证
@@ -248,14 +249,11 @@ impl CoreManager {
             config_path
         );
 
-        let clash_core = Config::verge().await.latest_ref().get_valid_clash_core();
+        let clash_core = { Config::verge().latest().clash_core.clone() };
+        let clash_core = clash_core.unwrap_or("verge-mihomo".into());
         logging!(info, Type::Config, true, "使用内核: {}", clash_core);
 
-        let app_handle = handle::Handle::global().app_handle().ok_or_else(|| {
-            let msg = "Failed to get app handle";
-            logging!(error, Type::Core, true, "{}", msg);
-            anyhow::anyhow!(msg)
-        })?;
+        let app_handle = handle::Handle::global().app_handle().unwrap();
         let app_dir = dirs::app_home_dir()?;
         let app_dir_str = dirs::path_to_str(&app_dir)?;
         logging!(info, Type::Config, true, "验证目录: {}", app_dir_str);
@@ -289,7 +287,7 @@ impl CoreManager {
             } else if !stderr.is_empty() {
                 stderr.to_string()
             } else if let Some(code) = output.status.code() {
-                format!("验证进程异常退出，退出码: {code}")
+                format!("验证进程异常退出，退出码: {}", code)
             } else {
                 "验证进程被终止".to_string()
             };
@@ -303,40 +301,40 @@ impl CoreManager {
         }
     }
     /// 只进行文件语法检查，不进行完整验证
-    fn validate_file_syntax(&self, config_path: &str) -> Result<(bool, String)> {
+    async fn validate_file_syntax(&self, config_path: &str) -> Result<(bool, String)> {
         logging!(info, Type::Config, true, "开始检查文件: {}", config_path);
 
         // 读取文件内容
         let content = match std::fs::read_to_string(config_path) {
             Ok(content) => content,
             Err(err) => {
-                let error_msg = format!("Failed to read file: {err}");
+                let error_msg = format!("Failed to read file: {}", err);
                 logging!(error, Type::Config, true, "无法读取文件: {}", error_msg);
                 return Ok((false, error_msg));
             }
         };
         // 对YAML文件尝试解析，只检查语法正确性
         logging!(info, Type::Config, true, "进行YAML语法检查");
-        match serde_yaml_ng::from_str::<serde_yaml_ng::Value>(&content) {
+        match serde_yaml::from_str::<serde_yaml::Value>(&content) {
             Ok(_) => {
                 logging!(info, Type::Config, true, "YAML语法检查通过");
                 Ok((true, String::new()))
             }
             Err(err) => {
                 // 使用标准化的前缀，以便错误处理函数能正确识别
-                let error_msg = format!("YAML syntax error: {err}");
+                let error_msg = format!("YAML syntax error: {}", err);
                 logging!(error, Type::Config, true, "YAML语法错误: {}", error_msg);
                 Ok((false, error_msg))
             }
         }
     }
     /// 验证脚本文件语法
-    fn validate_script_file(&self, path: &str) -> Result<(bool, String)> {
+    async fn validate_script_file(&self, path: &str) -> Result<(bool, String)> {
         // 读取脚本内容
         let content = match std::fs::read_to_string(path) {
             Ok(content) => content,
             Err(err) => {
-                let error_msg = format!("Failed to read script file: {err}");
+                let error_msg = format!("Failed to read script file: {}", err);
                 logging!(warn, Type::Config, true, "脚本语法错误: {}", err);
                 //handle::Handle::notice_message("config_validate::script_syntax_error", &error_msg);
                 return Ok((false, error_msg));
@@ -369,7 +367,7 @@ impl CoreManager {
                 Ok((true, String::new()))
             }
             Err(err) => {
-                let error_msg = format!("Script syntax error: {err}");
+                let error_msg = format!("Script syntax error: {}", err);
                 logging!(warn, Type::Config, true, "脚本语法错误: {}", err);
                 //handle::Handle::notice_message("config_validate::script_syntax_error", &error_msg);
                 Ok((false, error_msg))
@@ -384,6 +382,8 @@ impl CoreManager {
             return Ok((true, String::new()));
         }
 
+        logging!(info, Type::Config, true, "开始更新配置");
+
         // 1. 先生成新的配置内容
         logging!(info, Type::Config, true, "生成新的配置内容");
         Config::generate().await?;
@@ -391,20 +391,21 @@ impl CoreManager {
         // 2. 验证配置
         match self.validate_config().await {
             Ok((true, _)) => {
+                logging!(info, Type::Config, true, "配置验证通过");
                 // 4. 验证通过后，生成正式的运行时配置
-                logging!(info, Type::Config, true, "配置验证通过, 生成运行时配置");
-                let run_path = Config::generate_file(ConfigType::Run).await?;
+                logging!(info, Type::Config, true, "生成运行时配置");
+                let run_path = Config::generate_file(ConfigType::Run)?;
                 logging_error!(Type::Config, true, self.put_configs_force(run_path).await);
                 Ok((true, "something".into()))
             }
             Ok((false, error_msg)) => {
                 logging!(warn, Type::Config, true, "配置验证失败: {}", error_msg);
-                Config::runtime().await.discard();
+                Config::runtime().discard();
                 Ok((false, error_msg))
             }
             Err(e) => {
                 logging!(warn, Type::Config, true, "验证过程发生错误: {}", e);
-                Config::runtime().await.discard();
+                Config::runtime().discard();
                 Err(e)
             }
         }
@@ -415,15 +416,18 @@ impl CoreManager {
             logging_error!(Type::Core, true, "{}", msg);
             msg
         });
-        match IpcManager::global().put_configs_force(run_path_str?).await {
+        match MihomoManager::global()
+            .put_configs_force(run_path_str?)
+            .await
+        {
             Ok(_) => {
-                Config::runtime().await.apply();
+                Config::runtime().apply();
                 logging!(info, Type::Core, true, "Configuration updated successfully");
                 Ok(())
             }
             Err(e) => {
                 let msg = e.to_string();
-                Config::runtime().await.discard();
+                Config::runtime().discard();
                 logging_error!(Type::Core, true, "Failed to update configuration: {}", msg);
                 Err(msg)
             }
@@ -432,312 +436,17 @@ impl CoreManager {
 }
 
 impl CoreManager {
-    /// 清理多余的 mihomo 进程
-    async fn cleanup_orphaned_mihomo_processes(&self) -> Result<()> {
-        logging!(info, Type::Core, true, "开始清理多余的 mihomo 进程");
-
-        // 获取当前管理的进程 PID
-        let current_pid = {
-            let child_guard = self.child_sidecar.lock();
-            child_guard.as_ref().map(|child| child.pid())
-        };
-
-        let target_processes = ["verge-mihomo", "verge-mihomo-alpha"];
-
-        // 并行查找所有目标进程
-        let mut process_futures = Vec::new();
-        for &target in &target_processes {
-            let process_name = if cfg!(windows) {
-                format!("{target}.exe")
-            } else {
-                target.to_string()
-            };
-            process_futures.push(self.find_processes_by_name(process_name, target));
-        }
-
-        let process_results = futures::future::join_all(process_futures).await;
-
-        // 收集所有需要终止的进程PID
-        let mut pids_to_kill = Vec::new();
-        for result in process_results {
-            match result {
-                Ok((pids, process_name)) => {
-                    for pid in pids {
-                        // 跳过当前管理的进程
-                        if let Some(current) = current_pid
-                            && pid == current
-                        {
-                            logging!(
-                                debug,
-                                Type::Core,
-                                true,
-                                "跳过当前管理的进程: {} (PID: {})",
-                                process_name,
-                                pid
-                            );
-                            continue;
-                        }
-                        pids_to_kill.push((pid, process_name.clone()));
-                    }
-                }
-                Err(e) => {
-                    logging!(debug, Type::Core, true, "查找进程时发生错误: {}", e);
-                }
-            }
-        }
-
-        if pids_to_kill.is_empty() {
-            logging!(debug, Type::Core, true, "未发现多余的 mihomo 进程");
-            return Ok(());
-        }
-
-        let mut kill_futures = Vec::new();
-        for (pid, process_name) in &pids_to_kill {
-            kill_futures.push(self.kill_process_with_verification(*pid, process_name.clone()));
-        }
-
-        let kill_results = futures::future::join_all(kill_futures).await;
-
-        let killed_count = kill_results.into_iter().filter(|&success| success).count();
-
-        if killed_count > 0 {
-            logging!(
-                info,
-                Type::Core,
-                true,
-                "清理完成，共终止了 {} 个多余的 mihomo 进程",
-                killed_count
-            );
-        }
-
-        Ok(())
-    }
-
-    /// 根据进程名查找进程PID列
-    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;
-            use winapi::um::tlhelp32::{
-                CreateToolhelp32Snapshot, PROCESSENTRY32W, Process32FirstW, Process32NextW,
-                TH32CS_SNAPPROCESS,
-            };
-            use winapi::um::winnt::HANDLE;
-
-            let process_name_clone = process_name.clone();
-            let pids = AsyncHandler::spawn_blocking(move || -> Result<Vec<u32>> {
-                let mut pids = Vec::new();
-
-                unsafe {
-                    // 创建进程快照
-                    let snapshot: HANDLE = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
-                    if snapshot == winapi::um::handleapi::INVALID_HANDLE_VALUE {
-                        return Err(anyhow::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 {
-                            // 将宽字符转换为String
-                            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 output = if cfg!(target_os = "macos") {
-                tokio::process::Command::new("pgrep")
-                    .arg(&process_name)
-                    .output()
-                    .await?
-            } else {
-                // Linux
-                tokio::process::Command::new("pidof")
-                    .arg(&process_name)
-                    .output()
-                    .await?
-            };
-
-            if !output.status.success() {
-                return Ok((Vec::new(), process_name));
-            }
-
-            let stdout = String::from_utf8_lossy(&output.stdout);
-            let mut pids = Vec::new();
-
-            // Unix系统直接解析PID列表
-            for pid_str in stdout.split_whitespace() {
-                if let Ok(pid) = pid_str.parse::<u32>() {
-                    pids.push(pid);
-                }
-            }
-
-            Ok((pids, process_name))
-        }
-    }
-
-    /// 终止进程并验证结果 - 使用Windows API直接终止，更优雅高效
-    async fn kill_process_with_verification(&self, pid: u32, process_name: String) -> bool {
-        logging!(
-            info,
-            Type::Core,
-            true,
-            "尝试终止进程: {} (PID: {})",
-            process_name,
-            pid
-        );
-
-        #[cfg(windows)]
-        let success = {
-            use winapi::um::handleapi::CloseHandle;
-            use winapi::um::processthreadsapi::{OpenProcess, TerminateProcess};
-            use winapi::um::winnt::{HANDLE, PROCESS_TERMINATE};
-
-            AsyncHandler::spawn_blocking(move || -> bool {
-                unsafe {
-                    let process_handle: HANDLE = OpenProcess(PROCESS_TERMINATE, 0, pid);
-                    if process_handle.is_null() {
-                        return false;
-                    }
-                    let result = TerminateProcess(process_handle, 1);
-                    CloseHandle(process_handle);
-
-                    result != 0
-                }
-            })
-            .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 {
-            // 短暂等待并验证进程是否真正终止
-            tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
-
-            let still_running = self.is_process_running(pid).await.unwrap_or(false);
-            if still_running {
-                logging!(
-                    warn,
-                    Type::Core,
-                    true,
-                    "进程 {} (PID: {}) 终止命令成功但进程仍在运行",
-                    process_name,
-                    pid
-                );
-                false
-            } else {
-                logging!(
-                    info,
-                    Type::Core,
-                    true,
-                    "成功终止进程: {} (PID: {})",
-                    process_name,
-                    pid
-                );
-                true
-            }
-        } else {
-            logging!(
-                warn,
-                Type::Core,
-                true,
-                "无法终止进程: {} (PID: {})",
-                process_name,
-                pid
-            );
-            false
-        }
-    }
-
-    /// Windows API检查进程
-    async fn is_process_running(&self, pid: u32) -> Result<bool> {
-        #[cfg(windows)]
-        {
-            use winapi::shared::minwindef::DWORD;
-            use winapi::um::handleapi::CloseHandle;
-            use winapi::um::processthreadsapi::GetExitCodeProcess;
-            use winapi::um::processthreadsapi::OpenProcess;
-            use winapi::um::winnt::{HANDLE, PROCESS_QUERY_INFORMATION};
-
-            AsyncHandler::spawn_blocking(move || -> Result<bool> {
-                unsafe {
-                    let process_handle: HANDLE = OpenProcess(PROCESS_QUERY_INFORMATION, 0, pid);
-                    if process_handle.is_null() {
-                        return Ok(false);
-                    }
-                    let mut exit_code: DWORD = 0;
-                    let result = GetExitCodeProcess(process_handle, &mut exit_code);
-                    CloseHandle(process_handle);
-
-                    if result == 0 {
-                        return Ok(false);
-                    }
-                    Ok(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())
-        }
-    }
-
     async fn start_core_by_sidecar(&self) -> Result<()> {
-        logging!(info, Type::Core, true, "Running core by sidecar");
-
-        let config_file = &Config::generate_file(ConfigType::Run).await?;
+        logging!(trace, Type::Core, true, "Running core by sidecar");
+        let config_file = &Config::generate_file(ConfigType::Run)?;
         let app_handle = handle::Handle::global()
             .app_handle()
             .ok_or(anyhow::anyhow!("failed to get app handle"))?;
-        let clash_core = Config::verge().await.latest_ref().get_valid_clash_core();
+        let clash_core = Config::verge()
+            .latest()
+            .clash_core
+            .clone()
+            .unwrap_or("verge-mihomo".to_string());
         let config_dir = dirs::app_home_dir()?;
 
         let service_log_dir = dirs::app_home_dir()?.join("logs").join("service");
@@ -746,7 +455,7 @@ impl CoreManager {
         let now = Local::now();
         let timestamp = now.format("%Y%m%d_%H%M%S").to_string();
 
-        let log_path = service_log_dir.join(format!("sidecar_{timestamp}.log"));
+        let log_path = service_log_dir.join(format!("sidecar_{}.log", timestamp));
 
         let mut log_file = File::create(log_path)?;
 
@@ -761,19 +470,21 @@ impl CoreManager {
             ])
             .spawn()?;
 
-        while let Some(event) = rx.recv().await {
-            if let tauri_plugin_shell::process::CommandEvent::Stdout(line) = event
-                && let Err(e) = writeln!(log_file, "{}", String::from_utf8_lossy(&line))
-            {
-                logging!(
-                    error,
-                    Type::Core,
-                    true,
-                    "[Sidecar] Failed to write stdout to file: {}",
-                    e
-                );
+        tokio::spawn(async move {
+            while let Some(event) = rx.recv().await {
+                if let tauri_plugin_shell::process::CommandEvent::Stdout(line) = event {
+                    if let Err(e) = writeln!(log_file, "{}", String::from_utf8_lossy(&line)) {
+                        logging!(
+                            error,
+                            Type::Core,
+                            true,
+                            "[Sidecar] Failed to write stdout to file: {}",
+                            e
+                        );
+                    }
+                }
             }
-        }
+        });
 
         let pid = child.pid();
         logging!(
@@ -783,14 +494,14 @@ impl CoreManager {
             "Started core by sidecar pid: {}",
             pid
         );
-        *self.child_sidecar.lock() = Some(child);
-        self.set_running_mode(RunningMode::Sidecar);
+        *self.child_sidecar.lock().await = Some(child);
+        self.set_running_mode(RunningMode::Sidecar).await;
         Ok(())
     }
-    fn stop_core_by_sidecar(&self) -> Result<()> {
-        logging!(info, Type::Core, true, "Stopping core by sidecar");
+    async fn stop_core_by_sidecar(&self) -> Result<()> {
+        logging!(trace, Type::Core, true, "Stopping core by sidecar");
 
-        if let Some(child) = self.child_sidecar.lock().take() {
+        if let Some(child) = self.child_sidecar.lock().await.take() {
             let pid = child.pid();
             child.kill()?;
             logging!(
@@ -801,110 +512,285 @@ impl CoreManager {
                 pid
             );
         }
-        self.set_running_mode(RunningMode::NotRunning);
+        self.set_running_mode(RunningMode::NotRunning).await;
         Ok(())
     }
 }
 
 impl CoreManager {
     async fn start_core_by_service(&self) -> Result<()> {
-        logging!(info, Type::Core, true, "Running core by service");
-        let config_file = &Config::generate_file(ConfigType::Run).await?;
+        logging!(trace, Type::Core, true, "Running core by service");
+        let config_file = &Config::generate_file(ConfigType::Run)?;
         service::run_core_by_service(config_file).await?;
-        self.set_running_mode(RunningMode::Service);
+        self.set_running_mode(RunningMode::Service).await;
         Ok(())
     }
     async fn stop_core_by_service(&self) -> Result<()> {
-        logging!(info, Type::Core, true, "Stopping core by service");
+        logging!(trace, Type::Core, true, "Stopping core by service");
         service::stop_core_by_service().await?;
-        self.set_running_mode(RunningMode::NotRunning);
+        self.set_running_mode(RunningMode::NotRunning).await;
         Ok(())
     }
 }
 
-impl Default for CoreManager {
-    fn default() -> Self {
-        CoreManager {
-            running: Arc::new(Mutex::new(RunningMode::NotRunning)),
-            child_sidecar: Arc::new(Mutex::new(None)),
-        }
-    }
-}
-
 impl CoreManager {
-    pub async fn init(&self) -> Result<()> {
-        logging!(info, Type::Core, "Initializing core");
+    pub fn global() -> &'static CoreManager {
+        static CORE_MANAGER: OnceCell<CoreManager> = OnceCell::new();
+        CORE_MANAGER.get_or_init(|| CoreManager {
+            running: Arc::new(Mutex::new(RunningMode::NotRunning)),
+            child_sidecar: Arc::new(Mutex::new(None)),
+        })
+    }
+    // 当服务安装失败时的回退逻辑
+    async fn attempt_service_init(&self) -> Result<()> {
+        if service::check_service_needs_reinstall().await {
+            logging!(info, Type::Core, true, "服务版本不匹配或状态异常，执行重装");
+            if let Err(e) = service::reinstall_service().await {
+                logging!(
+                    warn,
+                    Type::Core,
+                    true,
+                    "服务重装失败 during attempt_service_init: {}",
+                    e
+                );
+                return Err(e);
+            }
+            // 如果重装成功，还需要尝试启动服务
+            logging!(info, Type::Core, true, "服务重装成功，尝试启动服务");
+        }
 
-        // 应用启动时先清理任何遗留的 mihomo 进程
-        if let Err(e) = self.cleanup_orphaned_mihomo_processes().await {
+        if let Err(e) = self.start_core_by_service().await {
             logging!(
                 warn,
                 Type::Core,
                 true,
-                "应用初始化时清理多余 mihomo 进程失败: {}",
+                "通过服务启动核心失败 during attempt_service_init: {}",
                 e
             );
+            // 确保 prefer_sidecar 在 start_core_by_service 失败时也被设置
+            let mut state = service::ServiceState::get();
+            if !state.prefer_sidecar {
+                state.prefer_sidecar = true;
+                state.last_error = Some(format!("通过服务启动核心失败: {}", e));
+                if let Err(save_err) = state.save() {
+                    logging!(
+                        error,
+                        Type::Core,
+                        true,
+                        "保存ServiceState失败 (in attempt_service_init/start_core_by_service): {}",
+                        save_err
+                    );
+                }
+            }
+            return Err(e);
+        }
+        Ok(())
+    }
+
+    pub async fn init(&self) -> Result<()> {
+        logging!(trace, Type::Core, "Initializing core");
+
+        let mut core_started_successfully = false;
+
+        if service::is_service_available().await.is_ok() {
+            logging!(
+                info,
+                Type::Core,
+                true,
+                "服务当前可用或看似可用，尝试通过服务模式启动/重装"
+            );
+            match self.attempt_service_init().await {
+                Ok(_) => {
+                    logging!(info, Type::Core, true, "服务模式成功启动核心");
+                    core_started_successfully = true;
+                }
+                Err(_err) => {
+                    logging!(
+                        warn,
+                        Type::Core,
+                        true,
+                        "服务模式启动或重装失败。将尝试Sidecar模式回退。"
+                    );
+                }
+            }
+        } else {
+            logging!(
+                info,
+                Type::Core,
+                true,
+                "服务初始不可用 (is_service_available 调用失败)"
+            );
         }
 
-        // 使用简化的启动流程
-        logging!(info, Type::Core, true, "开始核心初始化");
-        self.start_core().await?;
+        if !core_started_successfully {
+            logging!(
+                info,
+                Type::Core,
+                true,
+                "核心未通过服务模式启动，执行Sidecar回退或首次安装逻辑"
+            );
+
+            let service_state = service::ServiceState::get();
+
+            if service_state.prefer_sidecar {
+                logging!(
+                    info,
+                    Type::Core,
+                    true,
+                    "用户偏好Sidecar模式或先前服务启动失败，使用Sidecar模式启动"
+                );
+                self.start_core_by_sidecar().await?;
+                // 如果 sidecar 启动成功，我们可以认为核心初始化流程到此结束
+                // 后续的 Tray::global().subscribe_traffic().await 仍然会执行
+            } else {
+                let has_service_install_record = service_state.last_install_time > 0;
+                if !has_service_install_record {
+                    logging!(
+                        info,
+                        Type::Core,
+                        true,
+                        "无服务安装记录 (首次运行或状态重置)，尝试安装服务"
+                    );
+                    match service::install_service().await {
+                        Ok(_) => {
+                            logging!(info, Type::Core, true, "服务安装成功(首次尝试)");
+                            let mut new_state = service::ServiceState::default();
+                            new_state.record_install();
+                            new_state.prefer_sidecar = false;
+                            new_state.save()?;
+
+                            if service::is_service_available().await.is_ok() {
+                                logging!(info, Type::Core, true, "新安装的服务可用，尝试启动");
+                                if self.start_core_by_service().await.is_ok() {
+                                    logging!(info, Type::Core, true, "新安装的服务启动成功");
+                                } else {
+                                    logging!(
+                                        warn,
+                                        Type::Core,
+                                        true,
+                                        "新安装的服务启动失败，回退到Sidecar模式"
+                                    );
+                                    let mut final_state = service::ServiceState::get();
+                                    final_state.prefer_sidecar = true;
+                                    final_state.last_error =
+                                        Some("Newly installed service failed to start".to_string());
+                                    final_state.save()?;
+                                    self.start_core_by_sidecar().await?;
+                                }
+                            } else {
+                                logging!(
+                                    warn,
+                                    Type::Core,
+                                    true,
+                                    "服务安装成功但未能连接/立即可用，回退到Sidecar模式"
+                                );
+                                let mut final_state = service::ServiceState::get();
+                                final_state.prefer_sidecar = true;
+                                final_state.last_error = Some(
+                                    "Newly installed service not immediately available/connectable"
+                                        .to_string(),
+                                );
+                                final_state.save()?;
+                                self.start_core_by_sidecar().await?;
+                            }
+                        }
+                        Err(err) => {
+                            logging!(warn, Type::Core, true, "服务首次安装失败: {}", err);
+                            let new_state = service::ServiceState {
+                                last_error: Some(err.to_string()),
+                                prefer_sidecar: true,
+                                ..Default::default()
+                            };
+                            new_state.save()?;
+                            self.start_core_by_sidecar().await?;
+                        }
+                    }
+                } else {
+                    // 有安装记录，服务未成功启动，且初始不偏好sidecar
+                    // 这意味着服务之前可能可用，但 attempt_service_init 失败了（并应已设置 prefer_sidecar），
+                    // 或者服务初始不可用，无偏好，有记录。应强制使用 sidecar。
+                    logging!(
+                        info,
+                        Type::Core,
+                        true,
+                        "有服务安装记录但服务不可用/未启动，强制切换到Sidecar模式"
+                    );
+                    let mut final_state = service::ServiceState::get();
+                    if !final_state.prefer_sidecar {
+                        logging!(
+                            warn,
+                            Type::Core,
+                            true,
+                            "prefer_sidecar 为 false，因服务启动失败或不可用而强制设置为 true"
+                        );
+                        final_state.prefer_sidecar = true;
+                        final_state.last_error =
+                            Some(final_state.last_error.unwrap_or_else(|| {
+                                "Service startup failed or unavailable before sidecar fallback"
+                                    .to_string()
+                            }));
+                        final_state.save()?;
+                    }
+                    self.start_core_by_sidecar().await?;
+                }
+            }
+        }
+
+        logging!(trace, Type::Core, "Initied core logic completed");
+        #[cfg(target_os = "macos")]
+        logging_error!(Type::Core, true, Tray::global().subscribe_traffic().await);
 
-        logging!(info, Type::Core, true, "核心初始化完成");
         Ok(())
     }
 
-    pub fn set_running_mode(&self, mode: RunningMode) {
-        let mut guard = self.running.lock();
+    pub async fn set_running_mode(&self, mode: RunningMode) {
+        let mut guard = self.running.lock().await;
         *guard = mode;
     }
 
-    pub fn get_running_mode(&self) -> RunningMode {
-        let guard = self.running.lock();
+    pub async fn get_running_mode(&self) -> RunningMode {
+        let guard = self.running.lock().await;
         (*guard).clone()
     }
 
-    pub async fn prestart_core(&self) -> Result<()> {
-        SERVICE_MANAGER.lock().await.refresh().await?;
-        match SERVICE_MANAGER.lock().await.current() {
-            ServiceStatus::Ready => {
-                self.set_running_mode(RunningMode::Service);
-            }
-            _ => {
-                self.set_running_mode(RunningMode::Sidecar);
-            }
-        }
-        Ok(())
-    }
-
     /// 启动核心
     pub async fn start_core(&self) -> Result<()> {
-        self.prestart_core().await?;
-
-        match self.get_running_mode() {
-            RunningMode::Service => {
-                logging_error!(Type::Core, true, self.start_core_by_service().await);
+        if service::is_service_available().await.is_ok() {
+            if service::check_service_needs_reinstall().await {
+                service::reinstall_service().await?;
             }
-            RunningMode::NotRunning | RunningMode::Sidecar => {
-                logging_error!(Type::Core, true, self.start_core_by_sidecar().await);
+            logging!(info, Type::Core, true, "服务可用，使用服务模式启动");
+            self.start_core_by_service().await?;
+        } else {
+            // 服务不可用，检查用户偏好
+            let service_state = service::ServiceState::get();
+            if service_state.prefer_sidecar {
+                logging!(
+                    info,
+                    Type::Core,
+                    true,
+                    "服务不可用，根据用户偏好使用Sidecar模式"
+                );
+                self.start_core_by_sidecar().await?;
+            } else {
+                logging!(info, Type::Core, true, "服务不可用，使用Sidecar模式");
+                self.start_core_by_sidecar().await?;
             }
-        };
-
+        }
         Ok(())
     }
 
     /// 停止核心运行
     pub async fn stop_core(&self) -> Result<()> {
-        match self.get_running_mode() {
+        match self.get_running_mode().await {
             RunningMode::Service => self.stop_core_by_service().await,
-            RunningMode::Sidecar => self.stop_core_by_sidecar(),
+            RunningMode::Sidecar => self.stop_core_by_sidecar().await,
             RunningMode::NotRunning => Ok(()),
         }
     }
 
     /// 重启内核
     pub async fn restart_core(&self) -> Result<()> {
-        logging!(info, Type::Core, true, "Restarting core");
         self.stop_core().await?;
         self.start_core().await?;
         Ok(())
@@ -917,25 +803,18 @@ impl CoreManager {
             logging!(error, Type::Core, true, "{}", error_message);
             return Err(error_message.to_string());
         }
-        let core = clash_core.as_ref().ok_or_else(|| {
-            let msg = "Clash core should not be None";
-            logging!(error, Type::Core, true, "{}", msg);
-            msg.to_string()
-        })?;
-        if !IVerge::VALID_CLASH_CORES.contains(&core.as_str()) {
-            let error_message = format!("Clash core invalid name: {core}");
+        let core: &str = &clash_core.clone().unwrap();
+        if !CLASH_CORES.contains(&core) {
+            let error_message = format!("Clash core invalid name: {}", core);
             logging!(error, Type::Core, true, "{}", error_message);
             return Err(error_message);
         }
 
-        Config::verge().await.draft_mut().clash_core = clash_core.clone();
-        Config::verge().await.apply();
+        Config::verge().draft().clash_core = clash_core.clone();
+        Config::verge().apply();
+        logging_error!(Type::Core, true, Config::verge().latest().save_file());
 
-        // 分离数据获取和异步调用避免Send问题
-        let verge_data = Config::verge().await.latest_ref().clone();
-        logging_error!(Type::Core, true, verge_data.save_file().await);
-
-        let run_path = Config::generate_file(ConfigType::Run).await.map_err(|e| {
+        let run_path = Config::generate_file(ConfigType::Run).map_err(|e| {
             let msg = e.to_string();
             logging_error!(Type::Core, true, "{}", msg);
             msg
@@ -946,6 +825,3 @@ impl CoreManager {
         Ok(())
     }
 }
-
-// Use simplified singleton_lazy macro
-singleton_lazy!(CoreManager, CORE_MANAGER, CoreManager::default);

src-tauri/src/core/event_driven_proxy.rs

@@ -1,585 +0,0 @@
-use std::sync::Arc;
-use tokio::sync::RwLock;
-use tokio::sync::{mpsc, oneshot};
-use tokio::time::{Duration, sleep, timeout};
-use tokio_stream::{StreamExt, wrappers::UnboundedReceiverStream};
-
-use crate::config::{Config, IVerge};
-use crate::core::async_proxy_query::AsyncProxyQuery;
-use crate::logging_error;
-use crate::process::AsyncHandler;
-use crate::utils::logging::Type;
-use once_cell::sync::Lazy;
-use sysproxy::{Autoproxy, Sysproxy};
-
-#[derive(Debug, Clone)]
-pub enum ProxyEvent {
-    /// 配置变更事件
-    ConfigChanged,
-    /// 强制检查代理状态
-    #[allow(dead_code)]
-    ForceCheck,
-    /// 启用系统代理
-    #[allow(dead_code)]
-    EnableProxy,
-    /// 禁用系统代理
-    #[allow(dead_code)]
-    DisableProxy,
-    /// 切换到PAC模式
-    #[allow(dead_code)]
-    SwitchToPac,
-    /// 切换到HTTP代理模式
-    #[allow(dead_code)]
-    SwitchToHttp,
-    /// 应用启动事件
-    AppStarted,
-    /// 应用关闭事件
-    #[allow(dead_code)]
-    AppStopping,
-}
-
-#[derive(Debug, Clone)]
-pub struct ProxyState {
-    pub sys_enabled: bool,
-    pub pac_enabled: bool,
-    pub auto_proxy: Autoproxy,
-    pub sys_proxy: Sysproxy,
-    pub last_updated: std::time::Instant,
-    pub is_healthy: bool,
-}
-
-impl Default for ProxyState {
-    fn default() -> Self {
-        Self {
-            sys_enabled: false,
-            pac_enabled: false,
-            auto_proxy: Autoproxy {
-                enable: false,
-                url: "".to_string(),
-            },
-            sys_proxy: Sysproxy {
-                enable: false,
-                host: "127.0.0.1".to_string(),
-                port: 7897,
-                bypass: "".to_string(),
-            },
-            last_updated: std::time::Instant::now(),
-            is_healthy: true,
-        }
-    }
-}
-
-pub struct EventDrivenProxyManager {
-    state: Arc<RwLock<ProxyState>>,
-    event_sender: mpsc::UnboundedSender<ProxyEvent>,
-    query_sender: mpsc::UnboundedSender<QueryRequest>,
-}
-
-#[derive(Debug)]
-pub struct QueryRequest {
-    response_tx: oneshot::Sender<Autoproxy>,
-}
-
-// 配置结构体移到外部
-struct ProxyConfig {
-    sys_enabled: bool,
-    pac_enabled: bool,
-    guard_enabled: bool,
-}
-
-static PROXY_MANAGER: Lazy<EventDrivenProxyManager> = Lazy::new(EventDrivenProxyManager::new);
-
-impl EventDrivenProxyManager {
-    pub fn global() -> &'static EventDrivenProxyManager {
-        &PROXY_MANAGER
-    }
-
-    fn new() -> Self {
-        let state = Arc::new(RwLock::new(ProxyState::default()));
-        let (event_tx, event_rx) = mpsc::unbounded_channel();
-        let (query_tx, query_rx) = mpsc::unbounded_channel();
-
-        let state_clone = Arc::clone(&state);
-        AsyncHandler::spawn(move || Self::start_event_loop(state_clone, event_rx, query_rx));
-
-        Self {
-            state,
-            event_sender: event_tx,
-            query_sender: query_tx,
-        }
-    }
-
-    /// 获取自动代理配置（缓存）
-    pub async fn get_auto_proxy_cached(&self) -> Autoproxy {
-        self.state.read().await.auto_proxy.clone()
-    }
-
-    /// 异步获取最新的自动代理配置
-    pub async fn get_auto_proxy_async(&self) -> Autoproxy {
-        let (tx, rx) = oneshot::channel();
-        let query = QueryRequest { response_tx: tx };
-
-        if self.query_sender.send(query).is_err() {
-            log::error!(target: "app", "发送查询请求失败，返回缓存数据");
-            return self.get_auto_proxy_cached().await;
-        }
-
-        match timeout(Duration::from_secs(5), rx).await {
-            Ok(Ok(result)) => result,
-            _ => {
-                log::warn!(target: "app", "查询超时，返回缓存数据");
-                self.get_auto_proxy_cached().await
-            }
-        }
-    }
-
-    /// 通知配置变更
-    pub fn notify_config_changed(&self) {
-        self.send_event(ProxyEvent::ConfigChanged);
-    }
-
-    /// 通知应用启动
-    pub fn notify_app_started(&self) {
-        self.send_event(ProxyEvent::AppStarted);
-    }
-
-    /// 通知应用即将关闭
-    #[allow(dead_code)]
-    pub fn notify_app_stopping(&self) {
-        self.send_event(ProxyEvent::AppStopping);
-    }
-
-    /// 启用系统代理
-    #[allow(dead_code)]
-    pub fn enable_proxy(&self) {
-        self.send_event(ProxyEvent::EnableProxy);
-    }
-
-    /// 禁用系统代理
-    #[allow(dead_code)]
-    pub fn disable_proxy(&self) {
-        self.send_event(ProxyEvent::DisableProxy);
-    }
-
-    /// 强制检查代理状态
-    #[allow(dead_code)]
-    pub fn force_check(&self) {
-        self.send_event(ProxyEvent::ForceCheck);
-    }
-
-    fn send_event(&self, event: ProxyEvent) {
-        if let Err(e) = self.event_sender.send(event) {
-            log::error!(target: "app", "发送代理事件失败: {e}");
-        }
-    }
-
-    pub async fn start_event_loop(
-        state: Arc<RwLock<ProxyState>>,
-        event_rx: mpsc::UnboundedReceiver<ProxyEvent>,
-        query_rx: mpsc::UnboundedReceiver<QueryRequest>,
-    ) {
-        log::info!(target: "app", "事件驱动代理管理器启动");
-
-        // 将 mpsc 接收器包装成 Stream，避免每次循环创建 future
-        let mut event_stream = UnboundedReceiverStream::new(event_rx);
-        let mut query_stream = UnboundedReceiverStream::new(query_rx);
-
-        loop {
-            tokio::select! {
-                Some(event) = event_stream.next() => {
-                    log::debug!(target: "app", "处理代理事件: {event:?}");
-                    Self::handle_event(&state, event).await;
-                }
-                Some(query) = query_stream.next() => {
-                    let result = Self::handle_query(&state).await;
-                    let _ = query.response_tx.send(result);
-                }
-                else => {
-                    // 两个通道都关闭时退出
-                    log::info!(target: "app", "事件或查询通道关闭，代理管理器停止");
-                    break;
-                }
-            }
-        }
-    }
-
-    async fn handle_event(state: &Arc<RwLock<ProxyState>>, event: ProxyEvent) {
-        match event {
-            ProxyEvent::ConfigChanged | ProxyEvent::ForceCheck => {
-                Self::update_proxy_config(state).await;
-            }
-            ProxyEvent::EnableProxy => {
-                Self::enable_system_proxy(state).await;
-            }
-            ProxyEvent::DisableProxy => {
-                Self::disable_system_proxy(state);
-            }
-            ProxyEvent::SwitchToPac => {
-                Self::switch_proxy_mode(state, true).await;
-            }
-            ProxyEvent::SwitchToHttp => {
-                Self::switch_proxy_mode(state, false).await;
-            }
-            ProxyEvent::AppStarted => {
-                Self::initialize_proxy_state(state).await;
-            }
-            ProxyEvent::AppStopping => {
-                log::info!(target: "app", "清理代理状态");
-            }
-        }
-    }
-
-    async fn handle_query(state: &Arc<RwLock<ProxyState>>) -> Autoproxy {
-        let auto_proxy = Self::get_auto_proxy_with_timeout().await;
-
-        Self::update_state_timestamp(state, |s| {
-            s.auto_proxy = auto_proxy.clone();
-        })
-        .await;
-
-        auto_proxy
-    }
-
-    async fn initialize_proxy_state(state: &Arc<RwLock<ProxyState>>) {
-        log::info!(target: "app", "初始化代理状态");
-
-        let config = Self::get_proxy_config().await;
-        let auto_proxy = Self::get_auto_proxy_with_timeout().await;
-        let sys_proxy = Self::get_sys_proxy_with_timeout().await;
-
-        Self::update_state_timestamp(state, |s| {
-            s.sys_enabled = config.sys_enabled;
-            s.pac_enabled = config.pac_enabled;
-            s.auto_proxy = auto_proxy;
-            s.sys_proxy = sys_proxy;
-            s.is_healthy = true;
-        })
-        .await;
-
-        log::info!(target: "app", "代理状态初始化完成: sys={}, pac={}", config.sys_enabled, config.pac_enabled);
-    }
-
-    async fn update_proxy_config(state: &Arc<RwLock<ProxyState>>) {
-        log::debug!(target: "app", "更新代理配置");
-
-        let config = Self::get_proxy_config().await;
-
-        Self::update_state_timestamp(state, |s| {
-            s.sys_enabled = config.sys_enabled;
-            s.pac_enabled = config.pac_enabled;
-        })
-        .await;
-
-        if config.guard_enabled && config.sys_enabled {
-            Self::check_and_restore_proxy(state).await;
-        }
-    }
-
-    async fn check_and_restore_proxy(state: &Arc<RwLock<ProxyState>>) {
-        let (sys_enabled, pac_enabled) = {
-            let s = state.read().await;
-            (s.sys_enabled, s.pac_enabled)
-        };
-
-        if !sys_enabled {
-            return;
-        }
-
-        log::debug!(target: "app", "检查代理状态");
-
-        if pac_enabled {
-            Self::check_and_restore_pac_proxy(state).await;
-        } else {
-            Self::check_and_restore_sys_proxy(state).await;
-        }
-    }
-
-    async fn check_and_restore_pac_proxy(state: &Arc<RwLock<ProxyState>>) {
-        let current = Self::get_auto_proxy_with_timeout().await;
-        let expected = Self::get_expected_pac_config().await;
-
-        Self::update_state_timestamp(state, |s| {
-            s.auto_proxy = current.clone();
-        })
-        .await;
-
-        if !current.enable || current.url != expected.url {
-            log::info!(target: "app", "PAC代理设置异常，正在恢复...");
-            if let Err(e) = Self::restore_pac_proxy(&expected.url).await {
-                log::error!(target: "app", "恢复PAC代理失败: {}", e);
-            }
-
-            sleep(Duration::from_millis(500)).await;
-            let restored = Self::get_auto_proxy_with_timeout().await;
-
-            Self::update_state_timestamp(state, |s| {
-                s.is_healthy = restored.enable && restored.url == expected.url;
-                s.auto_proxy = restored;
-            })
-            .await;
-        }
-    }
-
-    async fn check_and_restore_sys_proxy(state: &Arc<RwLock<ProxyState>>) {
-        let current = Self::get_sys_proxy_with_timeout().await;
-        let expected = Self::get_expected_sys_proxy().await;
-
-        Self::update_state_timestamp(state, |s| {
-            s.sys_proxy = current.clone();
-        })
-        .await;
-
-        if !current.enable || current.host != expected.host || current.port != expected.port {
-            log::info!(target: "app", "系统代理设置异常，正在恢复...");
-            if let Err(e) = Self::restore_sys_proxy(&expected).await {
-                log::error!(target: "app", "恢复系统代理失败: {}", e);
-            }
-
-            sleep(Duration::from_millis(500)).await;
-            let restored = Self::get_sys_proxy_with_timeout().await;
-
-            Self::update_state_timestamp(state, |s| {
-                s.is_healthy = restored.enable
-                    && restored.host == expected.host
-                    && restored.port == expected.port;
-                s.sys_proxy = restored;
-            })
-            .await;
-        }
-    }
-
-    async fn enable_system_proxy(state: &Arc<RwLock<ProxyState>>) {
-        log::info!(target: "app", "启用系统代理");
-
-        let pac_enabled = state.read().await.pac_enabled;
-
-        if pac_enabled {
-            let expected = Self::get_expected_pac_config().await;
-            if let Err(e) = Self::restore_pac_proxy(&expected.url).await {
-                log::error!(target: "app", "启用PAC代理失败: {}", e);
-            }
-        } else {
-            let expected = Self::get_expected_sys_proxy().await;
-            if let Err(e) = Self::restore_sys_proxy(&expected).await {
-                log::error!(target: "app", "启用系统代理失败: {}", e);
-            }
-        }
-
-        Self::check_and_restore_proxy(state).await;
-    }
-
-    fn disable_system_proxy(_state: &Arc<RwLock<ProxyState>>) {
-        log::info!(target: "app", "禁用系统代理");
-
-        #[cfg(not(target_os = "windows"))]
-        {
-            let disabled_sys = Sysproxy::default();
-            let disabled_auto = Autoproxy::default();
-
-            logging_error!(Type::System, true, disabled_auto.set_auto_proxy());
-            logging_error!(Type::System, true, disabled_sys.set_system_proxy());
-        }
-    }
-
-    async fn switch_proxy_mode(state: &Arc<RwLock<ProxyState>>, to_pac: bool) {
-        log::info!(target: "app", "切换到{}模式", if to_pac { "PAC" } else { "HTTP代理" });
-
-        if to_pac {
-            let disabled_sys = Sysproxy::default();
-            logging_error!(Type::System, true, disabled_sys.set_system_proxy());
-
-            let expected = Self::get_expected_pac_config().await;
-            if let Err(e) = Self::restore_pac_proxy(&expected.url).await {
-                log::error!(target: "app", "切换到PAC模式失败: {}", e);
-            }
-        } else {
-            let disabled_auto = Autoproxy::default();
-            logging_error!(Type::System, true, disabled_auto.set_auto_proxy());
-
-            let expected = Self::get_expected_sys_proxy().await;
-            if let Err(e) = Self::restore_sys_proxy(&expected).await {
-                log::error!(target: "app", "切换到HTTP代理模式失败: {}", e);
-            }
-        }
-
-        Self::update_state_timestamp(state, |s| s.pac_enabled = to_pac).await;
-        Self::check_and_restore_proxy(state).await;
-    }
-
-    async fn get_auto_proxy_with_timeout() -> Autoproxy {
-        let async_proxy = AsyncProxyQuery::get_auto_proxy().await;
-
-        // 转换为兼容的结构
-        Autoproxy {
-            enable: async_proxy.enable,
-            url: async_proxy.url,
-        }
-    }
-
-    async fn get_sys_proxy_with_timeout() -> Sysproxy {
-        let async_proxy = AsyncProxyQuery::get_system_proxy().await;
-
-        // 转换为兼容的结构
-        Sysproxy {
-            enable: async_proxy.enable,
-            host: async_proxy.host,
-            port: async_proxy.port,
-            bypass: async_proxy.bypass,
-        }
-    }
-
-    // 统一的状态更新方法
-    async fn update_state_timestamp<F>(state: &Arc<RwLock<ProxyState>>, update_fn: F)
-    where
-        F: FnOnce(&mut ProxyState),
-    {
-        let mut state_guard = state.write().await;
-        update_fn(&mut state_guard);
-        state_guard.last_updated = std::time::Instant::now();
-    }
-
-    async fn get_proxy_config() -> ProxyConfig {
-        let (sys_enabled, pac_enabled, guard_enabled) = {
-            let verge_config = Config::verge().await;
-            let verge = verge_config.latest_ref();
-            (
-                verge.enable_system_proxy.unwrap_or(false),
-                verge.proxy_auto_config.unwrap_or(false),
-                verge.enable_proxy_guard.unwrap_or(false),
-            )
-        };
-        ProxyConfig {
-            sys_enabled,
-            pac_enabled,
-            guard_enabled,
-        }
-    }
-
-    async fn get_expected_pac_config() -> Autoproxy {
-        let proxy_host = {
-            let verge_config = Config::verge().await;
-            let verge = verge_config.latest_ref();
-            verge
-                .proxy_host
-                .clone()
-                .unwrap_or_else(|| "127.0.0.1".to_string())
-        };
-        let pac_port = IVerge::get_singleton_port();
-        Autoproxy {
-            enable: true,
-            url: format!("http://{proxy_host}:{pac_port}/commands/pac"),
-        }
-    }
-
-    async fn get_expected_sys_proxy() -> Sysproxy {
-        let verge_config = Config::verge().await;
-        let verge_mixed_port = verge_config.latest_ref().verge_mixed_port;
-        let proxy_host = verge_config.latest_ref().proxy_host.clone();
-
-        let port = verge_mixed_port.unwrap_or(Config::clash().await.latest_ref().get_mixed_port());
-        let proxy_host = proxy_host.unwrap_or_else(|| "127.0.0.1".to_string());
-
-        Sysproxy {
-            enable: true,
-            host: proxy_host,
-            port,
-            bypass: Self::get_bypass_config().await,
-        }
-    }
-
-    async fn get_bypass_config() -> String {
-        let (use_default, custom_bypass) = {
-            let verge_config = Config::verge().await;
-            let verge = verge_config.latest_ref();
-            (
-                verge.use_default_bypass.unwrap_or(true),
-                verge.system_proxy_bypass.clone().unwrap_or_default(),
-            )
-        };
-
-        #[cfg(target_os = "windows")]
-        let default_bypass = "localhost;127.*;192.168.*;10.*;172.16.*;172.17.*;172.18.*;172.19.*;172.20.*;172.21.*;172.22.*;172.23.*;172.24.*;172.25.*;172.26.*;172.27.*;172.28.*;172.29.*;172.30.*;172.31.*;<local>";
-
-        #[cfg(target_os = "linux")]
-        let default_bypass =
-            "localhost,127.0.0.1,192.168.0.0/16,10.0.0.0/8,172.16.0.0/12,172.29.0.0/16,::1";
-
-        #[cfg(target_os = "macos")]
-        let default_bypass = "127.0.0.1,192.168.0.0/16,10.0.0.0/8,172.16.0.0/12,172.29.0.0/16,localhost,*.local,*.crashlytics.com,<local>";
-
-        if custom_bypass.is_empty() {
-            default_bypass.to_string()
-        } else if use_default {
-            format!("{default_bypass},{custom_bypass}")
-        } else {
-            custom_bypass
-        }
-    }
-
-    #[cfg(target_os = "windows")]
-    async fn restore_pac_proxy(expected_url: &str) -> Result<(), anyhow::Error> {
-        Self::execute_sysproxy_command(&["pac", expected_url]).await
-    }
-
-    #[allow(clippy::unused_async)]
-    #[cfg(not(target_os = "windows"))]
-    async fn restore_pac_proxy(expected_url: &str) -> Result<(), anyhow::Error> {
-        {
-            let new_autoproxy = Autoproxy {
-                enable: true,
-                url: expected_url.to_string(),
-            };
-            // logging_error!(Type::System, true, new_autoproxy.set_auto_proxy());
-            new_autoproxy
-                .set_auto_proxy()
-                .map_err(|e| anyhow::anyhow!("Failed to set auto proxy: {}", e))
-        }
-    }
-
-    #[cfg(target_os = "windows")]
-    async fn restore_sys_proxy(expected: &Sysproxy) -> Result<(), anyhow::Error> {
-        let address = format!("{}:{}", expected.host, expected.port);
-        Self::execute_sysproxy_command(&["global", &address, &expected.bypass]).await
-    }
-
-    #[allow(clippy::unused_async)]
-    #[cfg(not(target_os = "windows"))]
-    async fn restore_sys_proxy(expected: &Sysproxy) -> Result<(), anyhow::Error> {
-        {
-            // logging_error!(Type::System, true, expected.set_system_proxy());
-            expected
-                .set_system_proxy()
-                .map_err(|e| anyhow::anyhow!("Failed to set system proxy: {}", e))
-        }
-    }
-
-    #[cfg(target_os = "windows")]
-    async fn execute_sysproxy_command(args: &[&str]) -> Result<(), anyhow::Error> {
-        use crate::utils::dirs;
-        #[allow(unused_imports)] // creation_flags必须
-        use std::os::windows::process::CommandExt;
-        use tokio::process::Command;
-
-        let binary_path = match dirs::service_path() {
-            Ok(path) => path,
-            Err(e) => {
-                log::error!(target: "app", "获取服务路径失败: {e}");
-                return Err(e);
-            }
-        };
-
-        let sysproxy_exe = binary_path.with_file_name("sysproxy.exe");
-        if !sysproxy_exe.exists() {
-            log::error!(target: "app", "sysproxy.exe 不存在");
-        }
-        anyhow::ensure!(sysproxy_exe.exists(), "sysproxy.exe does not exist");
-
-        let _output = Command::new(sysproxy_exe)
-            .args(args)
-            .creation_flags(0x08000000) // CREATE_NO_WINDOW - 隐藏窗口
-            .output()
-            .await?;
-
-        Ok(())
-    }
-}

src-tauri/src/core/handle.rs

@@ -1,10 +1,9 @@
-use crate::singleton;
+use once_cell::sync::OnceCell;
 use parking_lot::RwLock;
 use std::{
     sync::{
-        Arc,
         atomic::{AtomicU64, Ordering},
-        mpsc,
+        mpsc, Arc,
     },
     thread,
     time::{Duration, Instant},
@@ -21,6 +20,7 @@ enum FrontendEvent {
     NoticeMessage { status: String, message: String },
     ProfileChanged { current_profile_id: String },
     TimerUpdated { profile_index: String },
+    StartupCompleted,
     ProfileUpdateStarted { uid: String },
     ProfileUpdateCompleted { uid: String },
 }
@@ -82,135 +82,136 @@ impl NotificationSystem {
 
         *self.last_emit_time.write() = Instant::now();
 
-        match thread::Builder::new()
-            .name("frontend-notifier".into())
-            .spawn(move || {
-                let handle = Handle::global();
+        self.worker_handle = Some(
+            thread::Builder::new()
+                .name("frontend-notifier".into())
+                .spawn(move || {
+                    let handle = Handle::global();
 
-                while !handle.is_exiting() {
-                    match rx.recv_timeout(Duration::from_millis(100)) {
-                        Ok(event) => {
-                            let system_guard = handle.notification_system.read();
-                            let Some(system) = system_guard.as_ref() else {
-                                log::warn!("NotificationSystem not found in handle while processing event.");
-                                continue;
-                            };
+                    while !handle.is_exiting() {
+                        match rx.recv_timeout(Duration::from_millis(100)) {
+                            Ok(event) => {
+                                let system_guard = handle.notification_system.read();
+                                if system_guard.as_ref().is_none() {
+                                    log::warn!("NotificationSystem not found in handle while processing event.");
+                                    continue;
+                                }
+                                let system = system_guard.as_ref().unwrap();
 
-                            let is_emergency = *system.emergency_mode.read();
+                                let is_emergency = *system.emergency_mode.read();
 
-                            if is_emergency
-                                && let FrontendEvent::NoticeMessage { ref status, .. } = event
-                                    && status == "info" {
-                                        log::warn!(
-                                            "Emergency mode active, skipping info message"
-                                        );
-                                        continue;
+                                if is_emergency {
+                                    if let FrontendEvent::NoticeMessage { ref status, .. } = event {
+                                        if status == "info" {
+                                            log::warn!(
+                                                "Emergency mode active, skipping info message"
+                                            );
+                                            continue;
+                                        }
                                     }
+                                }
 
-                            if let Some(window) = handle.get_window() {
-                                *system.last_emit_time.write() = Instant::now();
+                                if let Some(window) = handle.get_window() {
+                                    *system.last_emit_time.write() = Instant::now();
 
-                                let (event_name_str, payload_result) = match event {
-                                    FrontendEvent::RefreshClash => {
-                                        ("verge://refresh-clash-config", Ok(serde_json::json!("yes")))
-                                    }
-                                    FrontendEvent::RefreshVerge => {
-                                        ("verge://refresh-verge-config", Ok(serde_json::json!("yes")))
-                                    }
-                                    FrontendEvent::NoticeMessage { status, message } => {
-                                        match serde_json::to_value((status, message)) {
-                                            Ok(p) => ("verge://notice-message", Ok(p)),
+                                    let (event_name_str, payload_result) = match event {
+                                        FrontendEvent::RefreshClash => {
+                                            ("verge://refresh-clash-config", Ok(serde_json::json!("yes")))
+                                        }
+                                        FrontendEvent::RefreshVerge => {
+                                            ("verge://refresh-verge-config", Ok(serde_json::json!("yes")))
+                                        }
+                                        FrontendEvent::NoticeMessage { status, message } => {
+                                            match serde_json::to_value((status, message)) {
+                                                Ok(p) => ("verge://notice-message", Ok(p)),
+                                                Err(e) => {
+                                                    log::error!("Failed to serialize NoticeMessage payload: {}", e);
+                                                    ("verge://notice-message", Err(e))
+                                                }
+                                            }
+                                        }
+                                        FrontendEvent::ProfileChanged { current_profile_id } => {
+                                            ("profile-changed", Ok(serde_json::json!(current_profile_id)))
+                                        }
+                                        FrontendEvent::TimerUpdated { profile_index } => {
+                                            ("verge://timer-updated", Ok(serde_json::json!(profile_index)))
+                                        }
+                                        FrontendEvent::StartupCompleted => {
+                                            ("verge://startup-completed", Ok(serde_json::json!(null)))
+                                        }
+                                        FrontendEvent::ProfileUpdateStarted { uid } => {
+                                            ("profile-update-started", Ok(serde_json::json!({ "uid": uid })))
+                                        }
+                                        FrontendEvent::ProfileUpdateCompleted { uid } => {
+                                            ("profile-update-completed", Ok(serde_json::json!({ "uid": uid })))
+                                        }
+                                    };
+
+                                    if let Ok(payload) = payload_result {
+                                        match window.emit(event_name_str, payload) {
+                                            Ok(_) => {
+                                                system.stats.total_sent.fetch_add(1, Ordering::SeqCst);
+                                            }
                                             Err(e) => {
-                                                log::error!("Failed to serialize NoticeMessage payload: {e}");
-                                                ("verge://notice-message", Err(e))
-                                            }
-                                        }
-                                    }
-                                    FrontendEvent::ProfileChanged { current_profile_id } => {
-                                        ("profile-changed", Ok(serde_json::json!(current_profile_id)))
-                                    }
-                                    FrontendEvent::TimerUpdated { profile_index } => {
-                                        ("verge://timer-updated", Ok(serde_json::json!(profile_index)))
-                                    }
-                                    FrontendEvent::ProfileUpdateStarted { uid } => {
-                                        ("profile-update-started", Ok(serde_json::json!({ "uid": uid })))
-                                    }
-                                    FrontendEvent::ProfileUpdateCompleted { uid } => {
-                                        ("profile-update-completed", Ok(serde_json::json!({ "uid": uid })))
-                                    }
-                                };
+                                                log::warn!("Failed to emit event {}: {}", event_name_str, e);
+                                                system.stats.total_errors.fetch_add(1, Ordering::SeqCst);
+                                                *system.stats.last_error_time.write() = Some(Instant::now());
 
-                                if let Ok(payload) = payload_result {
-                                    match window.emit(event_name_str, payload) {
-                                        Ok(_) => {
-                                            system.stats.total_sent.fetch_add(1, Ordering::SeqCst);
-                                            // 记录成功发送的事件
-                                            if log::log_enabled!(log::Level::Debug) {
-                                                log::debug!("Successfully emitted event: {event_name_str}");
-                                            }
-                                        }
-                                        Err(e) => {
-                                            log::warn!("Failed to emit event {event_name_str}: {e}");
-                                            system.stats.total_errors.fetch_add(1, Ordering::SeqCst);
-                                            *system.stats.last_error_time.write() = Some(Instant::now());
-
-                                            let errors = system.stats.total_errors.load(Ordering::SeqCst);
-                                            const EMIT_ERROR_THRESHOLD: u64 = 10;
-                                            if errors > EMIT_ERROR_THRESHOLD && !*system.emergency_mode.read() {
-                                                log::warn!(
-                                                    "Reached {EMIT_ERROR_THRESHOLD} emit errors, entering emergency mode"
-                                                );
-                                                *system.emergency_mode.write() = true;
+                                                let errors = system.stats.total_errors.load(Ordering::SeqCst);
+                                                const EMIT_ERROR_THRESHOLD: u64 = 10;
+                                                if errors > EMIT_ERROR_THRESHOLD && !*system.emergency_mode.read() {
+                                                    log::warn!(
+                                                        "Reached {} emit errors, entering emergency mode",
+                                                        EMIT_ERROR_THRESHOLD
+                                                    );
+                                                    *system.emergency_mode.write() = true;
+                                                }
                                             }
                                         }
+                                    } else {
+                                        system.stats.total_errors.fetch_add(1, Ordering::SeqCst);
+                                        *system.stats.last_error_time.write() = Some(Instant::now());
+                                        log::warn!("Skipped emitting event due to payload serialization error for {}", event_name_str);
                                     }
                                 } else {
-                                    system.stats.total_errors.fetch_add(1, Ordering::SeqCst);
-                                    *system.stats.last_error_time.write() = Some(Instant::now());
-                                    log::warn!("Skipped emitting event due to payload serialization error for {event_name_str}");
+                                    log::warn!("No window found, skipping event emit.");
                                 }
-                            } else {
-                                log::warn!("No window found, skipping event emit.");
+                                thread::sleep(Duration::from_millis(20));
+                            }
+                            Err(mpsc::RecvTimeoutError::Timeout) => {
+                                continue;
+                            }
+                            Err(mpsc::RecvTimeoutError::Disconnected) => {
+                                log::info!(
+                                    "Notification channel disconnected, exiting worker thread"
+                                );
+                                break;
                             }
-                            thread::sleep(Duration::from_millis(20));
-                        }
-                        Err(mpsc::RecvTimeoutError::Timeout) => {
-                        }
-                        Err(mpsc::RecvTimeoutError::Disconnected) => {
-                            log::info!(
-                                "Notification channel disconnected, exiting worker thread"
-                            );
-                            break;
                         }
                     }
-                }
 
-                log::info!("Notification worker thread exiting");
-            }) {
-            Ok(handle) => {
-                self.worker_handle = Some(handle);
-            }
-            Err(e) => {
-                log::error!("Failed to start notification worker thread: {e}");
-            }
-        }
+                    log::info!("Notification worker thread exiting");
+                })
+                .expect("Failed to start notification worker thread"),
+        );
     }
 
     /// 发送事件到队列
     fn send_event(&self, event: FrontendEvent) -> bool {
-        if *self.emergency_mode.read()
-            && let FrontendEvent::NoticeMessage { ref status, .. } = event
-            && status == "info"
-        {
-            log::info!("Skipping info message in emergency mode");
-            return false;
+        if *self.emergency_mode.read() {
+            if let FrontendEvent::NoticeMessage { ref status, .. } = event {
+                if status == "info" {
+                    log::info!("Skipping info message in emergency mode");
+                    return false;
+                }
+            }
         }
 
         if let Some(sender) = &self.sender {
             match sender.send(event) {
                 Ok(_) => true,
                 Err(e) => {
-                    log::warn!("Failed to send event to notification queue: {e:?}");
+                    log::warn!("Failed to send event to notification queue: {:?}", e);
                     self.stats.total_errors.fetch_add(1, Ordering::SeqCst);
                     *self.stats.last_error_time.write() = Some(Instant::now());
                     false
@@ -223,27 +224,12 @@ impl NotificationSystem {
     }
 
     fn shutdown(&mut self) {
-        log::info!("NotificationSystem shutdown initiated");
         self.is_running = false;
+        self.sender = None;
 
-        // 先关闭发送端，让接收端知道不会再有新消息
-        if let Some(sender) = self.sender.take() {
-            drop(sender);
-        }
-
-        // 设置超时避免无限等待
         if let Some(handle) = self.worker_handle.take() {
-            match handle.join() {
-                Ok(_) => {
-                    log::info!("NotificationSystem worker thread joined successfully");
-                }
-                Err(e) => {
-                    log::error!("NotificationSystem worker thread join failed: {e:?}");
-                }
-            }
+            let _ = handle.join();
         }
-
-        log::info!("NotificationSystem shutdown completed");
     }
 }
 
@@ -268,18 +254,16 @@ impl Default for Handle {
     }
 }
 
-// Use singleton macro
-singleton!(Handle, HANDLE);
-
 impl Handle {
-    pub fn new() -> Self {
-        Self::default()
+    pub fn global() -> &'static Handle {
+        static HANDLE: OnceCell<Handle> = OnceCell::new();
+        HANDLE.get_or_init(Handle::default)
     }
 
-    pub fn init(&self, app_handle: AppHandle) {
+    pub fn init(&self, app_handle: &AppHandle) {
         {
             let mut handle = self.app_handle.write();
-            *handle = Some(app_handle);
+            *handle = Some(app_handle.clone());
         }
 
         let mut system_opt = self.notification_system.write();
@@ -288,7 +272,6 @@ impl Handle {
         }
     }
 
-    /// 获取 AppHandle
     pub fn app_handle(&self) -> Option<AppHandle> {
         self.app_handle.read().clone()
     }
@@ -360,6 +343,22 @@ impl Handle {
         }
     }
 
+    pub fn notify_startup_completed() {
+        let handle = Self::global();
+        if handle.is_exiting() {
+            return;
+        }
+
+        let system_opt = handle.notification_system.read();
+        if let Some(system) = system_opt.as_ref() {
+            system.send_event(FrontendEvent::StartupCompleted);
+        } else {
+            log::warn!(
+                "Notification system not initialized when trying to send StartupCompleted event."
+            );
+        }
+    }
+
     pub fn notify_profile_update_started(uid: String) {
         let handle = Self::global();
         if handle.is_exiting() {
@@ -370,9 +369,7 @@ impl Handle {
         if let Some(system) = system_opt.as_ref() {
             system.send_event(FrontendEvent::ProfileUpdateStarted { uid });
         } else {
-            log::warn!(
-                "Notification system not initialized when trying to send ProfileUpdateStarted event."
-            );
+            log::warn!("Notification system not initialized when trying to send ProfileUpdateStarted event.");
         }
     }
 
@@ -386,9 +383,7 @@ impl Handle {
         if let Some(system) = system_opt.as_ref() {
             system.send_event(FrontendEvent::ProfileUpdateCompleted { uid });
         } else {
-            log::warn!(
-                "Notification system not initialized when trying to send ProfileUpdateCompleted event."
-            );
+            log::warn!("Notification system not initialized when trying to send ProfileUpdateCompleted event.");
         }
     }
 
@@ -453,9 +448,8 @@ impl Handle {
             info,
             Type::Frontend,
             true,
-            "发送{}条启动时累积的错误消息: {:?}",
-            errors.len(),
-            errors
+            "发送{}条启动时累积的错误消息",
+            errors.len()
         );
 
         // 启动单独线程处理启动错误，避免阻塞主线程
@@ -487,7 +481,7 @@ impl Handle {
             });
 
         if let Err(e) = thread_result {
-            log::error!("Failed to spawn startup errors thread: {e}");
+            log::error!("Failed to spawn startup errors thread: {}", e);
         }
     }
 
@@ -505,54 +499,3 @@ impl Handle {
         *self.is_exiting.read()
     }
 }
-
-#[cfg(target_os = "macos")]
-impl Handle {
-    pub fn set_activation_policy(&self, policy: tauri::ActivationPolicy) -> Result<(), String> {
-        let app_handle = self.app_handle();
-        if let Some(app_handle) = app_handle.as_ref() {
-            app_handle
-                .set_activation_policy(policy)
-                .map_err(|e| e.to_string())
-        } else {
-            Err("AppHandle not initialized".to_string())
-        }
-    }
-
-    pub fn set_activation_policy_regular(&self) {
-        if let Err(e) = self.set_activation_policy(tauri::ActivationPolicy::Regular) {
-            logging!(
-                warn,
-                Type::Setup,
-                true,
-                "Failed to set regular activation policy: {}",
-                e
-            );
-        }
-    }
-
-    pub fn set_activation_policy_accessory(&self) {
-        if let Err(e) = self.set_activation_policy(tauri::ActivationPolicy::Accessory) {
-            logging!(
-                warn,
-                Type::Setup,
-                true,
-                "Failed to set accessory activation policy: {}",
-                e
-            );
-        }
-    }
-
-    #[allow(dead_code)]
-    pub fn set_activation_policy_prohibited(&self) {
-        if let Err(e) = self.set_activation_policy(tauri::ActivationPolicy::Prohibited) {
-            logging!(
-                warn,
-                Type::Setup,
-                true,
-                "Failed to set prohibited activation policy: {}",
-                e
-            );
-        }
-    }
-}

src-tauri/src/core/hotkey.rs

@@ -1,297 +1,34 @@
-use crate::process::AsyncHandler;
-use crate::utils::notification::{NotificationEvent, notify_event};
 use crate::{
-    config::Config, core::handle, feat, logging, logging_error,
-    module::lightweight::entry_lightweight_mode, singleton_with_logging, utils::logging::Type,
+    config::Config,
+    core::handle,
+    feat, logging, logging_error,
+    module::lightweight::entry_lightweight_mode,
+    process::AsyncHandler,
+    utils::{logging::Type, resolve},
 };
-use anyhow::{Result, bail};
+use anyhow::{bail, Result};
+use once_cell::sync::OnceCell;
 use parking_lot::Mutex;
-use std::{collections::HashMap, fmt, str::FromStr, sync::Arc};
-use tauri::{AppHandle, Manager};
+use std::{collections::HashMap, sync::Arc};
+use tauri::Manager;
 use tauri_plugin_global_shortcut::{Code, GlobalShortcutExt, ShortcutState};
 
-/// Enum representing all available hotkey functions
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum HotkeyFunction {
-    OpenOrCloseDashboard,
-    ClashModeRule,
-    ClashModeGlobal,
-    ClashModeDirect,
-    ToggleSystemProxy,
-    ToggleTunMode,
-    EntryLightweightMode,
-    Quit,
-    #[cfg(target_os = "macos")]
-    Hide,
-}
-
-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",
-            #[cfg(target_os = "macos")]
-            HotkeyFunction::Hide => "hide",
-        };
-        write!(f, "{s}")
-    }
-}
-
-impl FromStr for HotkeyFunction {
-    type Err = anyhow::Error;
-
-    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),
-            #[cfg(target_os = "macos")]
-            "hide" => Ok(HotkeyFunction::Hide),
-            _ => bail!("invalid hotkey function: {}", s),
-        }
-    }
-}
-
-#[cfg(target_os = "macos")]
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-/// Enum representing predefined system hotkeys
-pub enum SystemHotkey {
-    CmdQ,
-    CmdW,
-}
-
-#[cfg(target_os = "macos")]
-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",
-        };
-        write!(f, "{s}")
-    }
-}
-
-#[cfg(target_os = "macos")]
-impl SystemHotkey {
-    pub fn function(self) -> HotkeyFunction {
-        match self {
-            SystemHotkey::CmdQ => HotkeyFunction::Quit,
-            SystemHotkey::CmdW => HotkeyFunction::Hide,
-        }
-    }
-}
-
 pub struct Hotkey {
-    current: Arc<Mutex<Vec<String>>>,
+    current: Arc<Mutex<Vec<String>>>, // 保存当前的热键设置
 }
 
 impl Hotkey {
-    fn new() -> Self {
-        Self {
+    pub fn global() -> &'static Hotkey {
+        static HOTKEY: OnceCell<Hotkey> = OnceCell::new();
+
+        HOTKEY.get_or_init(|| Hotkey {
             current: Arc::new(Mutex::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();
-        match function {
-            HotkeyFunction::OpenOrCloseDashboard => {
-                AsyncHandler::spawn(async move || {
-                    crate::feat::open_or_close_dashboard().await;
-                    notify_event(app_handle, 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;
-                });
-            }
-            HotkeyFunction::ClashModeGlobal => {
-                AsyncHandler::spawn(async move || {
-                    feat::change_clash_mode("global".into()).await;
-                    notify_event(
-                        app_handle,
-                        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;
-                });
-            }
-            HotkeyFunction::ToggleSystemProxy => {
-                AsyncHandler::spawn(async move || {
-                    feat::toggle_system_proxy().await;
-                    notify_event(app_handle, NotificationEvent::SystemProxyToggled).await;
-                });
-            }
-            HotkeyFunction::ToggleTunMode => {
-                AsyncHandler::spawn(async move || {
-                    feat::toggle_tun_mode(None).await;
-                    notify_event(app_handle, NotificationEvent::TunModeToggled).await;
-                });
-            }
-            HotkeyFunction::EntryLightweightMode => {
-                AsyncHandler::spawn(async move || {
-                    entry_lightweight_mode().await;
-                    notify_event(app_handle, NotificationEvent::LightweightModeEntered).await;
-                });
-            }
-            HotkeyFunction::Quit => {
-                AsyncHandler::spawn(async move || {
-                    notify_event(app_handle, NotificationEvent::AppQuit).await;
-                    feat::quit().await;
-                });
-            }
-            #[cfg(target_os = "macos")]
-            HotkeyFunction::Hide => {
-                AsyncHandler::spawn(async move || {
-                    feat::hide().await;
-                    notify_event(app_handle, NotificationEvent::AppHidden).await;
-                });
-            }
-        }
-    }
-
-    #[cfg(target_os = "macos")]
-    /// Register a system hotkey using enum
-    pub async fn register_system_hotkey(&self, hotkey: SystemHotkey) -> Result<()> {
-        let hotkey_str = hotkey.to_string();
-        let function = hotkey.function();
-        self.register_hotkey_with_function(&hotkey_str, function)
-            .await
-    }
-
-    #[cfg(target_os = "macos")]
-    /// Unregister a system hotkey using enum
-    pub fn unregister_system_hotkey(&self, hotkey: SystemHotkey) -> Result<()> {
-        let hotkey_str = hotkey.to_string();
-        self.unregister(&hotkey_str)
-    }
-
-    /// Register a hotkey with function enum
-    #[allow(clippy::unused_async)]
-    pub async fn register_hotkey_with_function(
-        &self,
-        hotkey: &str,
-        function: HotkeyFunction,
-    ) -> Result<()> {
-        let app_handle = handle::Handle::global()
-            .app_handle()
-            .ok_or_else(|| anyhow::anyhow!("Failed to get app handle for hotkey registration"))?;
-        let manager = app_handle.global_shortcut();
-
-        logging!(
-            debug,
-            Type::Hotkey,
-            "Attempting to register hotkey: {} for function: {}",
-            hotkey,
-            function
-        );
-
-        if manager.is_registered(hotkey) {
-            logging!(
-                debug,
-                Type::Hotkey,
-                "Hotkey {} was already registered, unregistering first",
-                hotkey
-            );
-            manager.unregister(hotkey)?;
-        }
-
-        let is_quit = matches!(function, HotkeyFunction::Quit);
-
-        let _ = 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!(
-                        debug,
-                        Type::Hotkey,
-                        "Hotkey pressed: {:?}",
-                        hotkey_event_owned
-                    );
-
-                    if hotkey_event_owned.key == Code::KeyQ && is_quit_owned {
-                        if let Some(window) = app_handle_cloned.get_webview_window("main")
-                            && window.is_focused().unwrap_or(false)
-                        {
-                            logging!(debug, Type::Hotkey, "Executing quit function");
-                            Self::execute_function(function_owned, &app_handle_cloned);
-                        }
-                    } else {
-                        logging!(debug, Type::Hotkey, "Executing function directly");
-
-                        let is_enable_global_hotkey = Config::verge()
-                            .await
-                            .latest_ref()
-                            .enable_global_hotkey
-                            .unwrap_or(true);
-
-                        if is_enable_global_hotkey {
-                            Self::execute_function(function_owned, &app_handle_cloned);
-                        } 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);
-                            }
-                        }
-                    }
-                }
-            });
-        });
-
-        logging!(
-            debug,
-            Type::Hotkey,
-            "Successfully registered hotkey {} for {}",
-            hotkey,
-            function
-        );
-        Ok(())
-    }
-}
-
-// Use unified singleton macro
-singleton_with_logging!(Hotkey, INSTANCE, "Hotkey");
-
-impl Hotkey {
-    pub async fn init(&self) -> Result<()> {
-        let verge = Config::verge().await;
-        let enable_global_hotkey = verge.latest_ref().enable_global_hotkey.unwrap_or(true);
+    pub fn init(&self) -> Result<()> {
+        let verge = Config::verge();
+        let enable_global_hotkey = verge.latest().enable_global_hotkey.unwrap_or(true);
 
         logging!(
             debug,
@@ -301,14 +38,12 @@ 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();
-
-        if let Some(hotkeys) = hotkeys {
+        if let Some(hotkeys) = verge.latest().hotkeys.as_ref() {
             logging!(
                 debug,
                 Type::Hotkey,
@@ -332,7 +67,7 @@ impl Hotkey {
                             key,
                             func
                         );
-                        if let Err(e) = self.register(key, func).await {
+                        if let Err(e) = self.register(key, func) {
                             logging!(
                                 error,
                                 Type::Hotkey,
@@ -366,7 +101,7 @@ impl Hotkey {
                     }
                 }
             }
-            self.current.lock().clone_from(&hotkeys);
+            self.current.lock().clone_from(hotkeys);
         } else {
             logging!(debug, Type::Hotkey, "No hotkeys configured");
         }
@@ -375,34 +110,161 @@ impl Hotkey {
     }
 
     pub fn reset(&self) -> Result<()> {
-        let app_handle = handle::Handle::global()
-            .app_handle()
-            .ok_or_else(|| anyhow::anyhow!("Failed to get app handle for hotkey registration"))?;
+        let app_handle = handle::Handle::global().app_handle().unwrap();
         let manager = app_handle.global_shortcut();
         manager.unregister_all()?;
         Ok(())
     }
 
-    /// Register a hotkey with string-based function (backward compatibility)
-    pub async fn register(&self, hotkey: &str, func: &str) -> Result<()> {
-        let function = HotkeyFunction::from_str(func)?;
-        self.register_hotkey_with_function(hotkey, function).await
+    pub fn register(&self, hotkey: &str, func: &str) -> Result<()> {
+        let app_handle = handle::Handle::global().app_handle().unwrap();
+        let manager = app_handle.global_shortcut();
+
+        logging!(
+            debug,
+            Type::Hotkey,
+            "Attempting to register hotkey: {} for function: {}",
+            hotkey,
+            func
+        );
+
+        if manager.is_registered(hotkey) {
+            logging!(
+                debug,
+                Type::Hotkey,
+                "Hotkey {} was already registered, unregistering first",
+                hotkey
+            );
+            manager.unregister(hotkey)?;
+        }
+
+        let f = match func.trim() {
+            "open_or_close_dashboard" => {
+                logging!(
+                    debug,
+                    Type::Hotkey,
+                    "Registering open_or_close_dashboard function"
+                );
+                || {
+                    logging!(
+                        debug,
+                        Type::Hotkey,
+                        true,
+                        "=== Hotkey Dashboard Window Operation Start ==="
+                    );
+
+                    // 使用 spawn_blocking 来确保在正确的线程上执行
+                    AsyncHandler::spawn_blocking(|| {
+                        logging!(debug, Type::Hotkey, "Toggle dashboard window visibility");
+
+                        // 检查窗口是否存在
+                        if let Some(window) = handle::Handle::global().get_window() {
+                            // 如果窗口可见，则隐藏它
+                            if window.is_visible().unwrap_or(false) {
+                                logging!(info, Type::Window, "Window is visible, hiding it");
+                                let _ = window.hide();
+                            } else {
+                                // 如果窗口不可见，则显示它
+                                logging!(info, Type::Window, "Window is hidden, showing it");
+                                if window.is_minimized().unwrap_or(false) {
+                                    let _ = window.unminimize();
+                                }
+                                let _ = window.show();
+                                let _ = window.set_focus();
+                            }
+                        } else {
+                            // 如果窗口不存在，创建一个新窗口
+                            logging!(
+                                info,
+                                Type::Window,
+                                "Window does not exist, creating a new one"
+                            );
+                            resolve::create_window(true);
+                        }
+                    });
+
+                    logging!(
+                        debug,
+                        Type::Hotkey,
+                        "=== Hotkey Dashboard Window Operation End ==="
+                    );
+                }
+            }
+            "clash_mode_rule" => || feat::change_clash_mode("rule".into()),
+            "clash_mode_global" => || feat::change_clash_mode("global".into()),
+            "clash_mode_direct" => || feat::change_clash_mode("direct".into()),
+            "toggle_system_proxy" => || feat::toggle_system_proxy(),
+            "toggle_tun_mode" => || feat::toggle_tun_mode(None),
+            "entry_lightweight_mode" => || entry_lightweight_mode(),
+            "quit" => || feat::quit(),
+            #[cfg(target_os = "macos")]
+            "hide" => || feat::hide(),
+
+            _ => {
+                logging!(error, Type::Hotkey, "Invalid function: {}", func);
+                bail!("invalid function \"{func}\"");
+            }
+        };
+
+        let is_quit = func.trim() == "quit";
+
+        let _ = manager.on_shortcut(hotkey, move |app_handle, hotkey, event| {
+            if event.state == ShortcutState::Pressed {
+                logging!(debug, Type::Hotkey, "Hotkey pressed: {:?}", hotkey);
+
+                if hotkey.key == Code::KeyQ && is_quit {
+                    if let Some(window) = app_handle.get_webview_window("main") {
+                        if window.is_focused().unwrap_or(false) {
+                            logging!(debug, Type::Hotkey, "Executing quit function");
+                            f();
+                        }
+                    }
+                } else {
+                    // 直接执行函数，不做任何状态检查
+                    logging!(debug, Type::Hotkey, "Executing function directly");
+
+                    // 获取全局热键状态
+                    let is_enable_global_hotkey = Config::verge()
+                        .latest()
+                        .enable_global_hotkey
+                        .unwrap_or(true);
+
+                    if is_enable_global_hotkey {
+                        f();
+                    } else if let Some(window) = app_handle.get_webview_window("main") {
+                        // 非轻量模式且未启用全局热键时，只在窗口可见且有焦点的情况下响应热键
+                        let is_visible = window.is_visible().unwrap_or(false);
+                        let is_focused = window.is_focused().unwrap_or(false);
+
+                        if is_focused && is_visible {
+                            f();
+                        }
+                    }
+                }
+            }
+        });
+
+        logging!(
+            debug,
+            Type::Hotkey,
+            "Successfully registered hotkey {} for {}",
+            hotkey,
+            func
+        );
+        Ok(())
     }
 
     pub fn unregister(&self, hotkey: &str) -> Result<()> {
-        let app_handle = handle::Handle::global()
-            .app_handle()
-            .ok_or_else(|| anyhow::anyhow!("Failed to get app handle for hotkey registration"))?;
+        let app_handle = handle::Handle::global().app_handle().unwrap();
         let manager = app_handle.global_shortcut();
         manager.unregister(hotkey)?;
         logging!(debug, Type::Hotkey, "Unregister hotkey {}", hotkey);
         Ok(())
     }
 
-    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);
+    pub fn update(&self, new_hotkeys: Vec<String>) -> Result<()> {
+        let mut current = self.current.lock();
+        let old_map = Self::get_map_from_vec(&current);
         let new_map = Self::get_map_from_vec(&new_hotkeys);
 
         let (del, add) = Self::get_diff(old_map, new_map);
@@ -411,12 +273,11 @@ impl Hotkey {
             let _ = self.unregister(key);
         });
 
-        for (key, func) in add.iter() {
-            logging_error!(Type::Hotkey, self.register(key, func).await);
-        }
+        add.iter().for_each(|(key, func)| {
+            logging_error!(Type::Hotkey, self.register(key, func));
+        });
 
-        // Update the current hotkeys after all async operations
-        *self.current.lock() = new_hotkeys;
+        *current = new_hotkeys;
         Ok(())
     }
 
@@ -428,9 +289,9 @@ impl Hotkey {
             let func = iter.next();
             let key = iter.next();
 
-            if let (Some(func), Some(key)) = (func, key) {
-                let func = func.trim();
-                let key = key.trim();
+            if func.is_some() && key.is_some() {
+                let func = func.unwrap().trim();
+                let key = key.unwrap().trim();
                 map.insert(key, func);
             }
         });
@@ -468,17 +329,7 @@ impl Hotkey {
 
 impl Drop for Hotkey {
     fn drop(&mut self) {
-        let app_handle = match handle::Handle::global().app_handle() {
-            Some(handle) => handle,
-            None => {
-                logging!(
-                    error,
-                    Type::Hotkey,
-                    "Failed to get app handle during hotkey cleanup"
-                );
-                return;
-            }
-        };
+        let app_handle = handle::Handle::global().app_handle().unwrap();
         if let Err(e) = app_handle.global_shortcut().unregister_all() {
             logging!(
                 error,

src-tauri/src/core/mod.rs

@@ -1,8 +1,6 @@
-pub mod async_proxy_query;
 pub mod backup;
 #[allow(clippy::module_inception)]
 mod core;
-pub mod event_driven_proxy;
 pub mod handle;
 pub mod hotkey;
 pub mod service;
@@ -12,4 +10,4 @@ pub mod timer;
 pub mod tray;
 pub mod win_uwp;
 
-pub use self::{core::*, event_driven_proxy::EventDrivenProxyManager, timer::Timer};
+pub use self::{core::*, timer::Timer};

src-tauri/src/core/service_ipc.rs

@@ -1,15 +1,9 @@
 use crate::{logging, utils::logging::Type};
-use anyhow::{Context, Result, bail};
-use backoff::{Error as BackoffError, ExponentialBackoff};
+use anyhow::{bail, Context, Result};
 use hmac::{Hmac, Mac};
 use serde::{Deserialize, Serialize};
 use sha2::{Digest, Sha256};
-use std::time::{Duration, SystemTime, UNIX_EPOCH};
-use tokio::io::{AsyncReadExt, AsyncWriteExt};
-#[cfg(unix)]
-use tokio::net::UnixStream;
-#[cfg(windows)]
-use tokio::net::windows::named_pipe::ClientOptions;
+use std::time::{SystemTime, UNIX_EPOCH};
 
 const IPC_SOCKET_NAME: &str = if cfg!(windows) {
     r"\\.\pipe\clash-verge-service"
@@ -116,134 +110,170 @@ pub fn verify_response_signature(response: &IpcResponse) -> Result<bool> {
     Ok(expected_signature == response.signature)
 }
 
-fn create_backoff_strategy() -> ExponentialBackoff {
-    ExponentialBackoff {
-        initial_interval: Duration::from_millis(50),
-        max_interval: Duration::from_secs(1),
-        max_elapsed_time: Some(Duration::from_secs(3)),
-        multiplier: 1.5,
-        ..Default::default()
-    }
-}
-
+// IPC连接管理-win
+#[cfg(target_os = "windows")]
 pub async fn send_ipc_request(
     command: IpcCommand,
     payload: serde_json::Value,
 ) -> Result<IpcResponse> {
-    let command_type = format!("{command:?}");
+    use std::{
+        ffi::CString,
+        fs::File,
+        io::{Read, Write},
+        os::windows::io::{FromRawHandle, RawHandle},
+        ptr,
+    };
+    use winapi::um::{
+        fileapi::{CreateFileA, OPEN_EXISTING},
+        handleapi::INVALID_HANDLE_VALUE,
+        winnt::{FILE_SHARE_READ, FILE_SHARE_WRITE, GENERIC_READ, GENERIC_WRITE},
+    };
 
-    let operation = || async {
-        match send_ipc_request_internal(command.clone(), payload.clone()).await {
-            Ok(response) => Ok(response),
-            Err(e) => {
-                logging!(
-                    warn,
-                    Type::Service,
-                    true,
-                    "IPC请求失败，准备重试: 命令={}, 错误={}",
-                    command_type,
-                    e
-                );
-                Err(BackoffError::transient(e))
-            }
+    logging!(info, Type::Service, true, "正在连接服务 (Windows)...");
+
+    let command_type = format!("{:?}", command);
+
+    let request = match create_signed_request(command, payload) {
+        Ok(req) => req,
+        Err(e) => {
+            logging!(error, Type::Service, true, "创建签名请求失败: {}", e);
+            return Err(e);
         }
     };
 
-    match backoff::future::retry(create_backoff_strategy(), operation).await {
-        Ok(response) => {
-            // logging!(
-            //     info,
-            //     Type::Service,
-            //     true,
-            //     "IPC请求成功: 命令={}, 成功={}",
-            //     command_type,
-            //     response.success
-            // );
-            Ok(response)
-        }
-        Err(e) => {
+    let request_json = serde_json::to_string(&request)?;
+
+    let result = tokio::task::spawn_blocking(move || -> Result<IpcResponse> {
+        let c_pipe_name = match CString::new(IPC_SOCKET_NAME) {
+            Ok(name) => name,
+            Err(e) => {
+                logging!(error, Type::Service, true, "创建CString失败: {}", e);
+                return Err(anyhow::anyhow!("创建CString失败: {}", e));
+            }
+        };
+
+        let handle = unsafe {
+            CreateFileA(
+                c_pipe_name.as_ptr(),
+                GENERIC_READ | GENERIC_WRITE,
+                FILE_SHARE_READ | FILE_SHARE_WRITE,
+                ptr::null_mut(),
+                OPEN_EXISTING,
+                0,
+                ptr::null_mut(),
+            )
+        };
+
+        if handle == INVALID_HANDLE_VALUE {
+            let error = std::io::Error::last_os_error();
             logging!(
                 error,
                 Type::Service,
                 true,
-                "IPC请求最终失败，重试已耗尽: 命令={}, 错误={}",
-                command_type,
-                e
+                "连接到服务命名管道失败: {}",
+                error
             );
-            Err(anyhow::anyhow!("IPC请求重试失败: {}", e))
+            return Err(anyhow::anyhow!("无法连接到服务命名管道: {}", error));
         }
-    }
-}
 
-// 内部IPC请求实现（不带重试）
-async fn send_ipc_request_internal(
-    command: IpcCommand,
-    payload: serde_json::Value,
-) -> Result<IpcResponse> {
-    #[cfg(target_os = "windows")]
-    {
-        send_ipc_request_windows(command, payload).await
-    }
-    #[cfg(target_family = "unix")]
-    {
-        send_ipc_request_unix(command, payload).await
-    }
-}
+        let mut pipe = unsafe { File::from_raw_handle(handle as RawHandle) };
+        logging!(info, Type::Service, true, "服务连接成功 (Windows)");
 
-// IPC连接管理-win
-#[cfg(target_os = "windows")]
-async fn send_ipc_request_windows(
-    command: IpcCommand,
-    payload: serde_json::Value,
-) -> Result<IpcResponse> {
-    let request = create_signed_request(command, payload)?;
-    let request_json = serde_json::to_string(&request)?;
-    let request_bytes = request_json.as_bytes();
-    let len_bytes = (request_bytes.len() as u32).to_be_bytes();
+        let request_bytes = request_json.as_bytes();
+        let len_bytes = (request_bytes.len() as u32).to_be_bytes();
 
-    let mut pipe = match ClientOptions::new().open(IPC_SOCKET_NAME) {
-        Ok(p) => p,
-        Err(e) => {
-            logging!(error, Type::Service, true, "连接到服务命名管道失败: {}", e);
-            return Err(anyhow::anyhow!("无法连接到服务命名管道: {}", e));
+        if let Err(e) = pipe.write_all(&len_bytes) {
+            logging!(error, Type::Service, true, "写入请求长度失败: {}", e);
+            return Err(anyhow::anyhow!("写入请求长度失败: {}", e));
         }
-    };
 
-    logging!(info, Type::Service, true, "服务连接成功 (Windows)");
+        if let Err(e) = pipe.write_all(request_bytes) {
+            logging!(error, Type::Service, true, "写入请求内容失败: {}", e);
+            return Err(anyhow::anyhow!("写入请求内容失败: {}", e));
+        }
 
-    pipe.write_all(&len_bytes).await?;
-    pipe.write_all(request_bytes).await?;
-    pipe.flush().await?;
+        if let Err(e) = pipe.flush() {
+            logging!(error, Type::Service, true, "刷新管道失败: {}", e);
+            return Err(anyhow::anyhow!("刷新管道失败: {}", e));
+        }
 
-    let mut response_len_bytes = [0u8; 4];
-    pipe.read_exact(&mut response_len_bytes).await?;
-    let response_len = u32::from_be_bytes(response_len_bytes) as usize;
+        let mut response_len_bytes = [0u8; 4];
+        if let Err(e) = pipe.read_exact(&mut response_len_bytes) {
+            logging!(error, Type::Service, true, "读取响应长度失败: {}", e);
+            return Err(anyhow::anyhow!("读取响应长度失败: {}", e));
+        }
 
-    let mut response_bytes = vec![0u8; response_len];
-    pipe.read_exact(&mut response_bytes).await?;
+        let response_len = u32::from_be_bytes(response_len_bytes) as usize;
 
-    let response: IpcResponse = serde_json::from_slice(&response_bytes)
-        .map_err(|e| anyhow::anyhow!("解析响应失败: {}", e))?;
+        let mut response_bytes = vec![0u8; response_len];
+        if let Err(e) = pipe.read_exact(&mut response_bytes) {
+            logging!(error, Type::Service, true, "读取响应内容失败: {}", e);
+            return Err(anyhow::anyhow!("读取响应内容失败: {}", e));
+        }
 
-    if !verify_response_signature(&response)? {
-        logging!(error, Type::Service, true, "服务响应签名验证失败");
-        bail!("服务响应签名验证失败");
-    }
+        let response: IpcResponse = match serde_json::from_slice::<IpcResponse>(&response_bytes) {
+            Ok(r) => r,
+            Err(e) => {
+                logging!(error, Type::Service, true, "服务响应解析失败: {}", e);
+                return Err(anyhow::anyhow!("解析响应失败: {}", e));
+            }
+        };
 
-    Ok(response)
+        match verify_response_signature(&response) {
+            Ok(valid) => {
+                if !valid {
+                    logging!(error, Type::Service, true, "服务响应签名验证失败");
+                    bail!("服务响应签名验证失败");
+                }
+            }
+            Err(e) => {
+                logging!(error, Type::Service, true, "验证响应签名时出错: {}", e);
+                return Err(e);
+            }
+        }
+
+        logging!(
+            info,
+            Type::Service,
+            true,
+            "IPC请求完成: 命令={}, 成功={}",
+            command_type,
+            response.success
+        );
+        Ok(response)
+    })
+    .await??;
+
+    Ok(result)
 }
 
 // IPC连接管理-unix
 #[cfg(target_family = "unix")]
-async fn send_ipc_request_unix(
+pub async fn send_ipc_request(
     command: IpcCommand,
     payload: serde_json::Value,
 ) -> Result<IpcResponse> {
-    let request = create_signed_request(command, payload)?;
+    use std::os::unix::net::UnixStream;
+
+    logging!(info, Type::Service, true, "正在连接服务 (Unix)...");
+
+    let command_type = format!("{:?}", command);
+
+    let request = match create_signed_request(command, payload) {
+        Ok(req) => req,
+        Err(e) => {
+            logging!(error, Type::Service, true, "创建签名请求失败: {}", e);
+            return Err(e);
+        }
+    };
+
     let request_json = serde_json::to_string(&request)?;
 
-    let mut stream = match UnixStream::connect(IPC_SOCKET_NAME).await {
-        Ok(s) => s,
+    let mut stream = match UnixStream::connect(IPC_SOCKET_NAME) {
+        Ok(s) => {
+            logging!(info, Type::Service, true, "服务连接成功 (Unix)");
+            s
+        }
         Err(e) => {
             logging!(error, Type::Service, true, "连接到Unix套接字失败: {}", e);
             return Err(anyhow::anyhow!("无法连接到服务Unix套接字: {}", e));
@@ -253,97 +283,58 @@ async fn send_ipc_request_unix(
     let request_bytes = request_json.as_bytes();
     let len_bytes = (request_bytes.len() as u32).to_be_bytes();
 
-    stream.write_all(&len_bytes).await?;
-    stream.write_all(request_bytes).await?;
-    stream.flush().await?;
+    if let Err(e) = std::io::Write::write_all(&mut stream, &len_bytes) {
+        logging!(error, Type::Service, true, "写入请求长度失败: {}", e);
+        return Err(anyhow::anyhow!("写入请求长度失败: {}", e));
+    }
+
+    if let Err(e) = std::io::Write::write_all(&mut stream, request_bytes) {
+        logging!(error, Type::Service, true, "写入请求内容失败: {}", e);
+        return Err(anyhow::anyhow!("写入请求内容失败: {}", e));
+    }
 
-    // 读取响应长度
     let mut response_len_bytes = [0u8; 4];
-    stream.read_exact(&mut response_len_bytes).await?;
+    if let Err(e) = std::io::Read::read_exact(&mut stream, &mut response_len_bytes) {
+        logging!(error, Type::Service, true, "读取响应长度失败: {}", e);
+        return Err(anyhow::anyhow!("读取响应长度失败: {}", e));
+    }
+
     let response_len = u32::from_be_bytes(response_len_bytes) as usize;
 
     let mut response_bytes = vec![0u8; response_len];
-    stream.read_exact(&mut response_bytes).await?;
-
-    let response: IpcResponse = serde_json::from_slice(&response_bytes)
-        .map_err(|e| anyhow::anyhow!("解析响应失败: {}", e))?;
-
-    if !verify_response_signature(&response)? {
-        logging!(error, Type::Service, true, "服务响应签名验证失败");
-        bail!("服务响应签名验证失败");
+    if let Err(e) = std::io::Read::read_exact(&mut stream, &mut response_bytes) {
+        logging!(error, Type::Service, true, "读取响应内容失败: {}", e);
+        return Err(anyhow::anyhow!("读取响应内容失败: {}", e));
     }
 
+    let response: IpcResponse = match serde_json::from_slice::<IpcResponse>(&response_bytes) {
+        Ok(r) => r,
+        Err(e) => {
+            logging!(error, Type::Service, true, "服务响应解析失败: {}", e,);
+            return Err(anyhow::anyhow!("解析响应失败: {}", e));
+        }
+    };
+
+    match verify_response_signature(&response) {
+        Ok(valid) => {
+            if !valid {
+                logging!(error, Type::Service, true, "服务响应签名验证失败");
+                bail!("服务响应签名验证失败");
+            }
+        }
+        Err(e) => {
+            logging!(error, Type::Service, true, "验证响应签名时出错: {}", e);
+            return Err(e);
+        }
+    }
+
+    logging!(
+        info,
+        Type::Service,
+        true,
+        "IPC请求完成: 命令={}, 成功={}",
+        command_type,
+        response.success
+    );
     Ok(response)
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_create_signed_request() {
-        let command = IpcCommand::GetVersion;
-        let payload = serde_json::json!({"test": "data"});
-
-        let result = create_signed_request(command, payload);
-        assert!(result.is_ok());
-
-        if let Ok(request) = result {
-            assert!(!request.id.is_empty());
-            assert!(!request.signature.is_empty());
-            assert_eq!(request.command, IpcCommand::GetVersion);
-        }
-    }
-
-    #[test]
-    fn test_sign_and_verify_message() {
-        let test_message = "test message for signing";
-
-        let signature_result = sign_message(test_message);
-        assert!(signature_result.is_ok());
-
-        if let Ok(signature) = signature_result {
-            assert!(!signature.is_empty());
-
-            // 测试相同消息产生相同签名
-            if let Ok(signature2) = sign_message(test_message) {
-                assert_eq!(signature, signature2);
-            }
-        }
-    }
-
-    #[test]
-    fn test_verify_response_signature() {
-        let response = IpcResponse {
-            id: "test-id".to_string(),
-            success: true,
-            data: Some(serde_json::json!({"result": "success"})),
-            error: None,
-            signature: String::new(),
-        };
-
-        // 创建正确的签名
-        let verification_response = IpcResponse {
-            id: response.id.clone(),
-            success: response.success,
-            data: response.data.clone(),
-            error: response.error.clone(),
-            signature: String::new(),
-        };
-
-        if let Ok(message) = serde_json::to_string(&verification_response)
-            && let Ok(correct_signature) = sign_message(&message)
-        {
-            let signed_response = IpcResponse {
-                signature: correct_signature,
-                ..response
-            };
-
-            let verification_result = verify_response_signature(&signed_response);
-            assert!(verification_result.is_ok());
-            if let Ok(is_valid) = verification_result {
-                assert!(is_valid);
-            }
-        }
-    }
-}

src-tauri/src/core/sysopt.rs

@@ -2,20 +2,25 @@
 use crate::utils::autostart as startup_shortcut;
 use crate::{
     config::{Config, IVerge},
-    core::{EventDrivenProxyManager, handle::Handle},
-    logging, logging_error, singleton_lazy,
+    core::handle::Handle,
+    logging, logging_error,
+    process::AsyncHandler,
     utils::logging::Type,
 };
 use anyhow::Result;
+use once_cell::sync::OnceCell;
+use parking_lot::Mutex;
 use std::sync::Arc;
-#[cfg(not(target_os = "windows"))]
 use sysproxy::{Autoproxy, Sysproxy};
 use tauri::async_runtime::Mutex as TokioMutex;
 use tauri_plugin_autostart::ManagerExt;
+use tokio::time::{sleep, Duration};
 
 pub struct Sysopt {
     update_sysproxy: Arc<TokioMutex<bool>>,
     reset_sysproxy: Arc<TokioMutex<bool>>,
+    /// record whether the guard async is running or not
+    guard_state: Arc<Mutex<bool>>,
 }
 
 #[cfg(target_os = "windows")]
@@ -24,17 +29,14 @@ static DEFAULT_BYPASS: &str = "localhost;127.*;192.168.*;10.*;172.16.*;172.17.*;
 static DEFAULT_BYPASS: &str =
     "localhost,127.0.0.1,192.168.0.0/16,10.0.0.0/8,172.16.0.0/12,172.29.0.0/16,::1";
 #[cfg(target_os = "macos")]
-static DEFAULT_BYPASS: &str = "127.0.0.1,192.168.0.0/16,10.0.0.0/8,172.16.0.0/12,172.29.0.0/16,localhost,*.local,*.crashlytics.com,<local>";
+static DEFAULT_BYPASS: &str =
+    "127.0.0.1,192.168.0.0/16,10.0.0.0/8,172.16.0.0/12,172.29.0.0/16,localhost,*.local,*.crashlytics.com,<local>";
 
-async fn get_bypass() -> String {
-    let use_default = Config::verge()
-        .await
-        .latest_ref()
-        .use_default_bypass
-        .unwrap_or(true);
+fn get_bypass() -> String {
+    let use_default = Config::verge().latest().use_default_bypass.unwrap_or(true);
     let res = {
-        let verge = Config::verge().await;
-        let verge = verge.latest_ref();
+        let verge = Config::verge();
+        let verge = verge.latest();
         verge.system_proxy_bypass.clone()
     };
     let custom_bypass = match res {
@@ -45,31 +47,24 @@ async fn get_bypass() -> String {
     if custom_bypass.is_empty() {
         DEFAULT_BYPASS.to_string()
     } else if use_default {
-        format!("{DEFAULT_BYPASS},{custom_bypass}")
+        format!("{},{}", DEFAULT_BYPASS, custom_bypass)
     } else {
         custom_bypass
     }
 }
 
-impl Default for Sysopt {
-    fn default() -> Self {
-        Sysopt {
+impl Sysopt {
+    pub fn global() -> &'static Sysopt {
+        static SYSOPT: OnceCell<Sysopt> = OnceCell::new();
+        SYSOPT.get_or_init(|| Sysopt {
             update_sysproxy: Arc::new(TokioMutex::new(false)),
             reset_sysproxy: Arc::new(TokioMutex::new(false)),
-        }
+            guard_state: Arc::new(false.into()),
+        })
     }
-}
 
-// Use simplified singleton_lazy macro
-singleton_lazy!(Sysopt, SYSOPT, Sysopt::default);
-
-impl Sysopt {
     pub fn init_guard_sysproxy(&self) -> Result<()> {
-        // 使用事件驱动代理管理器
-        let proxy_manager = EventDrivenProxyManager::global();
-        proxy_manager.notify_app_started();
-
-        log::info!(target: "app", "已启用事件驱动代理守卫");
+        self.guard_proxy();
         Ok(())
     }
 
@@ -77,18 +72,15 @@ impl Sysopt {
     pub async fn update_sysproxy(&self) -> Result<()> {
         let _lock = self.update_sysproxy.lock().await;
 
-        let port = {
-            let verge_port = Config::verge().await.latest_ref().verge_mixed_port;
-            match verge_port {
-                Some(port) => port,
-                None => Config::clash().await.latest_ref().get_mixed_port(),
-            }
-        };
+        let port = Config::verge()
+            .latest()
+            .verge_mixed_port
+            .unwrap_or(Config::clash().data().get_mixed_port());
         let pac_port = IVerge::get_singleton_port();
 
         let (sys_enable, pac_enable, proxy_host) = {
-            let verge = Config::verge().await;
-            let verge = verge.latest_ref();
+            let verge = Config::verge();
+            let verge = verge.latest();
             (
                 verge.enable_system_proxy.unwrap_or(false),
                 verge.proxy_auto_config.unwrap_or(false),
@@ -105,18 +97,16 @@ impl Sysopt {
                 enable: false,
                 host: proxy_host.clone(),
                 port,
-                bypass: get_bypass().await,
+                bypass: get_bypass(),
             };
             let mut auto = Autoproxy {
                 enable: false,
-                url: format!("http://{proxy_host}:{pac_port}/commands/pac"),
+                url: format!("http://{}:{}/commands/pac", proxy_host, pac_port),
             };
 
             if !sys_enable {
                 sys.set_system_proxy()?;
                 auto.set_auto_proxy()?;
-                let proxy_manager = EventDrivenProxyManager::global();
-                proxy_manager.notify_config_changed();
                 return Ok(());
             }
 
@@ -125,8 +115,6 @@ impl Sysopt {
                 auto.enable = true;
                 sys.set_system_proxy()?;
                 auto.set_auto_proxy()?;
-                let proxy_manager = EventDrivenProxyManager::global();
-                proxy_manager.notify_config_changed();
                 return Ok(());
             }
 
@@ -135,26 +123,19 @@ impl Sysopt {
                 sys.enable = true;
                 auto.set_auto_proxy()?;
                 sys.set_system_proxy()?;
-                let proxy_manager = EventDrivenProxyManager::global();
-                proxy_manager.notify_config_changed();
                 return Ok(());
             }
         }
         #[cfg(target_os = "windows")]
         {
             if !sys_enable {
-                let result = self.reset_sysproxy().await;
-                let proxy_manager = EventDrivenProxyManager::global();
-                proxy_manager.notify_config_changed();
-                return result;
+                return self.reset_sysproxy().await;
             }
             use crate::{core::handle::Handle, utils::dirs};
             use anyhow::bail;
             use tauri_plugin_shell::ShellExt;
 
-            let app_handle = Handle::global()
-                .app_handle()
-                .ok_or_else(|| anyhow::anyhow!("App handle not available"))?;
+            let app_handle = Handle::global().app_handle().unwrap();
 
             let binary_path = dirs::service_path()?;
             let sysproxy_exe = binary_path.with_file_name("sysproxy.exe");
@@ -164,36 +145,30 @@ impl Sysopt {
 
             let shell = app_handle.shell();
             let output = if pac_enable {
-                let address = format!("http://{proxy_host}:{pac_port}/commands/pac");
-                let sysproxy_str = sysproxy_exe
-                    .as_path()
-                    .to_str()
-                    .ok_or_else(|| anyhow::anyhow!("Invalid sysproxy.exe path"))?;
-                shell
-                    .command(sysproxy_str)
+                let address = format!("http://{}:{}/commands/pac", proxy_host, pac_port);
+                let output = shell
+                    .command(sysproxy_exe.as_path().to_str().unwrap())
                     .args(["pac", address.as_str()])
                     .output()
-                    .await?
+                    .await
+                    .unwrap();
+                output
             } else {
-                let address = format!("{proxy_host}:{port}");
-                let bypass = get_bypass().await;
-                let sysproxy_str = sysproxy_exe
-                    .as_path()
-                    .to_str()
-                    .ok_or_else(|| anyhow::anyhow!("Invalid sysproxy.exe path"))?;
-                shell
-                    .command(sysproxy_str)
+                let address = format!("{}:{}", proxy_host, port);
+                let bypass = get_bypass();
+                let output = shell
+                    .command(sysproxy_exe.as_path().to_str().unwrap())
                     .args(["global", address.as_str(), bypass.as_ref()])
                     .output()
-                    .await?
+                    .await
+                    .unwrap();
+                output
             };
 
             if !output.status.success() {
                 bail!("sysproxy exe run failed");
             }
         }
-        let proxy_manager = EventDrivenProxyManager::global();
-        proxy_manager.notify_config_changed();
 
         Ok(())
     }
@@ -205,16 +180,7 @@ impl Sysopt {
         #[cfg(not(target_os = "windows"))]
         {
             let mut sysproxy: Sysproxy = Sysproxy::get_system_proxy()?;
-            let mut autoproxy = match Autoproxy::get_auto_proxy() {
-                Ok(ap) => ap,
-                Err(e) => {
-                    log::warn!(target: "app", "重置代理时获取自动代理配置失败: {e}, 使用默认配置");
-                    Autoproxy {
-                        enable: false,
-                        url: "".to_string(),
-                    }
-                }
-            };
+            let mut autoproxy = Autoproxy::get_auto_proxy()?;
             sysproxy.enable = false;
             autoproxy.enable = false;
             autoproxy.set_auto_proxy()?;
@@ -227,9 +193,7 @@ impl Sysopt {
             use anyhow::bail;
             use tauri_plugin_shell::ShellExt;
 
-            let app_handle = Handle::global()
-                .app_handle()
-                .ok_or_else(|| anyhow::anyhow!("App handle not available"))?;
+            let app_handle = Handle::global().app_handle().unwrap();
 
             let binary_path = dirs::service_path()?;
             let sysproxy_exe = binary_path.with_file_name("sysproxy.exe");
@@ -239,15 +203,12 @@ impl Sysopt {
             }
 
             let shell = app_handle.shell();
-            let sysproxy_str = sysproxy_exe
-                .as_path()
-                .to_str()
-                .ok_or_else(|| anyhow::anyhow!("Invalid sysproxy.exe path"))?;
             let output = shell
-                .command(sysproxy_str)
+                .command(sysproxy_exe.as_path().to_str().unwrap())
                 .args(["set", "1"])
                 .output()
-                .await?;
+                .await
+                .unwrap();
 
             if !output.status.success() {
                 bail!("sysproxy exe run failed");
@@ -258,8 +219,8 @@ impl Sysopt {
     }
 
     /// update the startup
-    pub async fn update_launch(&self) -> Result<()> {
-        let enable_auto_launch = { Config::verge().await.latest_ref().enable_auto_launch };
+    pub fn update_launch(&self) -> Result<()> {
+        let enable_auto_launch = { Config::verge().latest().enable_auto_launch };
         let is_enable = enable_auto_launch.unwrap_or(false);
         logging!(info, true, "Setting auto-launch state to: {:?}", is_enable);
 
@@ -268,17 +229,19 @@ impl Sysopt {
         {
             if is_enable {
                 if let Err(e) = startup_shortcut::create_shortcut() {
-                    log::error!(target: "app", "创建启动快捷方式失败: {e}");
+                    log::error!(target: "app", "创建启动快捷方式失败: {}", e);
                     // 如果快捷方式创建失败，回退到原来的方法
                     self.try_original_autostart_method(is_enable);
                 } else {
                     return Ok(());
                 }
-            } else if let Err(e) = startup_shortcut::remove_shortcut() {
-                log::error!(target: "app", "删除启动快捷方式失败: {e}");
-                self.try_original_autostart_method(is_enable);
             } else {
-                return Ok(());
+                if let Err(e) = startup_shortcut::remove_shortcut() {
+                    log::error!(target: "app", "删除启动快捷方式失败: {}", e);
+                    self.try_original_autostart_method(is_enable);
+                } else {
+                    return Ok(());
+                }
             }
         }
 
@@ -293,10 +256,7 @@ impl Sysopt {
 
     /// 尝试使用原来的自启动方法
     fn try_original_autostart_method(&self, is_enable: bool) {
-        let Some(app_handle) = Handle::global().app_handle() else {
-            log::error!(target: "app", "App handle not available for autostart");
-            return;
-        };
+        let app_handle = Handle::global().app_handle().unwrap();
         let autostart_manager = app_handle.autolaunch();
 
         if is_enable {
@@ -313,30 +273,191 @@ impl Sysopt {
         {
             match startup_shortcut::is_shortcut_enabled() {
                 Ok(enabled) => {
-                    log::info!(target: "app", "快捷方式自启动状态: {enabled}");
+                    log::info!(target: "app", "快捷方式自启动状态: {}", enabled);
                     return Ok(enabled);
                 }
                 Err(e) => {
-                    log::error!(target: "app", "检查快捷方式失败，尝试原来的方法: {e}");
+                    log::error!(target: "app", "检查快捷方式失败，尝试原来的方法: {}", e);
                 }
             }
         }
 
         // 回退到原来的方法
-        let app_handle = Handle::global()
-            .app_handle()
-            .ok_or_else(|| anyhow::anyhow!("App handle not available"))?;
+        let app_handle = Handle::global().app_handle().unwrap();
         let autostart_manager = app_handle.autolaunch();
 
         match autostart_manager.is_enabled() {
             Ok(status) => {
-                log::info!(target: "app", "Auto launch status: {status}");
+                log::info!(target: "app", "Auto launch status: {}", status);
                 Ok(status)
             }
             Err(e) => {
-                log::error!(target: "app", "Failed to get auto launch status: {e}");
+                log::error!(target: "app", "Failed to get auto launch status: {}", e);
                 Err(anyhow::anyhow!("Failed to get auto launch status: {}", e))
             }
         }
     }
+
+    fn guard_proxy(&self) {
+        let _lock = self.guard_state.lock();
+
+        AsyncHandler::spawn(move || async move {
+            // default duration is 10s
+            let mut wait_secs = 10u64;
+
+            loop {
+                sleep(Duration::from_secs(wait_secs)).await;
+
+                let (enable, guard, guard_duration, pac, proxy_host) = {
+                    let verge = Config::verge();
+                    let verge = verge.latest();
+                    (
+                        verge.enable_system_proxy.unwrap_or(false),
+                        verge.enable_proxy_guard.unwrap_or(false),
+                        verge.proxy_guard_duration.unwrap_or(10),
+                        verge.proxy_auto_config.unwrap_or(false),
+                        verge
+                            .proxy_host
+                            .clone()
+                            .unwrap_or_else(|| String::from("127.0.0.1")),
+                    )
+                };
+
+                // stop loop
+                if !enable || !guard {
+                    continue;
+                }
+
+                // update duration
+                wait_secs = guard_duration;
+
+                log::debug!(target: "app", "try to guard the system proxy");
+
+                // 获取期望的代理端口
+                let port = Config::verge()
+                    .latest()
+                    .verge_mixed_port
+                    .unwrap_or(Config::clash().data().get_mixed_port());
+                let pac_port = IVerge::get_singleton_port();
+                let bypass = get_bypass();
+
+                // 检查系统代理配置
+                if pac {
+                    // 检查 PAC 代理设置
+                    let expected_url = format!("http://{}:{}/commands/pac", proxy_host, pac_port);
+                    let autoproxy = match Autoproxy::get_auto_proxy() {
+                        Ok(ap) => ap,
+                        Err(e) => {
+                            log::error!(target: "app", "failed to get the auto proxy: {}", e);
+                            continue;
+                        }
+                    };
+
+                    // 检查自动代理是否启用且URL是否正确
+                    if !autoproxy.enable || autoproxy.url != expected_url {
+                        log::info!(target: "app", "auto proxy settings changed, restoring...");
+                        #[cfg(not(target_os = "windows"))]
+                        {
+                            let new_autoproxy = Autoproxy {
+                                enable: true,
+                                url: expected_url,
+                            };
+                            logging_error!(Type::System, true, new_autoproxy.set_auto_proxy());
+                        }
+
+                        #[cfg(target_os = "windows")]
+                        {
+                            use crate::{core::handle::Handle, utils::dirs};
+                            use tauri_plugin_shell::ShellExt;
+
+                            let app_handle = Handle::global().app_handle().unwrap();
+                            let binary_path = match dirs::service_path() {
+                                Ok(path) => path,
+                                Err(e) => {
+                                    log::error!(target: "app", "failed to get service path: {}", e);
+                                    continue;
+                                }
+                            };
+
+                            let sysproxy_exe = binary_path.with_file_name("sysproxy.exe");
+                            if !sysproxy_exe.exists() {
+                                log::error!(target: "app", "sysproxy.exe not found");
+                                continue;
+                            }
+
+                            let shell = app_handle.shell();
+                            let output = shell
+                                .command(sysproxy_exe.as_path().to_str().unwrap())
+                                .args(["pac", expected_url.as_str()])
+                                .output()
+                                .await
+                                .unwrap();
+
+                            if !output.status.success() {
+                                log::error!(target: "app", "failed to set auto proxy");
+                            }
+                        }
+                    }
+                } else {
+                    // 检查常规系统代理设置
+                    let sysproxy = match Sysproxy::get_system_proxy() {
+                        Ok(sp) => sp,
+                        Err(e) => {
+                            log::error!(target: "app", "failed to get the system proxy: {}", e);
+                            continue;
+                        }
+                    };
+
+                    // 检查系统代理是否启用且配置是否匹配
+                    if !sysproxy.enable || sysproxy.host != proxy_host || sysproxy.port != port {
+                        log::info!(target: "app", "system proxy settings changed, restoring...");
+                        #[cfg(not(target_os = "windows"))]
+                        {
+                            let new_sysproxy = Sysproxy {
+                                enable: true,
+                                host: proxy_host.clone(),
+                                port,
+                                bypass: bypass.clone(),
+                            };
+                            logging_error!(Type::System, true, new_sysproxy.set_system_proxy());
+                        }
+
+                        #[cfg(target_os = "windows")]
+                        {
+                            use crate::{core::handle::Handle, utils::dirs};
+                            use tauri_plugin_shell::ShellExt;
+
+                            let app_handle = Handle::global().app_handle().unwrap();
+                            let binary_path = match dirs::service_path() {
+                                Ok(path) => path,
+                                Err(e) => {
+                                    log::error!(target: "app", "failed to get service path: {}", e);
+                                    continue;
+                                }
+                            };
+
+                            let sysproxy_exe = binary_path.with_file_name("sysproxy.exe");
+                            if !sysproxy_exe.exists() {
+                                log::error!(target: "app", "sysproxy.exe not found");
+                                continue;
+                            }
+
+                            let address = format!("{}:{}", proxy_host, port);
+                            let shell = app_handle.shell();
+                            let output = shell
+                                .command(sysproxy_exe.as_path().to_str().unwrap())
+                                .args(["global", address.as_str(), bypass.as_ref()])
+                                .output()
+                                .await
+                                .unwrap();
+
+                            if !output.status.success() {
+                                log::error!(target: "app", "failed to set system proxy");
+                            }
+                        }
+                    }
+                }
+            }
+        });
+    }
 }

src-tauri/src/core/timer.rs

@@ -1,15 +1,9 @@
-use crate::{config::Config, feat, logging, logging_error, singleton, utils::logging::Type};
+use crate::{config::Config, feat, logging, logging_error, utils::logging::Type};
 use anyhow::{Context, Result};
 use delay_timer::prelude::{DelayTimer, DelayTimerBuilder, TaskBuilder};
-use parking_lot::RwLock;
-use std::{
-    collections::HashMap,
-    pin::Pin,
-    sync::{
-        Arc,
-        atomic::{AtomicBool, AtomicU64, Ordering},
-    },
-};
+use once_cell::sync::OnceCell;
+use parking_lot::{Mutex, RwLock};
+use std::{collections::HashMap, sync::Arc};
 
 type TaskID = u64;
 
@@ -28,91 +22,94 @@ pub struct Timer {
     /// save the current state - using RwLock for better read concurrency
     pub timer_map: Arc<RwLock<HashMap<String, TimerTask>>>,
 
-    /// increment id - atomic counter for better performance
-    pub timer_count: AtomicU64,
+    /// increment id - kept as mutex since it's just a counter
+    pub timer_count: Arc<Mutex<TaskID>>,
 
     /// Flag to mark if timer is initialized - atomic for better performance
-    pub initialized: AtomicBool,
+    pub initialized: Arc<std::sync::atomic::AtomicBool>,
 }
 
-// Use singleton macro
-singleton!(Timer, TIMER_INSTANCE);
-
 impl Timer {
-    fn new() -> Self {
-        Timer {
+    pub fn global() -> &'static Timer {
+        static TIMER: OnceCell<Timer> = OnceCell::new();
+
+        TIMER.get_or_init(|| Timer {
             delay_timer: Arc::new(RwLock::new(DelayTimerBuilder::default().build())),
             timer_map: Arc::new(RwLock::new(HashMap::new())),
-            timer_count: AtomicU64::new(1),
-            initialized: AtomicBool::new(false),
-        }
+            timer_count: Arc::new(Mutex::new(1)),
+            initialized: Arc::new(std::sync::atomic::AtomicBool::new(false)),
+        })
     }
 
     /// Initialize timer with better error handling and atomic operations
-    pub async fn init(&self) -> Result<()> {
+    pub fn init(&self) -> Result<()> {
         // Use compare_exchange for thread-safe initialization check
         if self
             .initialized
-            .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
+            .compare_exchange(
+                false,
+                true,
+                std::sync::atomic::Ordering::SeqCst,
+                std::sync::atomic::Ordering::SeqCst,
+            )
             .is_err()
         {
             logging!(debug, Type::Timer, "Timer already initialized, skipping...");
             return Ok(());
         }
 
+        logging!(info, Type::Timer, true, "Initializing timer...");
+
         // Initialize timer tasks
-        if let Err(e) = self.refresh().await {
+        if let Err(e) = self.refresh() {
             // Reset initialization flag on error
-            self.initialized.store(false, Ordering::SeqCst);
+            self.initialized
+                .store(false, std::sync::atomic::Ordering::SeqCst);
             logging_error!(Type::Timer, false, "Failed to initialize timer: {}", e);
             return Err(e);
         }
 
-        // Log timer info first
-        {
-            let timer_map = self.timer_map.read();
+        let timer_map = self.timer_map.read();
+        logging!(
+            info,
+            Type::Timer,
+            "已注册的定时任务数量: {}",
+            timer_map.len()
+        );
+
+        for (uid, task) in timer_map.iter() {
             logging!(
                 info,
                 Type::Timer,
-                "已注册的定时任务数量: {}",
-                timer_map.len()
+                "注册了定时任务 - uid={}, interval={}min, task_id={}",
+                uid,
+                task.interval_minutes,
+                task.task_id
             );
-
-            for (uid, task) in timer_map.iter() {
-                logging!(
-                    info,
-                    Type::Timer,
-                    "注册了定时任务 - uid={}, interval={}min, task_id={}",
-                    uid,
-                    task.interval_minutes,
-                    task.task_id
-                );
-            }
         }
 
         let cur_timestamp = chrono::Local::now().timestamp();
 
         // Collect profiles that need immediate update
-        let profiles_to_update =
-            if let Some(items) = Config::profiles().await.latest_ref().get_items() {
-                items
-                    .iter()
-                    .filter_map(|item| {
-                        let interval = item.option.as_ref()?.update_interval? as i64;
-                        let updated = item.updated? as i64;
-                        let uid = item.uid.as_ref()?;
+        let profiles_to_update = if let Some(items) = Config::profiles().latest().get_items() {
+            items
+                .iter()
+                .filter_map(|item| {
+                    let interval = item.option.as_ref()?.update_interval? as i64;
+                    let updated = item.updated? as i64;
+                    let uid = item.uid.as_ref()?;
 
-                        if interval > 0 && cur_timestamp - updated >= interval * 60 {
-                            logging!(info, Type::Timer, "需要立即更新的配置: uid={}", uid);
-                            Some(uid.clone())
-                        } else {
-                            None
-                        }
-                    })
-                    .collect::<Vec<String>>()
-            } else {
-                Vec::new()
-            };
+                    if interval > 0 && cur_timestamp - updated >= interval * 60 {
+                        logging!(info, Type::Timer, "需要立即更新的配置: uid={}", uid);
+                        Some(uid.clone())
+                    } else {
+                        None
+                    }
+                })
+                .collect::<Vec<String>>()
+        } else {
+            Vec::new()
+        };
 
         // Advance tasks outside of locks to minimize lock contention
         if !profiles_to_update.is_empty() {
@@ -140,9 +137,9 @@ impl Timer {
     }
 
     /// Refresh timer tasks with better error handling
-    pub async fn refresh(&self) -> Result<()> {
+    pub fn refresh(&self) -> Result<()> {
         // Generate diff outside of lock to minimize lock contention
-        let diff_map = self.gen_diff().await;
+        let diff_map = self.gen_diff();
 
         if diff_map.is_empty() {
             logging!(debug, Type::Timer, "No timer changes needed");
@@ -156,80 +153,72 @@ impl Timer {
             diff_map.len()
         );
 
-        // Apply changes - first collect operations to perform without holding locks
-        let mut operations_to_add: Vec<(String, TaskID, u64)> = Vec::new();
-        let _operations_to_remove: Vec<String> = Vec::new();
+        // Apply changes while holding locks
+        let mut timer_map = self.timer_map.write();
+        let mut delay_timer = self.delay_timer.write();
 
-        // 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) {
-                            logging!(
-                                warn,
-                                Type::Timer,
-                                "Failed to remove task {} for uid {}: {}",
-                                tid,
-                                uid,
-                                e
-                            );
-                        } else {
-                            logging!(debug, Type::Timer, "Removed task {} for uid {}", tid, uid);
-                        }
-                    }
-                    DiffFlag::Add(tid, interval) => {
-                        let task = TimerTask {
-                            task_id: tid,
-                            interval_minutes: interval,
-                            last_run: chrono::Local::now().timestamp(),
-                        };
-
-                        timer_map.insert(uid.clone(), task);
-                        operations_to_add.push((uid, tid, interval));
-                    }
-                    DiffFlag::Mod(tid, interval) => {
-                        // Remove old task first
-                        if let Err(e) = delay_timer.remove_task(tid) {
-                            logging!(
-                                warn,
-                                Type::Timer,
-                                "Failed to remove old task {} for uid {}: {}",
-                                tid,
-                                uid,
-                                e
-                            );
-                        }
-
-                        // Then add the new one
-                        let task = TimerTask {
-                            task_id: tid,
-                            interval_minutes: interval,
-                            last_run: chrono::Local::now().timestamp(),
-                        };
-
-                        timer_map.insert(uid.clone(), task);
-                        operations_to_add.push((uid, tid, interval));
+        for (uid, diff) in diff_map {
+            match diff {
+                DiffFlag::Del(tid) => {
+                    timer_map.remove(&uid);
+                    if let Err(e) = delay_timer.remove_task(tid) {
+                        logging!(
+                            warn,
+                            Type::Timer,
+                            "Failed to remove task {} for uid {}: {}",
+                            tid,
+                            uid,
+                            e
+                        );
+                    } else {
+                        logging!(debug, Type::Timer, "Removed task {} for uid {}", tid, uid);
                     }
                 }
-            }
-        } // Locks are dropped here
+                DiffFlag::Add(tid, interval) => {
+                    let task = TimerTask {
+                        task_id: tid,
+                        interval_minutes: interval,
+                        last_run: chrono::Local::now().timestamp(),
+                    };
 
-        // 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) {
-                logging_error!(Type::Timer, "Failed to add task for uid {}: {}", uid, e);
+                    timer_map.insert(uid.clone(), task);
 
-                // Rollback on failure - remove from timer_map
-                self.timer_map.write().remove(&uid);
-            } else {
-                logging!(debug, Type::Timer, "Added task {} for uid {}", tid, uid);
+                    if let Err(e) = self.add_task(&mut delay_timer, uid.clone(), tid, interval) {
+                        logging_error!(Type::Timer, "Failed to add task for uid {}: {}", uid, e);
+                        timer_map.remove(&uid); // Rollback on failure
+                    } else {
+                        logging!(debug, Type::Timer, "Added task {} for uid {}", tid, uid);
+                    }
+                }
+                DiffFlag::Mod(tid, interval) => {
+                    // Remove old task first
+                    if let Err(e) = delay_timer.remove_task(tid) {
+                        logging!(
+                            warn,
+                            Type::Timer,
+                            "Failed to remove old task {} for uid {}: {}",
+                            tid,
+                            uid,
+                            e
+                        );
+                    }
+
+                    // Then add the new one
+                    let task = TimerTask {
+                        task_id: tid,
+                        interval_minutes: interval,
+                        last_run: chrono::Local::now().timestamp(),
+                    };
+
+                    timer_map.insert(uid.clone(), task);
+
+                    if let Err(e) = self.add_task(&mut delay_timer, uid.clone(), tid, interval) {
+                        logging_error!(Type::Timer, "Failed to update task for uid {}: {}", uid, e);
+                        timer_map.remove(&uid); // Rollback on failure
+                    } else {
+                        logging!(debug, Type::Timer, "Updated task {} for uid {}", tid, uid);
+                    }
+                }
             }
         }
 
@@ -237,23 +226,24 @@ impl Timer {
     }
 
     /// Generate map of profile UIDs to update intervals
-    async fn gen_map(&self) -> HashMap<String, u64> {
+    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().latest().get_items() {
             for item in items.iter() {
-                if let Some(option) = item.option.as_ref()
-                    && let (Some(interval), Some(uid)) = (option.update_interval, &item.uid)
-                    && interval > 0
-                {
-                    logging!(
-                        debug,
-                        Type::Timer,
-                        "找到定时更新配置: uid={}, interval={}min",
-                        uid,
-                        interval
-                    );
-                    new_map.insert(uid.clone(), interval);
+                if let Some(option) = item.option.as_ref() {
+                    if let (Some(interval), Some(uid)) = (option.update_interval, &item.uid) {
+                        if interval > 0 {
+                            logging!(
+                                debug,
+                                Type::Timer,
+                                "找到定时更新配置: uid={}, interval={}min",
+                                uid,
+                                interval
+                            );
+                            new_map.insert(uid.clone(), interval);
+                        }
+                    }
                 }
             }
         }
@@ -268,9 +258,9 @@ impl Timer {
     }
 
     /// Generate differences between current and new timer configuration
-    async fn gen_diff(&self) -> HashMap<String, DiffFlag> {
+    fn gen_diff(&self) -> HashMap<String, DiffFlag> {
         let mut diff_map = HashMap::new();
-        let new_map = self.gen_map().await;
+        let new_map = self.gen_map();
 
         // Read lock for comparing current state
         let timer_map = self.timer_map.read();
@@ -309,8 +299,7 @@ impl Timer {
         }
 
         // Find new tasks to add
-        let mut next_id = self.timer_count.load(Ordering::Relaxed);
-        let original_id = next_id;
+        let mut next_id = *self.timer_count.lock();
 
         for (uid, &interval) in new_map.iter() {
             if !timer_map.contains_key(uid) {
@@ -327,8 +316,8 @@ impl Timer {
         }
 
         // Update counter only if we added new tasks
-        if next_id > original_id {
-            self.timer_count.store(next_id, Ordering::Relaxed);
+        if next_id > *self.timer_count.lock() {
+            *self.timer_count.lock() = next_id;
         }
 
         logging!(debug, Type::Timer, "定时任务变更数量: {}", diff_map.len());
@@ -359,9 +348,9 @@ impl Timer {
             .set_frequency_repeated_by_minutes(minutes)
             .spawn_async_routine(move || {
                 let uid = uid.clone();
-                Box::pin(async move {
+                async move {
                     Self::async_task(uid).await;
-                }) as Pin<Box<dyn std::future::Future<Output = ()> + Send>>
+                }
             })
             .context("failed to create timer task")?;
 
@@ -373,24 +362,21 @@ impl Timer {
     }
 
     /// Get next update time for a profile
-    pub async fn get_next_update_time(&self, uid: &str) -> Option<i64> {
+    pub fn get_next_update_time(&self, uid: &str) -> Option<i64> {
         logging!(info, Type::Timer, "获取下次更新时间，uid={}", uid);
 
-        // First extract timer task data without holding the lock across await
-        let task_interval = {
-            let timer_map = self.timer_map.read();
-            match timer_map.get(uid) {
-                Some(t) => t.interval_minutes,
-                None => {
-                    logging!(warn, Type::Timer, "找不到对应的定时任务，uid={}", uid);
-                    return None;
-                }
+        let timer_map = self.timer_map.read();
+        let task = match timer_map.get(uid) {
+            Some(t) => t,
+            None => {
+                logging!(warn, Type::Timer, "找不到对应的定时任务，uid={}", uid);
+                return None;
             }
         };
 
-        // Get the profile updated timestamp - now safe to await
-        let config_profiles = Config::profiles().await;
-        let profiles = config_profiles.data_ref().clone();
+        // Get the profile updated timestamp
+        let profiles_config = Config::profiles();
+        let profiles = profiles_config.latest();
         let items = match profiles.get_items() {
             Some(i) => i,
             None => {
@@ -410,8 +396,8 @@ impl Timer {
         let updated = profile.updated.unwrap_or(0) as i64;
 
         // Calculate next update time
-        if updated > 0 && task_interval > 0 {
-            let next_time = updated + (task_interval as i64 * 60);
+        if updated > 0 && task.interval_minutes > 0 {
+            let next_time = updated + (task.interval_minutes as i64 * 60);
             logging!(
                 info,
                 Type::Timer,
@@ -426,7 +412,7 @@ impl Timer {
                 Type::Timer,
                 "更新时间或间隔无效，updated={}, interval={}",
                 updated,
-                task_interval
+                task.interval_minutes
             );
             None
         }
@@ -434,6 +420,7 @@ impl Timer {
 
     /// Emit update events for frontend notification
     fn emit_update_event(_uid: &str, _is_start: bool) {
+        #[cfg(any(feature = "verge-dev", feature = "default"))]
         {
             if _is_start {
                 super::handle::Handle::notify_profile_update_started(_uid.to_string());
@@ -451,7 +438,7 @@ impl Timer {
         match tokio::time::timeout(std::time::Duration::from_secs(40), async {
             Self::emit_update_event(&uid, true);
 
-            let is_current = Config::profiles().await.latest_ref().current.as_ref() == Some(&uid);
+            let is_current = Config::profiles().latest().current.as_ref() == Some(&uid);
             logging!(
                 info,
                 Type::Timer,

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

@@ -1 +1,336 @@
+use crate::{
+    module::mihomo::{MihomoManager, Rate},
+    utils::help::format_bytes_speed,
+};
+use ab_glyph::FontArc;
+use anyhow::Result;
+use futures::Stream;
+use image::{GenericImageView, Rgba, RgbaImage};
+use imageproc::drawing::draw_text_mut;
+use parking_lot::Mutex;
+use std::{io::Cursor, sync::Arc};
+use tokio_tungstenite::tungstenite::http;
+use tungstenite::client::IntoClientRequest;
+#[derive(Debug, Clone)]
+pub struct SpeedRate {
+    rate: Arc<Mutex<(Rate, Rate)>>,
+    last_update: Arc<Mutex<std::time::Instant>>,
+}
 
+impl SpeedRate {
+    pub fn new() -> Self {
+        Self {
+            rate: Arc::new(Mutex::new((Rate::default(), Rate::default()))),
+            last_update: Arc::new(Mutex::new(std::time::Instant::now())),
+        }
+    }
+
+    pub fn update_and_check_changed(&self, up: u64, down: u64) -> Option<Rate> {
+        let mut rates = self.rate.lock();
+        let mut last_update = self.last_update.lock();
+        let now = std::time::Instant::now();
+
+        // 限制更新频率为每秒最多2次（500ms）
+        if now.duration_since(*last_update).as_millis() < 500 {
+            return None;
+        }
+
+        let (current, previous) = &mut *rates;
+
+        // Avoid unnecessary float conversions for small value checks
+        let should_update = if current.up < 1000 && down < 1000 {
+            // For small values, always update to ensure accuracy
+            current.up != up || current.down != down
+        } else {
+            // For larger values, use integer math to check for >5% change
+            // Multiply by 20 instead of dividing by 0.05 to avoid floating point
+            let up_threshold = current.up / 20;
+            let down_threshold = current.down / 20;
+
+            (up > current.up && up - current.up > up_threshold)
+                || (up < current.up && current.up - up > up_threshold)
+                || (down > current.down && down - current.down > down_threshold)
+                || (down < current.down && current.down - down > down_threshold)
+        };
+
+        if !should_update {
+            return None;
+        }
+
+        *previous = current.clone();
+        current.up = up;
+        current.down = down;
+        *last_update = now;
+
+        if previous != current {
+            Some(current.clone())
+        } else {
+            None
+        }
+    }
+
+    pub fn get_curent_rate(&self) -> Option<Rate> {
+        let rates = self.rate.lock();
+        let (current, _) = &*rates;
+        Some(current.clone())
+    }
+
+    // 分离图标加载和速率渲染
+    pub fn add_speed_text(
+        is_custom_icon: bool,
+        icon_bytes: Option<Vec<u8>>,
+        rate: Option<&Rate>,
+    ) -> Result<Vec<u8>> {
+        let rate = rate.unwrap_or(&Rate { up: 0, down: 0 });
+
+        let (mut icon_width, mut icon_height) = (0, 256);
+        let icon_image = if let Some(bytes) = icon_bytes.clone() {
+            let icon_image = image::load_from_memory(&bytes)?;
+            icon_width = icon_image.width();
+            icon_height = icon_image.height();
+            icon_image
+        } else {
+            // 返回一个空的 RGBA 图像
+            image::DynamicImage::new_rgba8(0, 0)
+        };
+
+        let total_width = match (is_custom_icon, icon_bytes.is_some()) {
+            (true, true) => 510,
+            (true, false) => 740,
+            (false, false) => 740,
+            (false, true) => icon_width + 740,
+        };
+
+        // println!(
+        //     "icon_height: {}, icon_wight: {}, total_width: {}",
+        //     icon_height, icon_width, total_width
+        // );
+
+        // 创建新的透明画布
+        let mut combined_image = RgbaImage::new(total_width, icon_height);
+
+        // 将原始图标绘制到新画布的左侧
+        if icon_bytes.is_some() {
+            for y in 0..icon_height {
+                for x in 0..icon_width {
+                    let pixel = icon_image.get_pixel(x, y);
+                    combined_image.put_pixel(x, y, pixel);
+                }
+            }
+        }
+
+        let is_colorful = if let Some(bytes) = icon_bytes.clone() {
+            !crate::utils::help::is_monochrome_image_from_bytes(&bytes).unwrap_or(false)
+        } else {
+            false
+        };
+
+        // 选择文本颜色
+        let (text_color, shadow_color) = if is_colorful {
+            (
+                Rgba([144u8, 144u8, 144u8, 255u8]),
+                // Rgba([255u8, 255u8, 255u8, 128u8]),
+                Rgba([0u8, 0u8, 0u8, 128u8]),
+            )
+            // (
+            //     Rgba([160u8, 160u8, 160u8, 255u8]),
+            //     // Rgba([255u8, 255u8, 255u8, 128u8]),
+            //     Rgba([0u8, 0u8, 0u8, 255u8]),
+            // )
+        } else {
+            (
+                Rgba([255u8, 255u8, 255u8, 255u8]),
+                Rgba([0u8, 0u8, 0u8, 128u8]),
+            )
+        };
+        // 减小字体大小以适应文本区域
+        let font_data = include_bytes!("../../../assets/fonts/SF-Pro.ttf");
+        let font = FontArc::try_from_vec(font_data.to_vec()).unwrap();
+        let font_size = icon_height as f32 * 0.6; // 稍微减小字体
+        let scale = ab_glyph::PxScale::from(font_size);
+
+        // 使用更简洁的速率格式
+        let up_text = format!("↑ {}", format_bytes_speed(rate.up));
+        let down_text = format!("↓ {}", format_bytes_speed(rate.down));
+
+        // For test rate display
+        // let down_text = format!("↓ {}", format_bytes_speed(102 * 1020 * 1024));
+
+        // 计算文本位置，确保垂直间距合适
+        // 修改文本位置为居右显示
+        // 计算右对齐的文本位置
+        // let up_text_width = imageproc::drawing::text_size(scale, &font, &up_text).0 as u32;
+        // let down_text_width = imageproc::drawing::text_size(scale, &font, &down_text).0 as u32;
+        // let up_text_x = total_width - up_text_width;
+        // let down_text_x = total_width - down_text_width;
+
+        // 计算左对齐的文本位置
+        let (up_text_x, down_text_x) = {
+            if is_custom_icon || icon_bytes.is_some() {
+                let text_left_offset = 30;
+                let left_begin = icon_width + text_left_offset;
+                (left_begin, left_begin)
+            } else {
+                (icon_width, icon_width)
+            }
+        };
+
+        // 优化垂直位置，使速率显示的高度和上下间距正好等于图标大小
+        let text_height = font_size as i32;
+        let total_text_height = text_height * 2;
+        let up_y = (icon_height as i32 - total_text_height) / 2;
+        let down_y = up_y + text_height;
+
+        // 绘制速率文本（先阴影后文字）
+        let shadow_offset = 1;
+
+        // 绘制上行速率
+        draw_text_mut(
+            &mut combined_image,
+            shadow_color,
+            up_text_x as i32 + shadow_offset,
+            up_y + shadow_offset,
+            scale,
+            &font,
+            &up_text,
+        );
+        draw_text_mut(
+            &mut combined_image,
+            text_color,
+            up_text_x as i32,
+            up_y,
+            scale,
+            &font,
+            &up_text,
+        );
+
+        // 绘制下行速率
+        draw_text_mut(
+            &mut combined_image,
+            shadow_color,
+            down_text_x as i32 + shadow_offset,
+            down_y + shadow_offset,
+            scale,
+            &font,
+            &down_text,
+        );
+        draw_text_mut(
+            &mut combined_image,
+            text_color,
+            down_text_x as i32,
+            down_y,
+            scale,
+            &font,
+            &down_text,
+        );
+
+        // 将结果转换为 PNG 数据
+        let mut bytes = Vec::new();
+        combined_image.write_to(&mut Cursor::new(&mut bytes), image::ImageFormat::Png)?;
+        Ok(bytes)
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Traffic {
+    pub up: u64,
+    pub down: u64,
+}
+
+impl Traffic {
+    pub async fn get_traffic_stream() -> Result<impl Stream<Item = Result<Traffic, anyhow::Error>>>
+    {
+        use futures::{
+            future::FutureExt,
+            stream::{self, StreamExt},
+        };
+        use std::time::Duration;
+
+        // 先处理错误和超时情况
+        let stream = Box::pin(
+            stream::unfold((), move |_| async move {
+                'retry: loop {
+                    log::info!(target: "app", "establishing traffic websocket connection");
+                    let (url, token) = MihomoManager::get_traffic_ws_url();
+                    let mut request = match url.into_client_request() {
+                        Ok(req) => req,
+                        Err(e) => {
+                            log::error!(target: "app", "failed to create websocket request: {}", e);
+                            tokio::time::sleep(Duration::from_secs(2)).await;
+                            continue 'retry;
+                        }
+                    };
+
+                    request.headers_mut().insert(http::header::AUTHORIZATION, token);
+
+                    match tokio::time::timeout(Duration::from_secs(3),
+                        tokio_tungstenite::connect_async(request)
+                    ).await {
+                        Ok(Ok((ws_stream, _))) => {
+                            log::info!(target: "app", "traffic websocket connection established");
+                            // 设置流超时控制
+                            let traffic_stream = ws_stream
+                                .take_while(|msg| {
+                                    let continue_stream = msg.is_ok();
+                                    async move { continue_stream }.boxed()
+                                })
+                                .filter_map(|msg| async move {
+                                    match msg {
+                                        Ok(msg) => {
+                                            if !msg.is_text() {
+                                                return None;
+                                            }
+
+                                            match tokio::time::timeout(
+                                                Duration::from_millis(200),
+                                                async { msg.into_text() }
+                                            ).await {
+                                                Ok(Ok(text)) => {
+                                                    match serde_json::from_str::<serde_json::Value>(&text) {
+                                                        Ok(json) => {
+                                                            let up = json["up"].as_u64().unwrap_or(0);
+                                                            let down = json["down"].as_u64().unwrap_or(0);
+                                                            Some(Ok(Traffic { up, down }))
+                                                        },
+                                                        Err(e) => {
+                                                            log::warn!(target: "app", "traffic json parse error: {} for {}", e, text);
+                                                            None
+                                                        }
+                                                    }
+                                                },
+                                                Ok(Err(e)) => {
+                                                    log::warn!(target: "app", "traffic text conversion error: {}", e);
+                                                    None
+                                                },
+                                                Err(_) => {
+                                                    log::warn!(target: "app", "traffic text processing timeout");
+                                                    None
+                                                }
+                                            }
+                                        },
+                                        Err(e) => {
+                                            log::error!(target: "app", "traffic websocket error: {}", e);
+                                            None
+                                        }
+                                    }
+                                });
+
+                            return Some((traffic_stream, ()));
+                        },
+                        Ok(Err(e)) => {
+                            log::error!(target: "app", "traffic websocket connection failed: {}", e);
+                        },
+                        Err(_) => {
+                            log::error!(target: "app", "traffic websocket connection timed out");
+                        }
+                    }
+
+                    tokio::time::sleep(Duration::from_secs(2)).await;
+                }
+            })
+            .flatten(),
+        );
+
+        Ok(stream)
+    }
+}

src-tauri/src/core/win_uwp.rs

@@ -1,12 +1,12 @@
 #![cfg(target_os = "windows")]
 
 use crate::utils::dirs;
-use anyhow::{Result, bail};
+use anyhow::{bail, Result};
 use deelevate::{PrivilegeLevel, Token};
 use runas::Command as RunasCommand;
 use std::process::Command as StdCommand;
 
-pub fn invoke_uwptools() -> Result<()> {
+pub async fn invoke_uwptools() -> Result<()> {
     let resource_dir = dirs::app_resources_dir()?;
     let tool_path = resource_dir.join("enableLoopback.exe");
 

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

@@ -1,5 +1,3 @@
-// This function is exported for use by the Clash core
-// eslint-disable-next-line no-unused-vars
 function main(config, _name) {
   if (config.mode === "script") {
     config.mode = "rule";

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

@@ -1,5 +1,3 @@
-// This function is exported for use by the Clash core
-// eslint-disable-next-line no-unused-vars
 function main(config, _name) {
   if (Array.isArray(config.proxies)) {
     config.proxies.forEach((p, i) => {

src-tauri/src/enhance/chain.rs

@@ -3,7 +3,7 @@ use crate::{
     config::PrfItem,
     utils::{dirs, help},
 };
-use serde_yaml_ng::Mapping;
+use serde_yaml::Mapping;
 use std::fs;
 
 #[derive(Debug, Clone)]
@@ -22,7 +22,6 @@ pub enum ChainType {
 }
 
 #[derive(Debug, Clone)]
-#[allow(dead_code)]
 pub enum ChainSupport {
     Clash,
     ClashMeta,
@@ -30,49 +29,8 @@ pub enum ChainSupport {
     All,
 }
 
-// impl From<&PrfItem> for Option<ChainItem> {
-//     fn from(item: &PrfItem) -> Self {
-//         let itype = item.itype.as_ref()?.as_str();
-//         let file = item.file.clone()?;
-//         let uid = item.uid.clone().unwrap_or("".into());
-//         let path = dirs::app_profiles_dir().ok()?.join(file);
-
-//         if !path.exists() {
-//             return None;
-//         }
-
-//         match itype {
-//             "script" => Some(ChainItem {
-//                 uid,
-//                 data: ChainType::Script(fs::read_to_string(path).ok()?),
-//             }),
-//             "merge" => Some(ChainItem {
-//                 uid,
-//                 data: ChainType::Merge(help::read_mapping(&path).ok()?),
-//             }),
-//             "rules" => Some(ChainItem {
-//                 uid,
-//                 data: ChainType::Rules(help::read_seq_map(&path).ok()?),
-//             }),
-//             "proxies" => Some(ChainItem {
-//                 uid,
-//                 data: ChainType::Proxies(help::read_seq_map(&path).ok()?),
-//             }),
-//             "groups" => Some(ChainItem {
-//                 uid,
-//                 data: ChainType::Groups(help::read_seq_map(&path).ok()?),
-//             }),
-//             _ => None,
-//         }
-//     }
-// }
-// Helper trait to allow async conversion
-pub trait AsyncChainItemFrom {
-    async fn from_async(item: &PrfItem) -> Option<ChainItem>;
-}
-
-impl AsyncChainItemFrom for Option<ChainItem> {
-    async fn from_async(item: &PrfItem) -> Option<ChainItem> {
+impl From<&PrfItem> for Option<ChainItem> {
+    fn from(item: &PrfItem) -> Self {
         let itype = item.itype.as_ref()?.as_str();
         let file = item.file.clone()?;
         let uid = item.uid.clone().unwrap_or("".into());
@@ -89,33 +47,25 @@ impl AsyncChainItemFrom for Option<ChainItem> {
             }),
             "merge" => Some(ChainItem {
                 uid,
-                data: ChainType::Merge(help::read_mapping(&path).await.ok()?),
+                data: ChainType::Merge(help::read_mapping(&path).ok()?),
+            }),
+            "rules" => Some(ChainItem {
+                uid,
+                data: ChainType::Rules(help::read_seq_map(&path).ok()?),
+            }),
+            "proxies" => Some(ChainItem {
+                uid,
+                data: ChainType::Proxies(help::read_seq_map(&path).ok()?),
+            }),
+            "groups" => Some(ChainItem {
+                uid,
+                data: ChainType::Groups(help::read_seq_map(&path).ok()?),
             }),
-            "rules" => {
-                let seq_map = help::read_seq_map(&path).await.ok()?;
-                Some(ChainItem {
-                    uid,
-                    data: ChainType::Rules(seq_map),
-                })
-            }
-            "proxies" => {
-                let seq_map = help::read_seq_map(&path).await.ok()?;
-                Some(ChainItem {
-                    uid,
-                    data: ChainType::Proxies(seq_map),
-                })
-            }
-            "groups" => {
-                let seq_map = help::read_seq_map(&path).await.ok()?;
-                Some(ChainItem {
-                    uid,
-                    data: ChainType::Groups(seq_map),
-                })
-            }
             _ => None,
         }
     }
 }
+
 impl ChainItem {
     /// 内建支持一些脚本
     pub fn builtin() -> Vec<(ChainSupport, ChainItem)> {

src-tauri/src/enhance/field.rs

@@ -1,4 +1,4 @@
-use serde_yaml_ng::{Mapping, Value};
+use serde_yaml::{Mapping, Value};
 use std::collections::HashSet;
 
 pub const HANDLE_FIELDS: [&str; 12] = [

src-tauri/src/enhance/merge.rs

@@ -1,5 +1,5 @@
 use super::use_lowercase;
-use serde_yaml_ng::{self, Mapping, Value};
+use serde_yaml::{self, Mapping, Value};
 
 fn deep_merge(a: &mut Value, b: &Value) {
     match (a, b) {
@@ -18,10 +18,9 @@ pub fn use_merge(merge: Mapping, config: Mapping) -> Mapping {
 
     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");
-        Mapping::new()
-    })
+    let config = config.as_mapping().unwrap().clone();
+
+    config
 }
 
 #[test]
@@ -52,10 +51,10 @@ fn test_merge() -> anyhow::Result<()> {
     script1: test
   ";
 
-    let merge = serde_yaml_ng::from_str::<Mapping>(merge)?;
-    let config = serde_yaml_ng::from_str::<Mapping>(config)?;
+    let merge = serde_yaml::from_str::<Mapping>(merge)?;
+    let config = serde_yaml::from_str::<Mapping>(config)?;
 
-    let _ = serde_yaml_ng::to_string(&use_merge(merge, config))?;
+    let _ = serde_yaml::to_string(&use_merge(merge, config))?;
 
     Ok(())
 }

src-tauri/src/enhance/mod.rs

@@ -7,7 +7,7 @@ mod tun;
 
 use self::{chain::*, field::*, merge::*, script::*, seq::*, tun::*};
 use crate::{config::Config, utils::tmpl};
-use serde_yaml_ng::Mapping;
+use serde_yaml::Mapping;
 use std::collections::{HashMap, HashSet};
 
 type ResultLog = Vec<(String, String)>;
@@ -16,13 +16,13 @@ type ResultLog = Vec<(String, String)>;
 /// 返回最终订阅、该订阅包含的键、和script执行的结果
 pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
     // config.yaml 的订阅
-    let clash_config = { Config::clash().await.latest_ref().0.clone() };
+    let clash_config = { Config::clash().latest().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 = Config::verge();
+        let verge = verge.latest();
         (
-            Some(verge.get_valid_clash_core()),
+            verge.clash_core.clone(),
             verge.enable_tun_mode.unwrap_or(false),
             verge.enable_builtin_enhanced.unwrap_or(true),
             verge.verge_socks_enabled.unwrap_or(false),
@@ -32,18 +32,18 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
     };
     #[cfg(not(target_os = "windows"))]
     let redir_enabled = {
-        let verge = Config::verge().await;
-        let verge = verge.latest_ref();
+        let verge = Config::verge();
+        let verge = verge.latest();
         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 = Config::verge();
+        let verge = verge.latest();
         verge.verge_tproxy_enabled.unwrap_or(false)
     };
 
-    // 从profiles里拿东西 - 先收集需要的数据，然后释放锁
+    // 从profiles里拿东西
     let (
         mut config,
         merge_item,
@@ -55,172 +55,74 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
         global_script,
         profile_name,
     ) = {
-        // 收集所有需要的数据，然后释放profiles锁
-        let (
-            current,
-            merge_uid,
-            script_uid,
-            rules_uid,
-            proxies_uid,
-            groups_uid,
-            _current_profile_uid,
-            name,
-        ) = {
-            // 分离async调用和数据获取，避免借用检查问题
-            let current = {
-                let profiles = Config::profiles().await;
-                let profiles_clone = profiles.latest_ref().clone();
-                profiles_clone.current_mapping().await.unwrap_or_default()
-            };
+        let profiles = Config::profiles();
+        let profiles = profiles.latest();
 
-            // 重新获取锁进行其他操作
-            let profiles = Config::profiles().await;
-            let profiles_ref = profiles.latest_ref();
+        let current = profiles.current_mapping().unwrap_or_default();
+        let merge = profiles
+            .get_item(&profiles.current_merge().unwrap_or_default())
+            .ok()
+            .and_then(<Option<ChainItem>>::from)
+            .unwrap_or_else(|| ChainItem {
+                uid: "".into(),
+                data: ChainType::Merge(Mapping::new()),
+            });
+        let script = profiles
+            .get_item(&profiles.current_script().unwrap_or_default())
+            .ok()
+            .and_then(<Option<ChainItem>>::from)
+            .unwrap_or_else(|| ChainItem {
+                uid: "".into(),
+                data: ChainType::Script(tmpl::ITEM_SCRIPT.into()),
+            });
+        let rules = profiles
+            .get_item(&profiles.current_rules().unwrap_or_default())
+            .ok()
+            .and_then(<Option<ChainItem>>::from)
+            .unwrap_or_else(|| ChainItem {
+                uid: "".into(),
+                data: ChainType::Rules(SeqMap::default()),
+            });
+        let proxies = profiles
+            .get_item(&profiles.current_proxies().unwrap_or_default())
+            .ok()
+            .and_then(<Option<ChainItem>>::from)
+            .unwrap_or_else(|| ChainItem {
+                uid: "".into(),
+                data: ChainType::Proxies(SeqMap::default()),
+            });
+        let groups = profiles
+            .get_item(&profiles.current_groups().unwrap_or_default())
+            .ok()
+            .and_then(<Option<ChainItem>>::from)
+            .unwrap_or_else(|| ChainItem {
+                uid: "".into(),
+                data: ChainType::Groups(SeqMap::default()),
+            });
 
-            let 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 global_merge = profiles
+            .get_item(&"Merge".to_string())
+            .ok()
+            .and_then(<Option<ChainItem>>::from)
+            .unwrap_or_else(|| ChainItem {
+                uid: "Merge".into(),
+                data: ChainType::Merge(Mapping::new()),
+            });
 
-            let name = profiles_ref
-                .get_item(&current_profile_uid)
-                .ok()
-                .and_then(|item| item.name.clone())
-                .unwrap_or_default();
+        let global_script = profiles
+            .get_item(&"Script".to_string())
+            .ok()
+            .and_then(<Option<ChainItem>>::from)
+            .unwrap_or_else(|| ChainItem {
+                uid: "Script".into(),
+                data: ChainType::Script(tmpl::ITEM_SCRIPT.into()),
+            });
 
-            (
-                current,
-                merge_uid,
-                script_uid,
-                rules_uid,
-                proxies_uid,
-                groups_uid,
-                current_profile_uid,
-                name,
-            )
-        };
-
-        // 现在获取具体的items，此时profiles锁已经释放
-        let merge = {
-            let item = {
-                let profiles = Config::profiles().await;
-                let profiles = profiles.latest_ref();
-                profiles.get_item(&merge_uid).ok().cloned()
-            };
-            if let Some(item) = item {
-                <Option<ChainItem>>::from_async(&item).await
-            } else {
-                None
-            }
-        }
-        .unwrap_or_else(|| ChainItem {
-            uid: "".into(),
-            data: ChainType::Merge(Mapping::new()),
-        });
-
-        let script = {
-            let item = {
-                let profiles = Config::profiles().await;
-                let profiles = profiles.latest_ref();
-                profiles.get_item(&script_uid).ok().cloned()
-            };
-            if let Some(item) = item {
-                <Option<ChainItem>>::from_async(&item).await
-            } else {
-                None
-            }
-        }
-        .unwrap_or_else(|| ChainItem {
-            uid: "".into(),
-            data: ChainType::Script(tmpl::ITEM_SCRIPT.into()),
-        });
-
-        let rules = {
-            let item = {
-                let profiles = Config::profiles().await;
-                let profiles = profiles.latest_ref();
-                profiles.get_item(&rules_uid).ok().cloned()
-            };
-            if let Some(item) = item {
-                <Option<ChainItem>>::from_async(&item).await
-            } else {
-                None
-            }
-        }
-        .unwrap_or_else(|| ChainItem {
-            uid: "".into(),
-            data: ChainType::Rules(SeqMap::default()),
-        });
-
-        let proxies = {
-            let item = {
-                let profiles = Config::profiles().await;
-                let profiles = profiles.latest_ref();
-                profiles.get_item(&proxies_uid).ok().cloned()
-            };
-            if let Some(item) = item {
-                <Option<ChainItem>>::from_async(&item).await
-            } else {
-                None
-            }
-        }
-        .unwrap_or_else(|| ChainItem {
-            uid: "".into(),
-            data: ChainType::Proxies(SeqMap::default()),
-        });
-
-        let groups = {
-            let item = {
-                let profiles = Config::profiles().await;
-                let profiles = profiles.latest_ref();
-                profiles.get_item(&groups_uid).ok().cloned()
-            };
-            if let Some(item) = item {
-                <Option<ChainItem>>::from_async(&item).await
-            } else {
-                None
-            }
-        }
-        .unwrap_or_else(|| ChainItem {
-            uid: "".into(),
-            data: ChainType::Groups(SeqMap::default()),
-        });
-
-        let global_merge = {
-            let item = {
-                let profiles = Config::profiles().await;
-                let profiles = profiles.latest_ref();
-                profiles.get_item(&"Merge".to_string()).ok().cloned()
-            };
-            if let Some(item) = item {
-                <Option<ChainItem>>::from_async(&item).await
-            } else {
-                None
-            }
-        }
-        .unwrap_or_else(|| ChainItem {
-            uid: "Merge".into(),
-            data: ChainType::Merge(Mapping::new()),
-        });
-
-        let global_script = {
-            let item = {
-                let profiles = Config::profiles().await;
-                let profiles = profiles.latest_ref();
-                profiles.get_item(&"Script".to_string()).ok().cloned()
-            };
-            if let Some(item) = item {
-                <Option<ChainItem>>::from_async(&item).await
-            } else {
-                None
-            }
-        }
-        .unwrap_or_else(|| ChainItem {
-            uid: "Script".into(),
-            data: ChainType::Script(tmpl::ITEM_SCRIPT.into()),
-        });
+        let name = profiles
+            .get_item(&profiles.get_current().unwrap_or_default())
+            .ok()
+            .and_then(|item| item.name.clone())
+            .unwrap_or_default();
 
         (
             current,
@@ -312,12 +214,6 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
                 config.remove("port");
                 continue;
             }
-            #[cfg(target_os = "windows")]
-            {
-                if key.as_str() == Some("redir-port") || key.as_str() == Some("tproxy-port") {
-                    continue;
-                }
-            }
             #[cfg(not(target_os = "windows"))]
             {
                 if key.as_str() == Some("redir-port") && !redir_enabled {
@@ -332,23 +228,7 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
                     continue;
                 }
             }
-            // 处理 external-controller 键的开关逻辑
-            if key.as_str() == Some("external-controller") {
-                let enable_external_controller = Config::verge()
-                    .await
-                    .latest_ref()
-                    .enable_external_controller
-                    .unwrap_or(false);
-
-                if enable_external_controller {
-                    config.insert(key, value);
-                } else {
-                    // 如果禁用了外部控制器，设置为空字符串
-                    config.insert(key, "".into());
-                }
-            } else {
-                config.insert(key, value);
-            }
+            config.insert(key, value);
         }
     }
 
@@ -373,7 +253,7 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
             });
     }
 
-    config = use_tun(config, enable_tun);
+    config = use_tun(config, enable_tun).await;
     config = use_sort(config);
 
     // 应用独立的DNS配置（如果启用）
@@ -384,26 +264,27 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
         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)
-            {
-                // 处理hosts配置
-                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");
-                }
+            if dns_path.exists() {
+                if let Ok(dns_yaml) = fs::read_to_string(&dns_path) {
+                    if let Ok(dns_config) = serde_yaml::from_str::<serde_yaml::Mapping>(&dns_yaml) {
+                        // 处理hosts配置
+                        if let Some(hosts_value) = dns_config.get("hosts") {
+                            if hosts_value.is_mapping() {
+                                config.insert("hosts".into(), hosts_value.clone());
+                                log::info!(target: "app", "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)");
+                        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");
+                        }
                     }
-                } else {
-                    config.insert("dns".into(), dns_config.into());
-                    log::info!(target: "app", "apply dns_config.yaml");
                 }
             }
         }

src-tauri/src/enhance/script.rs

@@ -1,49 +1,30 @@
 use super::use_lowercase;
 use anyhow::{Error, Result};
-use serde_yaml_ng::Mapping;
+use serde_yaml::Mapping;
 
 pub fn use_script(
     script: String,
     config: Mapping,
     name: String,
 ) -> Result<(Mapping, Vec<(String, String)>)> {
-    use boa_engine::{Context, JsString, JsValue, Source, native_function::NativeFunction};
-    use std::{cell::RefCell, rc::Rc};
+    use boa_engine::{native_function::NativeFunction, Context, JsValue, Source};
+    use std::sync::{Arc, Mutex};
     let mut context = Context::default();
 
-    let outputs = Rc::new(RefCell::new(vec![]));
+    let outputs = Arc::new(Mutex::new(vec![]));
 
-    let copy_outputs = Rc::clone(&outputs);
+    let copy_outputs = outputs.clone();
     unsafe {
         let _ = context.register_global_builtin_callable(
             "__verge_log__".into(),
             2,
             NativeFunction::from_closure(
                 move |_: &JsValue, args: &[JsValue], context: &mut Context| {
-                    let level = args.first().ok_or_else(|| {
-                        boa_engine::JsError::from_opaque(
-                            JsString::from("Missing level argument").into(),
-                        )
-                    })?;
-                    let level = level.to_string(context)?;
-                    let level = level.to_std_string().map_err(|_| {
-                        boa_engine::JsError::from_opaque(
-                            JsString::from("Failed to convert level to string").into(),
-                        )
-                    })?;
-
-                    let data = args.get(1).ok_or_else(|| {
-                        boa_engine::JsError::from_opaque(
-                            JsString::from("Missing data argument").into(),
-                        )
-                    })?;
-                    let data = data.to_string(context)?;
-                    let data = data.to_std_string().map_err(|_| {
-                        boa_engine::JsError::from_opaque(
-                            JsString::from("Failed to convert data to string").into(),
-                        )
-                    })?;
-                    let mut out = copy_outputs.borrow_mut();
+                    let level = args.first().unwrap().to_string(context)?;
+                    let level = level.to_std_string().unwrap();
+                    let data = args.get(1).unwrap().to_string(context)?;
+                    let data = data.to_std_string().unwrap();
+                    let mut out = copy_outputs.lock().unwrap();
                     out.push((level, data));
                     Ok(JsValue::undefined())
                 },
@@ -52,45 +33,38 @@ pub fn use_script(
     }
     let _ = context.eval(Source::from_bytes(
         r#"var console = Object.freeze({
-        log(data){__verge_log__("log",JSON.stringify(data, null, 2))},
-        info(data){__verge_log__("info",JSON.stringify(data, null, 2))},
-        error(data){__verge_log__("error",JSON.stringify(data, null, 2))},
-        debug(data){__verge_log__("debug",JSON.stringify(data, null, 2))},
-        warn(data){__verge_log__("warn",JSON.stringify(data, null, 2))},
-        table(data){__verge_log__("table",JSON.stringify(data, null, 2))},
+        log(data){__verge_log__("log",JSON.stringify(data))}, 
+        info(data){__verge_log__("info",JSON.stringify(data))}, 
+        error(data){__verge_log__("error",JSON.stringify(data))},
+        debug(data){__verge_log__("debug",JSON.stringify(data))},
       });"#,
     ));
 
     let config = use_lowercase(config.clone());
     let config_str = serde_json::to_string(&config)?;
 
-    // 仅处理 name 参数中的特殊字符
-    let safe_name = escape_js_string_for_single_quote(&name);
-
     let code = format!(
-        r"try{{
+        r#"try{{
         {script};
-        JSON.stringify(main({config_str},'{safe_name}')||'')
+        JSON.stringify(main({config_str},'{name}')||'')
       }} catch(err) {{
         `__error_flag__ ${{err.toString()}}`
-      }}"
+      }}"#
     );
-
     if let Ok(result) = context.eval(Source::from_bytes(code.as_str())) {
         if !result.is_string() {
             anyhow::bail!("main function should return object");
         }
-        let result = result
-            .to_string(&mut context)
-            .map_err(|e| anyhow::anyhow!("Failed to convert JS result to string: {}", e))?;
-        let result = result
-            .to_std_string()
-            .map_err(|_| anyhow::anyhow!("Failed to convert JS string to std string"))?;
-
-        // 直接解析JSON结果,不做其他解析
-        let res: Result<Mapping, Error> = parse_json_safely(&result);
-
-        let mut out = outputs.borrow_mut();
+        let result = result.to_string(&mut context).unwrap();
+        let result = result.to_std_string().unwrap();
+        if result.starts_with("__error_flag__") {
+            anyhow::bail!(result[15..].to_owned());
+        }
+        if result == "\"\"" {
+            anyhow::bail!("main function should return object");
+        }
+        let res: Result<Mapping, Error> = Ok(serde_json::from_str::<Mapping>(result.as_str())?);
+        let mut out = outputs.lock().unwrap();
         match res {
             Ok(config) => Ok((use_lowercase(config), out.to_vec())),
             Err(err) => {
@@ -103,30 +77,7 @@ pub fn use_script(
     }
 }
 
-fn parse_json_safely(json_str: &str) -> Result<Mapping, Error> {
-    let json_str = strip_outer_quotes(json_str);
-
-    Ok(serde_json::from_str::<Mapping>(json_str)?)
-}
-
-// 移除字符串外层的引号
-fn strip_outer_quotes(s: &str) -> &str {
-    let s = s.trim();
-    if (s.starts_with('"') && s.ends_with('"')) || (s.starts_with('\'') && s.ends_with('\'')) {
-        &s[1..s.len() - 1]
-    } else {
-        s
-    }
-}
-
-// 转义单引号和反斜杠，用于单引号包裹的JavaScript字符串
-fn escape_js_string_for_single_quote(s: &str) -> String {
-    s.replace('\\', "\\\\").replace('\'', "\\'")
-}
-
 #[test]
-#[allow(unused_variables)]
-#[allow(clippy::expect_used)]
 fn test_script() {
     let script = r#"
     function main(config) {
@@ -139,7 +90,7 @@ fn test_script() {
     }
   "#;
 
-    let config = r"
+    let config = r#"
     rules:
       - 111
       - 222
@@ -147,37 +98,12 @@ fn test_script() {
       enable: false
     dns:
       enable: false
-  ";
+  "#;
 
-    let config = serde_yaml_ng::from_str(config).expect("Failed to parse test config YAML");
-    let (config, results) = use_script(script.into(), config, "".to_string())
-        .expect("Script execution should succeed in test");
+    let config = serde_yaml::from_str(config).unwrap();
+    let (config, results) = use_script(script.into(), config, "".to_string()).unwrap();
 
-    let _ = serde_yaml_ng::to_string(&config).expect("Failed to serialize config to YAML");
-    let yaml_config_size = std::mem::size_of_val(&config);
-    let box_yaml_config_size = std::mem::size_of_val(&Box::new(config));
-    assert!(box_yaml_config_size < yaml_config_size);
-}
+    let _ = serde_yaml::to_string(&config).unwrap();
 
-// 测试特殊字符转义功能
-#[test]
-#[allow(clippy::expect_used)]
-fn test_escape_unescape() {
-    let test_string = r#"Hello "World"!\nThis is a test with \u00A9 copyright symbol."#;
-    let escaped = escape_js_string_for_single_quote(test_string);
-    println!("Original: {test_string}");
-    println!("Escaped: {escaped}");
-
-    let json_str = r#"{"key":"value","nested":{"key":"value"}}"#;
-    let parsed = parse_json_safely(json_str).expect("Failed to parse test JSON safely");
-
-    assert!(parsed.contains_key("key"));
-    assert!(parsed.contains_key("nested"));
-
-    let quoted_json_str = r#""{"key":"value","nested":{"key":"value"}}""#;
-    let parsed_quoted =
-        parse_json_safely(quoted_json_str).expect("Failed to parse quoted test JSON safely");
-
-    assert!(parsed_quoted.contains_key("key"));
-    assert!(parsed_quoted.contains_key("nested"));
+    dbg!(results);
 }

src-tauri/src/enhance/seq.rs

@@ -1,5 +1,5 @@
 use serde::{Deserialize, Serialize};
-use serde_yaml_ng::{Mapping, Sequence, Value};
+use serde_yaml::{Mapping, Sequence, Value};
 
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
 pub struct SeqMap {
@@ -44,39 +44,39 @@ pub fn use_seq(seq: SeqMap, mut config: Mapping, field: &str) -> Mapping {
     config.insert(Value::String(field.into()), Value::Sequence(new_seq));
 
     // If this is proxies field, we also need to filter proxy-groups
-    if field == "proxies"
-        && let Some(Value::Sequence(groups)) = config.get_mut("proxy-groups")
-    {
-        let mut new_groups = Sequence::new();
-        for group in groups {
-            if let Value::Mapping(group_map) = group {
-                let mut new_group = group_map.clone();
-                if let Some(Value::Sequence(proxies)) = group_map.get("proxies") {
-                    let filtered_proxies: Sequence = proxies
-                        .iter()
-                        .filter(|p| {
-                            if let Value::String(name) = p {
-                                !delete.contains(name)
-                            } else {
-                                true
-                            }
-                        })
-                        .cloned()
-                        .collect();
-                    new_group.insert(
-                        Value::String("proxies".into()),
-                        Value::Sequence(filtered_proxies),
-                    );
+    if field == "proxies" {
+        if let Some(Value::Sequence(groups)) = config.get_mut("proxy-groups") {
+            let mut new_groups = Sequence::new();
+            for group in groups {
+                if let Value::Mapping(group_map) = group {
+                    let mut new_group = group_map.clone();
+                    if let Some(Value::Sequence(proxies)) = group_map.get("proxies") {
+                        let filtered_proxies: Sequence = proxies
+                            .iter()
+                            .filter(|p| {
+                                if let Value::String(name) = p {
+                                    !delete.contains(name)
+                                } else {
+                                    true
+                                }
+                            })
+                            .cloned()
+                            .collect();
+                        new_group.insert(
+                            Value::String("proxies".into()),
+                            Value::Sequence(filtered_proxies),
+                        );
+                    }
+                    new_groups.push(Value::Mapping(new_group));
+                } else {
+                    new_groups.push(group.clone());
                 }
-                new_groups.push(Value::Mapping(new_group));
-            } else {
-                new_groups.push(group.clone());
             }
+            config.insert(
+                Value::String("proxy-groups".into()),
+                Value::Sequence(new_groups),
+            );
         }
-        config.insert(
-            Value::String("proxy-groups".into()),
-            Value::Sequence(new_groups),
-        );
     }
 
     config
@@ -86,11 +86,9 @@ pub fn use_seq(seq: SeqMap, mut config: Mapping, field: &str) -> Mapping {
 mod tests {
     use super::*;
     #[allow(unused_imports)]
-    use serde_yaml_ng::Value;
+    use serde_yaml::Value;
 
     #[test]
-    #[allow(clippy::unwrap_used)]
-    #[allow(clippy::expect_used)]
     fn test_delete_proxy_and_references() {
         let config_str = r#"
 proxies:
@@ -109,8 +107,7 @@ proxy-groups:
   proxies:
     - "proxy1"
 "#;
-        let mut config: Mapping =
-            serde_yaml_ng::from_str(config_str).expect("Failed to parse test config YAML");
+        let mut config: Mapping = serde_yaml::from_str(config_str).unwrap();
 
         let seq = SeqMap {
             prepend: Sequence::new(),
@@ -121,51 +118,38 @@ proxy-groups:
         config = use_seq(seq, config, "proxies");
 
         // Check if proxy1 is removed from proxies
-        let proxies = config
-            .get("proxies")
-            .expect("proxies field should exist")
-            .as_sequence()
-            .expect("proxies should be a sequence");
+        let proxies = config.get("proxies").unwrap().as_sequence().unwrap();
         assert_eq!(proxies.len(), 1);
         assert_eq!(
             proxies[0]
                 .as_mapping()
-                .expect("proxy should be a mapping")
+                .unwrap()
                 .get("name")
-                .expect("proxy should have name")
+                .unwrap()
                 .as_str()
-                .expect("name should be string"),
+                .unwrap(),
             "proxy2"
         );
 
         // Check if proxy1 is removed from all groups
-        let groups = config
-            .get("proxy-groups")
-            .expect("proxy-groups field should exist")
-            .as_sequence()
-            .expect("proxy-groups should be a sequence");
+        let groups = config.get("proxy-groups").unwrap().as_sequence().unwrap();
         let group1_proxies = groups[0]
             .as_mapping()
-            .expect("group should be a mapping")
+            .unwrap()
             .get("proxies")
-            .expect("group should have proxies")
+            .unwrap()
             .as_sequence()
-            .expect("group proxies should be a sequence");
+            .unwrap();
         let group2_proxies = groups[1]
             .as_mapping()
-            .expect("group should be a mapping")
+            .unwrap()
             .get("proxies")
-            .expect("group should have proxies")
+            .unwrap()
             .as_sequence()
-            .expect("group proxies should be a sequence");
+            .unwrap();
 
         assert_eq!(group1_proxies.len(), 1);
-        assert_eq!(
-            group1_proxies[0]
-                .as_str()
-                .expect("proxy name should be string"),
-            "proxy2"
-        );
+        assert_eq!(group1_proxies[0].as_str().unwrap(), "proxy2");
         assert_eq!(group2_proxies.len(), 0);
     }
 }

src-tauri/src/enhance/tun.rs

@@ -1,7 +1,4 @@
-use serde_yaml_ng::{Mapping, Value};
-
-#[cfg(target_os = "macos")]
-use crate::process::AsyncHandler;
+use serde_yaml::{Mapping, Value};
 
 macro_rules! revise {
     ($map: expr, $key: expr, $val: expr) => {
@@ -21,7 +18,7 @@ macro_rules! append {
     };
 }
 
-pub fn use_tun(mut config: Mapping, enable: bool) -> Mapping {
+pub async fn use_tun(mut config: Mapping, enable: bool) -> Mapping {
     let tun_key = Value::from("tun");
     let tun_val = config.get(&tun_key);
     let mut tun_val = tun_val.map_or(Mapping::new(), |val| {
@@ -62,10 +59,8 @@ pub fn use_tun(mut config: Mapping, enable: bool) -> Mapping {
 
             #[cfg(target_os = "macos")]
             {
-                AsyncHandler::spawn(move || async move {
-                    crate::utils::resolve::dns::restore_public_dns().await;
-                    crate::utils::resolve::dns::set_public_dns("223.6.6.6".to_string()).await;
-                });
+                crate::utils::resolve::restore_public_dns().await;
+                crate::utils::resolve::set_public_dns("223.6.6.6".to_string()).await;
             }
         }
 
@@ -74,9 +69,7 @@ pub fn use_tun(mut config: Mapping, enable: bool) -> Mapping {
     } else {
         // TUN未启用时，仅恢复系统DNS，不修改配置文件中的DNS设置
         #[cfg(target_os = "macos")]
-        AsyncHandler::spawn(move || async move {
-            crate::utils::resolve::dns::restore_public_dns().await;
-        });
+        crate::utils::resolve::restore_public_dns().await;
     }
 
     // 更新TUN配置

src-tauri/src/feat/backup.rs

@@ -11,7 +11,7 @@ use std::fs;
 /// 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| {
-        log::error!(target: "app", "Failed to create backup: {err:#?}");
+        log::error!(target: "app", "Failed to create backup: {:#?}", err);
         err
     })?;
 
@@ -19,12 +19,12 @@ pub async fn create_backup_and_upload_webdav() -> Result<()> {
         .upload(temp_file_path.clone(), file_name)
         .await
     {
-        log::error!(target: "app", "Failed to upload to WebDAV: {err:#?}");
+        log::error!(target: "app", "Failed to upload to WebDAV: {:#?}", err);
         return Err(err);
     }
 
     if let Err(err) = std::fs::remove_file(&temp_file_path) {
-        log::warn!(target: "app", "Failed to remove temp file: {err:#?}");
+        log::warn!(target: "app", "Failed to remove temp file: {:#?}", err);
     }
 
     Ok(())
@@ -33,7 +33,7 @@ pub async fn create_backup_and_upload_webdav() -> Result<()> {
 /// List WebDAV backups
 pub async fn list_wevdav_backup() -> Result<Vec<ListFile>> {
     backup::WebDavClient::global().list().await.map_err(|err| {
-        log::error!(target: "app", "Failed to list WebDAV backup files: {err:#?}");
+        log::error!(target: "app", "Failed to list WebDAV backup files: {:#?}", err);
         err
     })
 }
@@ -44,27 +44,25 @@ pub async fn delete_webdav_backup(filename: String) -> Result<()> {
         .delete(filename)
         .await
         .map_err(|err| {
-            log::error!(target: "app", "Failed to delete WebDAV backup file: {err:#?}");
+            log::error!(target: "app", "Failed to delete WebDAV backup file: {:#?}", err);
             err
         })
 }
 
 /// 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 = Config::verge();
+    let verge_data = verge.data().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 backup_storage_path = app_home_dir()
-        .map_err(|e| anyhow::anyhow!("Failed to get app home dir: {e}"))?
-        .join(&filename);
+    let backup_storage_path = app_home_dir().unwrap().join(&filename);
     backup::WebDavClient::global()
         .download(filename, backup_storage_path.clone())
         .await
         .map_err(|err| {
-            log::error!(target: "app", "Failed to download WebDAV backup file: {err:#?}");
+            log::error!(target: "app", "Failed to download WebDAV backup file: {:#?}", err);
             err
         })?;
 

src-tauri/src/feat/clash.rs

@@ -1,103 +1,92 @@
 use crate::{
     config::Config,
-    core::{CoreManager, handle, tray},
-    ipc::IpcManager,
+    core::{handle, tray, CoreManager},
     logging_error,
+    module::mihomo::MihomoManager,
     process::AsyncHandler,
     utils::{logging::Type, resolve},
 };
-use serde_yaml_ng::{Mapping, Value};
+use serde_yaml::{Mapping, Value};
+use tauri::Manager;
 
 /// Restart the Clash core
-pub async fn restart_clash_core() {
-    match CoreManager::global().restart_core().await {
-        Ok(_) => {
-            handle::Handle::refresh_clash();
-            handle::Handle::notice_message("set_config::ok", "ok");
+pub fn restart_clash_core() {
+    AsyncHandler::spawn(move || async move {
+        match CoreManager::global().restart_core().await {
+            Ok(_) => {
+                handle::Handle::refresh_clash();
+                handle::Handle::notice_message("set_config::ok", "ok");
+            }
+            Err(err) => {
+                handle::Handle::notice_message("set_config::error", format!("{err}"));
+                log::error!(target:"app", "{err}");
+            }
         }
-        Err(err) => {
-            handle::Handle::notice_message("set_config::error", format!("{err}"));
-            log::error!(target:"app", "{err}");
-        }
-    }
+    });
 }
 
 /// Restart the application
-pub async fn restart_app() {
-    // logging_error!(Type::Core, true, CoreManager::global().stop_core().await);
-    resolve::resolve_reset_async().await;
-
-    handle::Handle::global()
-        .app_handle()
-        .map(|app_handle| {
-            app_handle.restart();
-        })
-        .unwrap_or_else(|| {
-            logging_error!(
-                Type::System,
-                false,
-                "{}",
-                "Failed to get app handle for restart"
-            );
-        });
+pub fn restart_app() {
+    AsyncHandler::spawn(move || async move {
+        logging_error!(Type::Core, true, CoreManager::global().stop_core().await);
+        resolve::resolve_reset_async().await;
+        let app_handle = handle::Handle::global().app_handle().unwrap();
+        std::thread::sleep(std::time::Duration::from_secs(1));
+        tauri::process::restart(&app_handle.env());
+    });
 }
 
 fn after_change_clash_mode() {
     AsyncHandler::spawn(move || async {
-        match IpcManager::global().get_connections().await {
+        match MihomoManager::global().get_connections().await {
             Ok(connections) => {
                 if let Some(connections_array) = connections["connections"].as_array() {
                     for connection in connections_array {
                         if let Some(id) = connection["id"].as_str() {
-                            let _ = IpcManager::global().delete_connection(id).await;
+                            let _ = MihomoManager::global().delete_connection(id).await;
                         }
                     }
                 }
             }
             Err(err) => {
-                log::error!(target: "app", "Failed to get connections: {err}");
+                log::error!(target: "app", "Failed to get connections: {}", err);
             }
         }
     });
 }
 
 /// Change Clash mode (rule/global/direct/script)
-pub async fn change_clash_mode(mode: String) {
+pub fn change_clash_mode(mode: String) {
     let mut mapping = Mapping::new();
     mapping.insert(Value::from("mode"), mode.clone().into());
     // Convert YAML mapping to JSON Value
     let json_value = serde_json::json!({
         "mode": mode
     });
-    log::debug!(target: "app", "change clash mode to {mode}");
-    match IpcManager::global().patch_configs(json_value).await {
-        Ok(_) => {
-            // 更新订阅
-            Config::clash().await.data_mut().patch_config(mapping);
+    AsyncHandler::spawn(move || async move {
+        log::debug!(target: "app", "change clash mode to {mode}");
+        match MihomoManager::global().patch_configs(json_value).await {
+            Ok(_) => {
+                // 更新订阅
+                Config::clash().data().patch_config(mapping);
 
-            // 分离数据获取和异步调用
-            let clash_data = Config::clash().await.data_mut().clone();
-            if clash_data.save_config().await.is_ok() {
-                handle::Handle::refresh_clash();
-                logging_error!(Type::Tray, true, tray::Tray::global().update_menu().await);
-                logging_error!(
-                    Type::Tray,
-                    true,
-                    tray::Tray::global().update_icon(None).await
-                );
-            }
+                if Config::clash().data().save_config().is_ok() {
+                    handle::Handle::refresh_clash();
+                    logging_error!(Type::Tray, true, tray::Tray::global().update_menu());
+                    logging_error!(Type::Tray, true, tray::Tray::global().update_icon(None));
+                }
 
-            let is_auto_close_connection = Config::verge()
-                .await
-                .data_mut()
-                .auto_close_connection
-                .unwrap_or(false);
-            if is_auto_close_connection {
-                after_change_clash_mode();
+                let is_auto_close_connection = Config::verge()
+                    .data()
+                    .auto_close_connection
+                    .unwrap_or(false);
+                if is_auto_close_connection {
+                    after_change_clash_mode();
+                }
             }
+            Err(err) => println!("{err}"),
         }
-        Err(err) => log::error!(target: "app", "{err}"),
-    }
+    });
 }
 
 /// Test connection delay to a URL
@@ -105,11 +94,7 @@ pub async fn test_delay(url: String) -> anyhow::Result<u32> {
     use crate::utils::network::{NetworkManager, ProxyType};
     use tokio::time::Instant;
 
-    let tun_mode = Config::verge()
-        .await
-        .latest_ref()
-        .enable_tun_mode
-        .unwrap_or(false);
+    let tun_mode = Config::verge().latest().enable_tun_mode.unwrap_or(false);
 
     // 如果是TUN模式，不使用代理，否则使用自身代理
     let proxy_type = if !tun_mode {
@@ -122,13 +107,13 @@ pub async fn test_delay(url: String) -> anyhow::Result<u32> {
 
     let start = Instant::now();
 
-    let response = NetworkManager::new()
+    let response = NetworkManager::global()
         .get_with_interrupt(&url, proxy_type, Some(10), user_agent, false)
         .await;
 
     match response {
         Ok(response) => {
-            log::trace!(target: "app", "test_delay response: {response:#?}");
+            log::trace!(target: "app", "test_delay response: {:#?}", response);
             if response.status().is_success() {
                 Ok(start.elapsed().as_millis() as u32)
             } else {
@@ -136,7 +121,7 @@ pub async fn test_delay(url: String) -> anyhow::Result<u32> {
             }
         }
         Err(err) => {
-            log::trace!(target: "app", "test_delay error: {err:#?}");
+            log::trace!(target: "app", "test_delay error: {:#?}", err);
             Err(err)
         }
     }

src-tauri/src/feat/config.rs

@@ -1,19 +1,16 @@
 use crate::{
     config::{Config, IVerge},
-    core::{CoreManager, handle, hotkey, sysopt, tray},
+    core::{handle, hotkey, sysopt, tray, CoreManager},
     logging_error,
     module::lightweight,
     utils::logging::Type,
 };
 use anyhow::Result;
-use serde_yaml_ng::Mapping;
+use serde_yaml::Mapping;
 
 /// Patch Clash configuration
 pub async fn patch_clash(patch: Mapping) -> Result<()> {
-    Config::clash()
-        .await
-        .draft_mut()
-        .patch_config(patch.clone());
+    Config::clash().draft().patch_config(patch.clone());
 
     let res = {
         // 激活订阅
@@ -22,14 +19,10 @@ pub async fn patch_clash(patch: Mapping) -> Result<()> {
             CoreManager::global().restart_core().await?;
         } else {
             if patch.get("mode").is_some() {
-                logging_error!(Type::Tray, true, tray::Tray::global().update_menu().await);
-                logging_error!(
-                    Type::Tray,
-                    true,
-                    tray::Tray::global().update_icon(None).await
-                );
+                logging_error!(Type::Tray, true, tray::Tray::global().update_menu());
+                logging_error!(Type::Tray, true, tray::Tray::global().update_icon(None));
             }
-            Config::runtime().await.draft_mut().patch_config(patch);
+            Config::runtime().latest().patch_config(patch);
             CoreManager::global().update_config().await?;
         }
         handle::Handle::refresh_clash();
@@ -37,14 +30,12 @@ pub async fn patch_clash(patch: Mapping) -> Result<()> {
     };
     match res {
         Ok(()) => {
-            Config::clash().await.apply();
-            // 分离数据获取和异步调用
-            let clash_data = Config::clash().await.data_mut().clone();
-            clash_data.save_config().await?;
+            Config::clash().apply();
+            Config::clash().data().save_config()?;
             Ok(())
         }
         Err(err) => {
-            Config::clash().await.discard();
+            Config::clash().discard();
             Err(err)
         }
     }
@@ -69,10 +60,7 @@ enum UpdateFlags {
 
 /// Patch Verge configuration
 pub async fn patch_verge(patch: IVerge, not_save_file: bool) -> Result<()> {
-    Config::verge()
-        .await
-        .draft_mut()
-        .patch_config(patch.clone());
+    Config::verge().draft().patch_config(patch.clone());
 
     let tun_mode = patch.enable_tun_mode;
     let auto_launch = patch.enable_auto_launch;
@@ -107,7 +95,6 @@ pub async fn patch_verge(patch: IVerge, not_save_file: bool) -> Result<()> {
     let tray_event = patch.tray_event;
     let home_cards = patch.home_cards.clone();
     let enable_auto_light_weight = patch.enable_auto_light_weight_mode;
-    let enable_external_controller = patch.enable_external_controller;
     let res: std::result::Result<(), anyhow::Error> = {
         // Initialize with no flags set
         let mut update_flags: i32 = UpdateFlags::None as i32;
@@ -178,11 +165,6 @@ pub async fn patch_verge(patch: IVerge, not_save_file: bool) -> Result<()> {
             update_flags |= UpdateFlags::LighteWeight as i32;
         }
 
-        // 处理 external-controller 的开关
-        if enable_external_controller.is_some() {
-            update_flags |= UpdateFlags::RestartCore as i32;
-        }
-
         // Process updates based on flags
         if (update_flags & (UpdateFlags::RestartCore as i32)) != 0 {
             Config::generate().await?;
@@ -193,35 +175,33 @@ pub async fn patch_verge(patch: IVerge, not_save_file: bool) -> Result<()> {
             handle::Handle::refresh_clash();
         }
         if (update_flags & (UpdateFlags::VergeConfig as i32)) != 0 {
-            Config::verge().await.draft_mut().enable_global_hotkey = enable_global_hotkey;
+            Config::verge().draft().enable_global_hotkey = enable_global_hotkey;
             handle::Handle::refresh_verge();
         }
         if (update_flags & (UpdateFlags::Launch as i32)) != 0 {
-            sysopt::Sysopt::global().update_launch().await?;
+            sysopt::Sysopt::global().update_launch()?;
         }
         if (update_flags & (UpdateFlags::SysProxy as i32)) != 0 {
             sysopt::Sysopt::global().update_sysproxy().await?;
         }
-        if (update_flags & (UpdateFlags::Hotkey as i32)) != 0
-            && let Some(hotkeys) = patch.hotkeys
-        {
-            hotkey::Hotkey::global().update(hotkeys).await?;
+        if (update_flags & (UpdateFlags::Hotkey as i32)) != 0 {
+            hotkey::Hotkey::global().update(patch.hotkeys.unwrap())?;
         }
         if (update_flags & (UpdateFlags::SystrayMenu as i32)) != 0 {
-            tray::Tray::global().update_menu().await?;
+            tray::Tray::global().update_menu()?;
         }
         if (update_flags & (UpdateFlags::SystrayIcon as i32)) != 0 {
-            tray::Tray::global().update_icon(None).await?;
+            tray::Tray::global().update_icon(None)?;
         }
         if (update_flags & (UpdateFlags::SystrayTooltip as i32)) != 0 {
-            tray::Tray::global().update_tooltip().await?;
+            tray::Tray::global().update_tooltip()?;
         }
         if (update_flags & (UpdateFlags::SystrayClickBehavior as i32)) != 0 {
-            tray::Tray::global().update_click_behavior().await?;
+            tray::Tray::global().update_click_behavior()?;
         }
         if (update_flags & (UpdateFlags::LighteWeight as i32)) != 0 {
-            if enable_auto_light_weight.unwrap_or(false) {
-                lightweight::enable_auto_light_weight_mode().await;
+            if enable_auto_light_weight.unwrap() {
+                lightweight::enable_auto_light_weight_mode();
             } else {
                 lightweight::disable_auto_light_weight_mode();
             }
@@ -231,17 +211,15 @@ pub async fn patch_verge(patch: IVerge, not_save_file: bool) -> Result<()> {
     };
     match res {
         Ok(()) => {
-            Config::verge().await.apply();
+            Config::verge().apply();
             if !not_save_file {
-                // 分离数据获取和异步调用
-                let verge_data = Config::verge().await.data_mut().clone();
-                verge_data.save_file().await?;
+                Config::verge().data().save_file()?;
             }
 
             Ok(())
         }
         Err(err) => {
-            Config::verge().await.discard();
+            Config::verge().discard();
             Err(err)
         }
     }

src-tauri/src/feat/profile.rs

@@ -1,25 +1,24 @@
 use crate::{
     cmd,
-    config::{Config, PrfItem, PrfOption, profiles::profiles_draft_update_item_safe},
-    core::{CoreManager, handle, tray},
-    logging,
-    utils::logging::Type,
+    config::{Config, PrfItem, PrfOption},
+    core::{handle, CoreManager, *},
+    process::AsyncHandler,
 };
-use anyhow::{Result, bail};
+use anyhow::{bail, Result};
 
 /// Toggle proxy profile
-pub async fn toggle_proxy_profile(profile_index: String) {
-    match cmd::patch_profiles_config_by_profile_index(profile_index).await {
-        Ok(_) => {
-            let result = tray::Tray::global().update_menu().await;
-            if let Err(err) = result {
-                logging!(error, Type::Tray, true, "更新菜单失败: {}", err);
+pub fn toggle_proxy_profile(profile_index: String) {
+    AsyncHandler::spawn(|| async move {
+        let app_handle = handle::Handle::global().app_handle().unwrap();
+        match cmd::patch_profiles_config_by_profile_index(app_handle, profile_index).await {
+            Ok(_) => {
+                let _ = tray::Tray::global().update_menu();
+            }
+            Err(err) => {
+                log::error!(target: "app", "{err}");
             }
         }
-        Err(err) => {
-            log::error!(target: "app", "{err}");
-        }
-    }
+    });
 }
 
 /// Update a profile
@@ -30,58 +29,51 @@ pub async fn update_profile(
     option: Option<PrfOption>,
     auto_refresh: Option<bool>,
 ) -> Result<()> {
-    logging!(info, Type::Config, true, "[订阅更新] 开始更新订阅 {}", uid);
+    println!("[订阅更新] 开始更新订阅 {}", uid);
     let auto_refresh = auto_refresh.unwrap_or(true); // 默认为true，保持兼容性
 
     let url_opt = {
-        let profiles = Config::profiles().await;
-        let profiles = profiles.latest_ref();
+        let profiles = Config::profiles();
+        let profiles = profiles.latest();
         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} 不是远程订阅，跳过更新");
+            println!("[订阅更新] {} 不是远程订阅，跳过更新", uid);
             None // 非远程订阅直接更新
         } else if item.url.is_none() {
-            log::warn!(target: "app", "[订阅更新] {uid} 缺少URL，无法更新");
+            println!("[订阅更新] {} 缺少URL，无法更新", uid);
             bail!("failed to get the profile item url");
         } else {
-            log::info!(target: "app",
+            println!(
                 "[订阅更新] {} 是远程订阅，URL: {}",
                 uid,
-                item.url.clone().ok_or_else(|| anyhow::anyhow!("Profile URL is None"))?
+                item.url.clone().unwrap()
             );
-            Some((
-                item.url
-                    .clone()
-                    .ok_or_else(|| anyhow::anyhow!("Profile URL is None"))?,
-                item.option.clone(),
-            ))
+            Some((item.url.clone().unwrap(), item.option.clone()))
         }
     };
 
     let should_update = match url_opt {
         Some((url, opt)) => {
-            log::info!(target: "app", "[订阅更新] 开始下载新的订阅内容");
+            println!("[订阅更新] 开始下载新的订阅内容");
             let merged_opt = PrfOption::merge(opt.clone(), option.clone());
 
             // 尝试使用正常设置更新
             match PrfItem::from_url(&url, None, None, merged_opt.clone()).await {
                 Ok(item) => {
-                    log::info!(target: "app", "[订阅更新] 更新订阅配置成功");
-                    let profiles = Config::profiles().await;
+                    println!("[订阅更新] 更新订阅配置成功");
+                    let profiles = Config::profiles();
+                    let mut profiles = profiles.latest();
+                    profiles.update_item(uid.clone(), item)?;
 
-                    // 使用Send-safe helper函数
-                    let result = profiles_draft_update_item_safe(uid.clone(), item).await;
-                    result?;
-
-                    let is_current = Some(uid.clone()) == profiles.latest_ref().get_current();
-                    log::info!(target: "app", "[订阅更新] 是否为当前使用的订阅: {is_current}");
+                    let is_current = Some(uid.clone()) == profiles.get_current();
+                    println!("[订阅更新] 是否为当前使用的订阅: {}", is_current);
                     is_current && auto_refresh
                 }
                 Err(err) => {
                     // 首次更新失败，尝试使用Clash代理
-                    log::warn!(target: "app", "[订阅更新] 正常更新失败: {err}，尝试使用Clash代理更新");
+                    println!("[订阅更新] 正常更新失败: {}，尝试使用Clash代理更新", err);
 
                     // 发送通知
                     handle::Handle::notice_message("update_retry_with_clash", uid.clone());
@@ -98,7 +90,7 @@ pub async fn update_profile(
                     // 使用Clash代理重试
                     match PrfItem::from_url(&url, None, None, Some(fallback_opt)).await {
                         Ok(mut item) => {
-                            log::info!(target: "app", "[订阅更新] 使用Clash代理更新成功");
+                            println!("[订阅更新] 使用Clash代理更新成功");
 
                             // 恢复原始代理设置到item
                             if let Some(option) = item.option.as_mut() {
@@ -107,10 +99,9 @@ pub async fn update_profile(
                             }
 
                             // 更新到配置
-                            let profiles = Config::profiles().await;
-
-                            // 使用 Send-safe 方法进行数据操作
-                            profiles_draft_update_item_safe(uid.clone(), item.clone()).await?;
+                            let profiles = Config::profiles();
+                            let mut profiles = profiles.latest();
+                            profiles.update_item(uid.clone(), item.clone())?;
 
                             // 获取配置名称用于通知
                             let profile_name = item.name.clone().unwrap_or_else(|| uid.clone());
@@ -118,15 +109,15 @@ pub async fn update_profile(
                             // 发送通知告知用户自动更新使用了回退机制
                             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}");
+                            let is_current = Some(uid.clone()) == profiles.get_current();
+                            println!("[订阅更新] 是否为当前使用的订阅: {}", is_current);
                             is_current && auto_refresh
                         }
                         Err(retry_err) => {
-                            log::error!(target: "app", "[订阅更新] 使用Clash代理更新仍然失败: {retry_err}");
+                            println!("[订阅更新] 使用Clash代理更新仍然失败: {}", retry_err);
                             handle::Handle::notice_message(
                                 "update_failed_even_with_clash",
-                                format!("{retry_err}"),
+                                format!("{}", retry_err),
                             );
                             return Err(retry_err);
                         }
@@ -138,23 +129,14 @@ pub async fn update_profile(
     };
 
     if should_update {
-        logging!(info, Type::Config, true, "[订阅更新] 更新内核配置");
+        println!("[订阅更新] 更新内核配置");
         match CoreManager::global().update_config().await {
             Ok(_) => {
-                logging!(info, Type::Config, true, "[订阅更新] 更新成功");
+                println!("[订阅更新] 更新成功");
                 handle::Handle::refresh_clash();
-                if let Err(err) = cmd::proxy::force_refresh_proxies().await {
-                    logging!(
-                        error,
-                        Type::Config,
-                        true,
-                        "[订阅更新] 代理组刷新失败: {}",
-                        err
-                    );
-                }
             }
             Err(err) => {
-                logging!(error, Type::Config, true, "[订阅更新] 更新失败: {}", err);
+                println!("[订阅更新] 更新失败: {}", err);
                 handle::Handle::notice_message("update_failed", format!("{err}"));
                 log::error!(target: "app", "{err}");
             }

src-tauri/src/feat/proxy.rs

@@ -1,103 +1,85 @@
 use crate::{
     config::{Config, IVerge},
     core::handle,
-    ipc::IpcManager,
-    logging,
-    utils::logging::Type,
+    process::AsyncHandler,
 };
 use std::env;
 use tauri_plugin_clipboard_manager::ClipboardExt;
 
 /// Toggle system proxy on/off
-pub async fn toggle_system_proxy() {
-    // 获取当前系统代理状态
-    let enable = {
-        let verge = Config::verge().await;
+pub fn toggle_system_proxy() {
+    let enable = Config::verge().draft().enable_system_proxy;
+    let enable = enable.unwrap_or(false);
+    let auto_close_connection = Config::verge()
+        .data()
+        .auto_close_connection
+        .unwrap_or(false);
 
-        verge.latest_ref().enable_system_proxy.unwrap_or(false)
-    };
-    // 获取自动关闭连接设置
-    let auto_close_connection = {
-        let verge = Config::verge().await;
+    AsyncHandler::spawn(move || async move {
+        // 如果当前系统代理即将关闭，且自动关闭连接设置为true，则关闭所有连接
+        if enable && auto_close_connection {
+            if let Err(err) = crate::module::mihomo::MihomoManager::global()
+                .close_all_connections()
+                .await
+            {
+                log::error!(target: "app", "Failed to close all connections: {}", err);
+            }
+        }
 
-        verge.latest_ref().auto_close_connection.unwrap_or(false)
-    };
-
-    // 如果当前系统代理即将关闭，且自动关闭连接设置为true，则关闭所有连接
-    if enable
-        && auto_close_connection
-        && let Err(err) = IpcManager::global().close_all_connections().await
-    {
-        log::error!(target: "app", "Failed to close all connections: {err}");
-    }
-
-    let patch_result = super::patch_verge(
-        IVerge {
-            enable_system_proxy: Some(!enable),
-            ..IVerge::default()
-        },
-        false,
-    )
-    .await;
-
-    match patch_result {
-        Ok(_) => handle::Handle::refresh_verge(),
-        Err(err) => log::error!(target: "app", "{err}"),
-    }
+        match super::patch_verge(
+            IVerge {
+                enable_system_proxy: Some(!enable),
+                ..IVerge::default()
+            },
+            false,
+        )
+        .await
+        {
+            Ok(_) => handle::Handle::refresh_verge(),
+            Err(err) => log::error!(target: "app", "{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;
+pub fn toggle_tun_mode(not_save_file: Option<bool>) {
+    let enable = Config::verge().data().enable_tun_mode;
     let enable = enable.unwrap_or(false);
 
-    match super::patch_verge(
-        IVerge {
-            enable_tun_mode: Some(!enable),
-            ..IVerge::default()
-        },
-        not_save_file.unwrap_or(false),
-    )
-    .await
-    {
-        Ok(_) => handle::Handle::refresh_verge(),
-        Err(err) => log::error!(target: "app", "{err}"),
-    }
+    AsyncHandler::spawn(async move || {
+        match super::patch_verge(
+            IVerge {
+                enable_tun_mode: Some(!enable),
+                ..IVerge::default()
+            },
+            not_save_file.unwrap_or(false),
+        )
+        .await
+        {
+            Ok(_) => handle::Handle::refresh_verge(),
+            Err(err) => log::error!(target: "app", "{err}"),
+        }
+    });
 }
 
 /// Copy proxy environment variables to clipboard
-pub async fn copy_clash_env() {
+pub fn copy_clash_env() {
     // 从环境变量获取IP地址，如果没有则从配置中获取 proxy_host，默认为 127.0.0.1
-    let clash_verge_rev_ip = match env::var("CLASH_VERGE_REV_IP") {
-        Ok(ip) => ip,
-        Err(_) => Config::verge()
-            .await
-            .latest_ref()
+    let clash_verge_rev_ip = env::var("CLASH_VERGE_REV_IP").unwrap_or_else(|_| {
+        Config::verge()
+            .latest()
             .proxy_host
             .clone()
-            .unwrap_or_else(|| "127.0.0.1".to_string()),
-    };
+            .unwrap_or_else(|| "127.0.0.1".to_string())
+    });
 
-    let Some(app_handle) = handle::Handle::global().app_handle() else {
-        logging!(
-            error,
-            Type::System,
-            "Failed to get app handle for proxy operation"
-        );
-        return;
-    };
-    let port = {
-        Config::verge()
-            .await
-            .latest_ref()
-            .verge_mixed_port
-            .unwrap_or(7897)
-    };
-    let http_proxy = format!("http://{clash_verge_rev_ip}:{port}");
-    let socks5_proxy = format!("socks5://{clash_verge_rev_ip}:{port}");
+    let app_handle = handle::Handle::global().app_handle().unwrap();
+    let port = { Config::verge().latest().verge_mixed_port.unwrap_or(7897) };
+    let http_proxy = format!("http://{clash_verge_rev_ip}:{}", port);
+    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().latest().env_type.clone() };
     let env_type = match env_type {
         Some(env_type) => env_type,
         None => {

src-tauri/src/feat/window.rs

@@ -1,225 +1,133 @@
-use crate::utils::window_manager::WindowManager;
+#[cfg(target_os = "macos")]
+use crate::AppHandleManager;
 use crate::{
     config::Config,
-    core::{CoreManager, handle, sysopt},
-    ipc::IpcManager,
-    logging,
-    module::lightweight,
-    utils::logging::Type,
+    core::{handle, sysopt, CoreManager},
+    module::mihomo::MihomoManager,
+    utils::resolve,
 };
 
 /// Open or close the dashboard window
-pub async fn open_or_close_dashboard() {
-    open_or_close_dashboard_internal().await
+#[allow(dead_code)]
+pub fn open_or_close_dashboard() {
+    println!("Attempting to open/close dashboard");
+    log::info!(target: "app", "Attempting to open/close dashboard");
+
+    if let Some(window) = handle::Handle::global().get_window() {
+        println!("Found existing window");
+        log::info!(target: "app", "Found existing window");
+
+        // 如果窗口存在，则切换其显示状态
+        match window.is_visible() {
+            Ok(visible) => {
+                println!("Window visibility status: {}", visible);
+                log::info!(target: "app", "Window visibility status: {}", visible);
+
+                if visible {
+                    println!("Attempting to hide window");
+                    log::info!(target: "app", "Attempting to hide window");
+                    let _ = window.hide();
+                } else {
+                    println!("Attempting to show and focus window");
+                    log::info!(target: "app", "Attempting to show and focus window");
+                    if window.is_minimized().unwrap_or(false) {
+                        let _ = window.unminimize();
+                    }
+                    let _ = window.show();
+                    let _ = window.set_focus();
+                }
+            }
+            Err(e) => {
+                println!("Failed to get window visibility: {:?}", e);
+                log::error!(target: "app", "Failed to get window visibility: {:?}", e);
+            }
+        }
+    } else {
+        println!("No existing window found, creating new window");
+        log::info!(target: "app", "No existing window found, creating new window");
+        resolve::create_window(true);
+    }
 }
 
-/// Internal implementation for opening/closing 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:?}");
-}
-
-/// 异步优化的应用退出函数
-pub async fn quit() {
-    logging!(debug, Type::System, true, "启动退出流程");
+/// 优化的应用退出函数
+pub fn quit() {
+    log::debug!(target: "app", "启动退出流程");
 
     // 获取应用句柄并设置退出标志
-    let Some(app_handle) = handle::Handle::global().app_handle() else {
-        logging!(
-            error,
-            Type::System,
-            "Failed to get app handle for quit operation"
-        );
-        return;
-    };
+    let app_handle = handle::Handle::global().app_handle().unwrap();
     handle::Handle::global().set_is_exiting();
 
     // 优先关闭窗口，提供立即反馈
     if let Some(window) = handle::Handle::global().get_window() {
         let _ = window.hide();
-        log::info!(target: "app", "窗口已隐藏");
     }
 
-    // 使用异步任务处理资源清理，避免阻塞
-    logging!(info, Type::System, true, "开始异步清理资源");
-    let cleanup_result = clean_async().await;
-
-    logging!(
-        info,
-        Type::System,
-        true,
-        "资源清理完成，退出代码: {}",
-        if cleanup_result { 0 } else { 1 }
-    );
-    app_handle.exit(if cleanup_result { 0 } else { 1 });
-}
-
-async fn clean_async() -> bool {
-    use tokio::time::{Duration, timeout};
-
-    logging!(info, Type::System, true, "开始执行异步清理操作...");
-
-    // 1. 处理TUN模式
-    let tun_success = if Config::verge()
-        .await
-        .data_mut()
-        .enable_tun_mode
-        .unwrap_or(false)
-    {
-        let disable_tun = serde_json::json!({"tun": {"enable": false}});
-        match timeout(
-            Duration::from_secs(3),
-            IpcManager::global().patch_configs(disable_tun),
-        )
-        .await
-        {
-            Ok(Ok(_)) => {
-                log::info!(target: "app", "TUN模式已禁用");
-                tokio::time::sleep(Duration::from_millis(300)).await;
-                true
-            }
-            Ok(Err(e)) => {
-                log::warn!(target: "app", "禁用TUN模式失败: {e}");
-                false
-            }
-            Err(_) => {
-                log::warn!(target: "app", "禁用TUN模式超时");
-                false
-            }
-        }
-    } else {
-        true
-    };
-
-    // 2. 系统代理重置
-    let proxy_task = async {
-        match timeout(
-            Duration::from_secs(3),
-            sysopt::Sysopt::global().reset_sysproxy(),
-        )
-        .await
-        {
-            Ok(_) => {
-                log::info!(target: "app", "系统代理已重置");
-                true
-            }
-            Err(_) => {
-                log::warn!(target: "app", "重置系统代理超时");
-                false
-            }
-        }
-    };
-
-    // 3. 核心服务停止
-    let core_task = async {
-        match timeout(Duration::from_secs(3), CoreManager::global().stop_core()).await {
-            Ok(_) => {
-                log::info!(target: "app", "核心服务已停止");
-                true
-            }
-            Err(_) => {
-                log::warn!(target: "app", "停止核心服务超时");
-                false
-            }
-        }
-    };
-
-    // 4. DNS恢复（仅macOS）
-    #[cfg(target_os = "macos")]
-    let dns_task = async {
-        match timeout(
-            Duration::from_millis(1000),
-            crate::utils::resolve::dns::restore_public_dns(),
-        )
-        .await
-        {
-            Ok(_) => {
-                log::info!(target: "app", "DNS设置已恢复");
-                true
-            }
-            Err(_) => {
-                log::warn!(target: "app", "恢复DNS设置超时");
-                false
-            }
-        }
-    };
-
-    // 并行执行剩余清理任务
-    let (proxy_success, core_success) = tokio::join!(proxy_task, core_task);
-
-    #[cfg(target_os = "macos")]
-    let dns_success = dns_task.await;
-    #[cfg(not(target_os = "macos"))]
-    let dns_success = true;
-
-    let all_success = tun_success && proxy_success && core_success && dns_success;
-
-    logging!(
-        info,
-        Type::System,
-        true,
-        "异步关闭操作完成 - TUN: {}, 代理: {}, 核心: {}, DNS: {}, 总体: {}",
-        tun_success,
-        proxy_success,
-        core_success,
-        dns_success,
-        all_success
-    );
-
-    all_success
+    // 在单独线程中处理资源清理，避免阻塞主线程
+    std::thread::spawn(move || {
+        let cleanup_result = clean();
+        app_handle.exit(match cleanup_result {
+            true => 0,
+            false => 1,
+        });
+    });
 }
 
 pub fn clean() -> bool {
-    use crate::process::AsyncHandler;
-
-    let (tx, rx) = std::sync::mpsc::channel();
-
-    AsyncHandler::spawn(move || async move {
-        logging!(info, Type::System, true, "开始执行关闭操作...");
-
-        // 使用已有的异步清理函数
-        let cleanup_result = clean_async().await;
-
-        // 发送结果
-        let _ = tx.send(cleanup_result);
-    });
-
-    match rx.recv_timeout(std::time::Duration::from_secs(8)) {
-        Ok(result) => {
-            logging!(info, Type::System, true, "关闭操作完成，结果: {}", result);
-            result
-        }
-        Err(_) => {
-            logging!(
-                warn,
-                Type::System,
-                true,
-                "清理操作超时，返回成功状态避免阻塞"
-            );
+    use tokio::time::{timeout, Duration};
+    let rt = tokio::runtime::Runtime::new().unwrap();
+    let cleanup_result = rt.block_on(async {
+        // 1. 处理TUN模式
+        let tun_success = if Config::verge().data().enable_tun_mode.unwrap_or(false) {
+            let disable_tun = serde_json::json!({
+                "tun": {
+                    "enable": false
+                }
+            });
+            timeout(
+                Duration::from_secs(1),
+                MihomoManager::global().patch_configs(disable_tun),
+            )
+            .await
+            .is_ok()
+        } else {
             true
-        }
-    }
+        };
+
+        // 2. 顺序执行关键清理
+        let proxy_res = timeout(
+            Duration::from_secs(1),
+            sysopt::Sysopt::global().reset_sysproxy(),
+        )
+        .await;
+
+        let core_res = timeout(Duration::from_secs(1), CoreManager::global().stop_core()).await;
+
+        // 3. 平台特定清理
+        #[cfg(target_os = "macos")]
+        let _dns_res = timeout(Duration::from_millis(500), resolve::restore_public_dns()).await;
+
+        tun_success && proxy_res.is_ok() && core_res.is_ok()
+    });
+    cleanup_result
 }
 
 #[cfg(target_os = "macos")]
-pub async fn hide() {
+pub fn hide() {
     use crate::module::lightweight::add_light_weight_timer;
 
     let enable_auto_light_weight_mode = Config::verge()
-        .await
-        .data_mut()
+        .data()
         .enable_auto_light_weight_mode
         .unwrap_or(false);
 
     if enable_auto_light_weight_mode {
-        add_light_weight_timer().await;
+        add_light_weight_timer();
     }
 
-    if let Some(window) = handle::Handle::global().get_window()
-        && window.is_visible().unwrap_or(false)
-    {
-        let _ = window.hide();
+    if let Some(window) = handle::Handle::global().get_window() {
+        if window.is_visible().unwrap_or(false) {
+            let _ = window.hide();
+        }
     }
-    handle::Handle::global().set_activation_policy_accessory();
+    AppHandleManager::global().set_activation_policy_accessory();
 }

src-tauri/src/ipc/general.rs

@@ -1,370 +0,0 @@
-use std::time::Duration;
-
-use kode_bridge::{
-    ClientConfig, IpcHttpClient, LegacyResponse,
-    errors::{AnyError, AnyResult},
-};
-use percent_encoding::{AsciiSet, CONTROLS, utf8_percent_encode};
-
-use crate::{
-    logging, singleton_with_logging,
-    utils::{dirs::ipc_path, logging::Type},
-};
-
-// 定义用于URL路径的编码集合，只编码真正必要的字符
-const URL_PATH_ENCODE_SET: &AsciiSet = &CONTROLS
-    .add(b' ') // 空格
-    .add(b'/') // 斜杠
-    .add(b'?') // 问号
-    .add(b'#') // 井号
-    .add(b'&') // 和号
-    .add(b'%'); // 百分号
-
-// Helper function to create AnyError from string
-fn create_error(msg: impl Into<String>) -> AnyError {
-    Box::new(std::io::Error::other(msg.into()))
-}
-
-pub struct IpcManager {
-    client: IpcHttpClient,
-}
-
-impl IpcManager {
-    pub fn new() -> Self {
-        logging!(info, Type::Ipc, true, "Creating new IpcManager instance");
-        let ipc_path_buf = ipc_path().unwrap_or_else(|e| {
-            logging!(error, Type::Ipc, true, "Failed to get IPC path: {}", e);
-            std::path::PathBuf::from("/tmp/clash-verge-ipc") // fallback path
-        });
-        let ipc_path = ipc_path_buf.to_str().unwrap_or_default();
-        let config = ClientConfig {
-            default_timeout: Duration::from_secs(5),
-            enable_pooling: false,
-            max_retries: 4,
-            retry_delay: Duration::from_millis(125),
-            max_concurrent_requests: 16,
-            max_requests_per_second: Some(64.0),
-            ..Default::default()
-        };
-        #[allow(clippy::unwrap_used)]
-        let client = IpcHttpClient::with_config(ipc_path, config).unwrap();
-        Self { client }
-    }
-}
-
-impl IpcManager {
-    pub async fn request(
-        &self,
-        method: &str,
-        path: &str,
-        body: Option<&serde_json::Value>,
-    ) -> AnyResult<LegacyResponse> {
-        self.client.request(method, path, body).await
-    }
-}
-
-impl IpcManager {
-    pub async fn send_request(
-        &self,
-        method: &str,
-        path: &str,
-        body: Option<&serde_json::Value>,
-    ) -> AnyResult<serde_json::Value> {
-        let response = IpcManager::global().request(method, path, body).await?;
-        match method {
-            "GET" => Ok(response.json()?),
-            "PATCH" => {
-                if response.status == 204 {
-                    Ok(serde_json::json!({"code": 204}))
-                } else {
-                    Ok(response.json()?)
-                }
-            }
-            "PUT" | "DELETE" => {
-                if response.status == 204 {
-                    Ok(serde_json::json!({"code": 204}))
-                } else {
-                    match response.json() {
-                        Ok(json) => Ok(json),
-                        Err(_) => Ok(serde_json::json!({
-                            "code": response.status,
-                            "message": response.body,
-                            "error": "failed to parse response as JSON"
-                        })),
-                    }
-                }
-            }
-            _ => match response.json() {
-                Ok(json) => Ok(json),
-                Err(_) => Ok(serde_json::json!({
-                    "code": response.status,
-                    "message": response.body,
-                    "error": "failed to parse response as JSON"
-                })),
-            },
-        }
-    }
-
-    // 基础代理信息获取
-    pub async fn get_proxies(&self) -> AnyResult<serde_json::Value> {
-        let url = "/proxies";
-        self.send_request("GET", url, None).await
-    }
-
-    // 代理提供者信息获取
-    pub async fn get_providers_proxies(&self) -> AnyResult<serde_json::Value> {
-        let url = "/providers/proxies";
-        self.send_request("GET", url, None).await
-    }
-
-    // 连接管理
-    pub async fn get_connections(&self) -> AnyResult<serde_json::Value> {
-        let url = "/connections";
-        self.send_request("GET", url, None).await
-    }
-
-    pub async fn delete_connection(&self, id: &str) -> AnyResult<()> {
-        let encoded_id = utf8_percent_encode(id, URL_PATH_ENCODE_SET).to_string();
-        let url = format!("/connections/{encoded_id}");
-        let response = self.send_request("DELETE", &url, None).await?;
-        if response["code"] == 204 {
-            Ok(())
-        } else {
-            Err(create_error(
-                response["message"].as_str().unwrap_or("unknown error"),
-            ))
-        }
-    }
-
-    pub async fn close_all_connections(&self) -> AnyResult<()> {
-        let url = "/connections";
-        let response = self.send_request("DELETE", url, None).await?;
-        if response["code"] == 204 {
-            Ok(())
-        } else {
-            Err(create_error(
-                response["message"]
-                    .as_str()
-                    .unwrap_or("unknown error")
-                    .to_owned(),
-            ))
-        }
-    }
-}
-
-impl IpcManager {
-    #[allow(dead_code)]
-    pub async fn is_mihomo_running(&self) -> AnyResult<()> {
-        let url = "/version";
-        let _response = self.send_request("GET", url, None).await?;
-        Ok(())
-    }
-
-    pub async fn put_configs_force(&self, clash_config_path: &str) -> AnyResult<()> {
-        let url = "/configs?force=true";
-        let payload = serde_json::json!({
-            "path": clash_config_path,
-        });
-        let _response = self.send_request("PUT", url, Some(&payload)).await?;
-        Ok(())
-    }
-
-    pub async fn patch_configs(&self, config: serde_json::Value) -> AnyResult<()> {
-        let url = "/configs";
-        let response = self.send_request("PATCH", url, Some(&config)).await?;
-        if response["code"] == 204 {
-            Ok(())
-        } else {
-            Err(create_error(
-                response["message"]
-                    .as_str()
-                    .unwrap_or("unknown error")
-                    .to_owned(),
-            ))
-        }
-    }
-
-    pub async fn test_proxy_delay(
-        &self,
-        name: &str,
-        test_url: Option<String>,
-        timeout: i32,
-    ) -> AnyResult<serde_json::Value> {
-        let test_url =
-            test_url.unwrap_or_else(|| "https://cp.cloudflare.com/generate_204".to_string());
-
-        let encoded_name = utf8_percent_encode(name, URL_PATH_ENCODE_SET).to_string();
-        // 测速URL不再编码，直接传递
-        let url = format!("/proxies/{encoded_name}/delay?url={test_url}&timeout={timeout}");
-
-        self.send_request("GET", &url, None).await
-    }
-
-    // 版本和配置相关
-    pub async fn get_version(&self) -> AnyResult<serde_json::Value> {
-        let url = "/version";
-        self.send_request("GET", url, None).await
-    }
-
-    pub async fn get_config(&self) -> AnyResult<serde_json::Value> {
-        let url = "/configs";
-        self.send_request("GET", url, None).await
-    }
-
-    pub async fn update_geo_data(&self) -> AnyResult<()> {
-        let url = "/configs/geo";
-        let response = self.send_request("POST", url, None).await?;
-        if response["code"] == 204 {
-            Ok(())
-        } else {
-            Err(create_error(
-                response["message"]
-                    .as_str()
-                    .unwrap_or("unknown error")
-                    .to_string(),
-            ))
-        }
-    }
-
-    pub async fn upgrade_core(&self) -> AnyResult<()> {
-        let url = "/upgrade";
-        let response = self.send_request("POST", url, None).await?;
-        if response["code"] == 204 {
-            Ok(())
-        } else {
-            Err(create_error(
-                response["message"]
-                    .as_str()
-                    .unwrap_or("unknown error")
-                    .to_string(),
-            ))
-        }
-    }
-
-    // 规则相关
-    pub async fn get_rules(&self) -> AnyResult<serde_json::Value> {
-        let url = "/rules";
-        self.send_request("GET", url, None).await
-    }
-
-    pub async fn get_rule_providers(&self) -> AnyResult<serde_json::Value> {
-        let url = "/providers/rules";
-        self.send_request("GET", url, None).await
-    }
-
-    pub async fn update_rule_provider(&self, name: &str) -> AnyResult<()> {
-        let encoded_name = utf8_percent_encode(name, URL_PATH_ENCODE_SET).to_string();
-        let url = format!("/providers/rules/{encoded_name}");
-        let response = self.send_request("PUT", &url, None).await?;
-        if response["code"] == 204 {
-            Ok(())
-        } else {
-            Err(create_error(
-                response["message"]
-                    .as_str()
-                    .unwrap_or("unknown error")
-                    .to_string(),
-            ))
-        }
-    }
-
-    // 代理相关
-    pub async fn update_proxy(&self, group: &str, proxy: &str) -> AnyResult<()> {
-        // 使用 percent-encoding 进行正确的 URL 编码
-        let encoded_group = utf8_percent_encode(group, URL_PATH_ENCODE_SET).to_string();
-        let url = format!("/proxies/{encoded_group}");
-        let payload = serde_json::json!({
-            "name": proxy
-        });
-        match self.send_request("PUT", &url, Some(&payload)).await {
-            Ok(_) => Ok(()),
-            Err(e) => {
-                logging!(
-                    error,
-                    crate::utils::logging::Type::Ipc,
-                    true,
-                    "IPC: updateProxy encountered error: {} (ignored, always returning true)",
-                    e
-                );
-                Ok(())
-            }
-        }
-    }
-
-    pub async fn proxy_provider_health_check(&self, name: &str) -> AnyResult<()> {
-        let encoded_name = utf8_percent_encode(name, URL_PATH_ENCODE_SET).to_string();
-        let url = format!("/providers/proxies/{encoded_name}/healthcheck");
-        let response = self.send_request("GET", &url, None).await?;
-        if response["code"] == 204 {
-            Ok(())
-        } else {
-            Err(create_error(
-                response["message"]
-                    .as_str()
-                    .unwrap_or("unknown error")
-                    .to_string(),
-            ))
-        }
-    }
-
-    pub async fn update_proxy_provider(&self, name: &str) -> AnyResult<()> {
-        let encoded_name = utf8_percent_encode(name, URL_PATH_ENCODE_SET).to_string();
-        let url = format!("/providers/proxies/{encoded_name}");
-        let response = self.send_request("PUT", &url, None).await?;
-        if response["code"] == 204 {
-            Ok(())
-        } else {
-            Err(create_error(
-                response["message"]
-                    .as_str()
-                    .unwrap_or("unknown error")
-                    .to_string(),
-            ))
-        }
-    }
-
-    // 延迟测试相关
-    pub async fn get_group_proxy_delays(
-        &self,
-        group_name: &str,
-        url: Option<String>,
-        timeout: i32,
-    ) -> AnyResult<serde_json::Value> {
-        let test_url = url.unwrap_or_else(|| "https://cp.cloudflare.com/generate_204".to_string());
-
-        let encoded_group_name = utf8_percent_encode(group_name, URL_PATH_ENCODE_SET).to_string();
-        // 测速URL不再编码，直接传递
-        let url = format!("/group/{encoded_group_name}/delay?url={test_url}&timeout={timeout}");
-
-        self.send_request("GET", &url, None).await
-    }
-
-    // 调试相关
-    pub async fn is_debug_enabled(&self) -> AnyResult<bool> {
-        let url = "/debug/pprof";
-        match self.send_request("GET", url, None).await {
-            Ok(_) => Ok(true),
-            Err(_) => Ok(false),
-        }
-    }
-
-    pub async fn gc(&self) -> AnyResult<()> {
-        let url = "/debug/gc";
-        let response = self.send_request("PUT", url, None).await?;
-        if response["code"] == 204 {
-            Ok(())
-        } else {
-            Err(create_error(
-                response["message"]
-                    .as_str()
-                    .unwrap_or("unknown error")
-                    .to_string(),
-            ))
-        }
-    }
-
-    // 日志相关功能已迁移到 logs.rs 模块，使用流式处理
-}
-
-// Use singleton macro with logging
-singleton_with_logging!(IpcManager, INSTANCE, "IpcManager");