chore: update release log & fix workflow2

refactor: restrict AsyncHandler usage to Windows platform only
refactor: replace tokio::task::spawn_blocking with AsyncHandler::spawn_blocking for improved task management
2026-10-15 13:50:47 +08:00 · 2025-08-22 16:30:07 +08:00 · 2025-08-22 04:18:21 +08:00 · 2025-08-22 04:05:35 +08:00 · 2025-08-22 03:41:14 +08:00 · 2025-08-22 03:16:59 +08:00
254 changed files with 30476 additions and 11195 deletions
@@ -0,0 +1,101 @@
+{
+  "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"
+}
@@ -0,0 +1 @@
+github: clash-verge-rev
@@ -9,13 +9,16 @@ 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
@@ -34,6 +37,7 @@ 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
@@ -42,13 +46,13 @@ body:
      description: 请提供复现问题的步骤 / Steps to reproduce the behavior
    validations:
      required: true
-  - type: dropdown
+  - type: checkboxes
    attributes:
      label: 操作系统 / OS
      options:
-        - Windows
-        - Linux
-        - MacOS
+        - label: Windows
+        - label: Linux
+        - label: MacOS
    validations:
      required: true
  - type: input
@@ -61,5 +65,9 @@ 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
@@ -0,0 +1,58 @@
+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
@@ -1,123 +1,176 @@
 name: Alpha Build

 on:
+  # 因为 alpha 不再负责频繁构建，且需要相对于 autobuild 更稳定使用环境
+  # 所以不再使用 workflow_dispatch 触发
+  # 应当通过 git tag 来触发构建
+  # TODO 手动控制版本号
  workflow_dispatch:
-  schedule:
-    # UTC+8 0,6,12,18
-    - cron: "0 16,22,4,10 * * *"
+    # 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*"
 permissions: write-all
 env:
+  TAG_NAME: alpha
+  TAG_CHANNEL: Alpha
  CARGO_INCREMENTAL: 0
  RUST_BACKTRACE: short
 concurrency:
-  # only allow per workflow per commit (and not pr) to run at a time
  group: "${{ github.workflow }} - ${{ github.head_ref || github.ref }}"
-  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}

 jobs:
-  check_commit:
+  check_alpha_tag:
+    name: Check Alpha Tag package.json Version Consistency
    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
+      - name: Check tag and package.json version
+        id: check_tag
        run: |
-          # For manual workflow_dispatch, always run
-          if [ "${{ github.event_name }}" == "workflow_dispatch" ]; then
-            echo "should_run=true" >> $GITHUB_OUTPUT
-            exit 0
+          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
-
-          # Store current version from package.json
-          CURRENT_VERSION=$(cat package.json | jq -r '.version')
-          echo "Current version: $CURRENT_VERSION"
-
-          # Get the previous commit's package.json version
-          git checkout HEAD~1 package.json
-          PREVIOUS_VERSION=$(cat package.json | jq -r '.version')
-          echo "Previous version: $PREVIOUS_VERSION"
-
-          # Reset back to current commit
-          git checkout HEAD package.json
-
-          # Check if version changed
-          if [ "$CURRENT_VERSION" != "$PREVIOUS_VERSION" ]; then
-            echo "Version changed from $PREVIOUS_VERSION to $CURRENT_VERSION"
-            echo "should_run=true" >> $GITHUB_OUTPUT
-            exit 0
+          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
-
-          # Check if src or src-tauri directories changed
-          CURRENT_SRC_HASH=$(git rev-parse HEAD:src)
-          PREVIOUS_SRC_HASH=$(git rev-parse HEAD~1:src 2>/dev/null || echo "")
-          CURRENT_TAURI_HASH=$(git rev-parse HEAD:src-tauri 2>/dev/null || echo "")
-          PREVIOUS_TAURI_HASH=$(git rev-parse HEAD~1:src-tauri 2>/dev/null || echo "")
-
-          echo "Current src hash: $CURRENT_SRC_HASH"
-          echo "Previous src hash: $PREVIOUS_SRC_HASH"
-          echo "Current tauri hash: $CURRENT_TAURI_HASH"
-          echo "Previous tauri hash: $PREVIOUS_TAURI_HASH"
-
-          if [ "$CURRENT_SRC_HASH" != "$PREVIOUS_SRC_HASH" ] || [ "$CURRENT_TAURI_HASH" != "$PREVIOUS_TAURI_HASH" ]; then
-            echo "Source directories changed"
-            echo "should_run=true" >> $GITHUB_OUTPUT
-          else
-            echo "Version and source directories unchanged"
-            echo "should_run=false" >> $GITHUB_OUTPUT
+          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:
-    needs: check_commit
-    if: ${{ needs.check_commit.outputs.should_run == 'true' }}
+    name: Delete Old Alpha Release Assets and Tags
+    needs: check_alpha_tag
    runs-on: ubuntu-latest
    steps:
-      - name: Delete Old Alpha Release Assets
+      - name: Delete Old Alpha Tags Except Latest
        uses: actions/github-script@v7
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
          script: |
-            const releaseTag = 'alpha';
+            const tagPattern = /-alpha.*/; // 匹配带有 -alpha 的 tag
+            const owner = context.repo.owner;
+            const repo = context.repo.repo;

            try {
-              // Get the release by tag name
-              const { data: release } = await github.rest.repos.getReleaseByTag({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                tag: releaseTag
+              // 获取所有 tag
+              const { data: tags } = await github.rest.repos.listTags({
+                owner,
+                repo,
+                per_page: 100 // 调整 per_page 以获取更多 tag
              });

-              console.log(`Found release with ID: ${release.id}`);
+              // 过滤出包含 -alpha 的 tag
+              const alphaTags = (await Promise.all(
+                tags
+                  .filter(tag => tagPattern.test(tag.name))
+                  .map(async tag => {
+                    // 获取每个 tag 的 commit 信息以获得日期
+                    const { data: commit } = await github.rest.repos.getCommit({
+                      owner,
+                      repo,
+                      ref: tag.commit.sha
+                    });
+                    return {
+                      ...tag,
+                      commitDate: commit.committer && commit.committer.date ? commit.committer.date : commit.commit.author.date
+                    };
+                  })
+              )).sort((a, b) => {
+                // 按 commit 日期降序排序（最新的在前面）
+                return new Date(b.commitDate) - new Date(a.commitDate);
+              });

-              // Delete each asset
-              if (release.assets && release.assets.length > 0) {
-                console.log(`Deleting ${release.assets.length} assets`);
+              console.log(`Found ${alphaTags.length} alpha tags`);

-                for (const asset of release.assets) {
-                  console.log(`Deleting asset: ${asset.name} (${asset.id})`);
-                  await github.rest.repos.deleteReleaseAsset({
-                    owner: context.repo.owner,
-                    repo: context.repo.repo,
-                    asset_id: asset.id
+              if (alphaTags.length === 0) {
+                console.log('No alpha tags found');
+                return;
+              }
+
+              // 保留最新的 tag
+              const latestTag = alphaTags[0];
+              console.log(`Keeping latest alpha tag: ${latestTag.name}`);
+
+              // 处理其他旧的 alpha tag
+              for (const tag of alphaTags.slice(1)) {
+                console.log(`Processing tag: ${tag.name}`);
+
+                // 获取与 tag 关联的 release
+                try {
+                  const { data: release } = await github.rest.repos.getReleaseByTag({
+                    owner,
+                    repo,
+                    tag: tag.name
                  });
-                }

-                console.log('All assets deleted successfully');
-              } else {
-                console.log('No assets found to delete');
+                  // 删除 release 下的所有资产
+                  if (release.assets && release.assets.length > 0) {
+                    console.log(`Deleting ${release.assets.length} assets for release ${tag.name}`);
+                    for (const asset of release.assets) {
+                      console.log(`Deleting asset: ${asset.name} (${asset.id})`);
+                      await github.rest.repos.deleteReleaseAsset({
+                        owner,
+                        repo,
+                        asset_id: asset.id
+                      });
+                    }
+                  }
+
+                  // 删除 release
+                  console.log(`Deleting release for tag: ${tag.name}`);
+                  await github.rest.repos.deleteRelease({
+                    owner,
+                    repo,
+                    release_id: release.id
+                  });
+
+                  // 删除 tag
+                  console.log(`Deleting tag: ${tag.name}`);
+                  await github.rest.git.deleteRef({
+                    owner,
+                    repo,
+                    ref: `tags/${tag.name}`
+                  });
+
+                } catch (error) {
+                  if (error.status === 404) {
+                    console.log(`No release found for tag ${tag.name}, deleting tag directly`);
+                    await github.rest.git.deleteRef({
+                      owner,
+                      repo,
+                      ref: `tags/${tag.name}`
+                    });
+                  } else {
+                    console.error(`Error processing tag ${tag.name}:`, error);
+                    throw error;
+                  }
+                }
              }
+
+              console.log('Old alpha tags and releases deleted successfully');
            } catch (error) {
-              if (error.status === 404) {
-                console.log('Release not found, nothing to delete');
-              } else {
-                console.error('Error:', error);
-                throw error;
-              }
+              console.error('Error:', error);
+              throw error;
            }

  update_tag:
@@ -128,22 +181,18 @@ jobs:
      - name: Checkout repository
        uses: actions/checkout@v4

-      - name: Fetch Alpha update logs
-        id: fetch_alpha_logs
+      - name: Fetch UPDATE logs
+        id: fetch_update_logs
        run: |
-          # Check if UPDATELOG.md exists
          if [ -f "UPDATELOG.md" ]; then
-            # Extract the section starting with ## and containing -alpha until the next ## or end of file
-            # ALPHA_LOGS=$(awk '/^## .*-alpha/{flag=1; print; next} /^## /{flag=0} flag' UPDATELOG.md)
-            ALPHA_LOGS=$(awk '/^## v/{if(flag) exit; flag=1} flag' UPDATELOG.md)
-
-            if [ -n "$ALPHA_LOGS" ]; then
-              echo "Found alpha update logs"
-              echo "ALPHA_LOGS<<EOF" >> $GITHUB_ENV
-              echo "$ALPHA_LOGS" >> $GITHUB_ENV
+            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 alpha sections found in UPDATELOG.md"
+              echo "No update sections found in UPDATELOG.md"
            fi
          else
            echo "UPDATELOG.md file not found"
@@ -156,17 +205,15 @@ jobs:
        shell: bash

      - run: |
-          # 检查 ALPHA_LOGS 是否存在，如果不存在则使用默认消息
-          if [ -z "$ALPHA_LOGS" ]; then
-            echo "No alpha logs found, using default message"
-            ALPHA_LOGS="More new features are now supported. Check for detailed changelog soon."
+          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 alpha logs"
+            echo "Using found update logs"
          fi

-          # 生成 release.txt 文件
          cat > release.txt << EOF
-          $ALPHA_LOGS
+          $UPDATE_LOGS

          ## 我应该下载哪个版本？

@@ -189,7 +236,6 @@ jobs:
          - arm64架构: arm64_fixed_webview2-setup.exe

          ### FAQ
-
          - [常见问题](https://clash-verge-rev.github.io/faq/windows.html)

          ### 稳定机场VPN推荐
@@ -201,14 +247,15 @@ jobs:
      - name: Upload Release
        uses: softprops/action-gh-release@v2
        with:
-          tag_name: alpha
-          name: "Clash Verge Rev Alpha"
+          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

-  alpha:
+  alpha-x86-windows-macos-linux:
+    name: Alpha x86 Windows, MacOS and Linux
    needs: update_tag
    strategy:
      fail-fast: false
@@ -224,7 +271,6 @@ jobs:
            target: x86_64-apple-darwin
          - os: ubuntu-22.04
            target: x86_64-unknown-linux-gnu
-
    runs-on: ${{ matrix.os }}
    steps:
      - name: Checkout Repository
@@ -240,8 +286,7 @@ jobs:
        uses: Swatinem/rust-cache@v2
        with:
          workspaces: src-tauri
-          cache-all-crates: true
-          cache-on-failure: true
+          save-if: false

      - name: Install dependencies (ubuntu only)
        if: matrix.os == 'ubuntu-22.04'
@@ -262,10 +307,10 @@ jobs:
      - name: Pnpm install and check
        run: |
          pnpm i
-          pnpm check ${{ matrix.target }}
+          pnpm run prebuild ${{ matrix.target }}

-      - name: Release Alpha Version
-        run: pnpm release-alpha-version
+      # - name: Release ${{ env.TAG_CHANNEL }} Version
+      #   run: pnpm release-version ${{ env.TAG_NAME }}

      - name: Tauri build
        uses: tauri-apps/tauri-action@v0
@@ -281,15 +326,16 @@ jobs:
          APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
        with:
-          tagName: alpha
-          releaseName: "Clash Verge Rev Alpha"
+          tagName: ${{ env.TAG_NAME }}
+          releaseName: "Clash Verge Rev ${{ env.TAG_CHANNEL }}"
          releaseBody: "More new features are now supported."
          releaseDraft: false
          prerelease: true
          tauriScript: pnpm
          args: --target ${{ matrix.target }}

-  alpha-for-linux-arm:
+  alpha-arm-linux:
+    name: Alpha ARM Linux
    needs: update_tag
    strategy:
      fail-fast: false
@@ -316,7 +362,7 @@ jobs:
        uses: Swatinem/rust-cache@v2
        with:
          workspaces: src-tauri
-          cache-all-crates: true
+          save-if: false

      - name: Install Node
        uses: actions/setup-node@v4
@@ -331,13 +377,13 @@ jobs:
      - name: Pnpm install and check
        run: |
          pnpm i
-          pnpm check ${{ matrix.target }}
+          pnpm run prebuild ${{ matrix.target }}

-      - name: Release Alpha Version
-        run: pnpm release-alpha-version
+      # - name: Release ${{ env.TAG_CHANNEL }} Version
+      #   run: pnpm release-version ${{ env.TAG_NAME }}

-      - name: "Setup for linux"
-        run: |-
+      - name: Setup for linux
+        run: |
          sudo ls -lR /etc/apt/

          cat > /tmp/sources.list << EOF
@@ -356,9 +402,14 @@ jobs:
          sudo mv /tmp/sources.list /etc/apt/sources.list

          sudo dpkg --add-architecture ${{ matrix.arch }}
-          sudo apt update
+          sudo apt-get update -y
+          sudo apt-get -f install -y

-          sudo apt install -y \
+          sudo apt-get install -y \
+            linux-libc-dev:${{ matrix.arch }} \
+            libc6-dev:${{ matrix.arch }}
+
+          sudo apt-get install -y \
            libxslt1.1:${{ matrix.arch }} \
            libwebkit2gtk-4.1-dev:${{ matrix.arch }} \
            libayatana-appindicator3-dev:${{ matrix.arch }} \
@@ -366,14 +417,14 @@ jobs:
            patchelf:${{ matrix.arch }} \
            librsvg2-dev:${{ matrix.arch }}

-      - name: "Install aarch64 tools"
+      - name: Install aarch64 tools
        if: matrix.target == 'aarch64-unknown-linux-gnu'
        run: |
          sudo apt install -y \
            gcc-aarch64-linux-gnu \
            g++-aarch64-linux-gnu

-      - name: "Install armv7 tools"
+      - name: Install armv7 tools
        if: matrix.target == 'armv7-unknown-linux-gnueabihf'
        run: |
          sudo apt install -y \
@@ -406,15 +457,16 @@ jobs:
      - name: Upload Release
        uses: softprops/action-gh-release@v2
        with:
-          tag_name: alpha
-          name: "Clash Verge Rev Alpha"
+          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/deb/*.deb
            src-tauri/target/${{ matrix.target }}/release/bundle/rpm/*.rpm

-  alpha-for-fixed-webview2:
+  alpha-x86-arm-windows_webview2:
+    name: Alpha x86 and ARM Windows with WebView2
    needs: update_tag
    strategy:
      fail-fast: false
@@ -438,8 +490,7 @@ jobs:
        uses: Swatinem/rust-cache@v2
        with:
          workspaces: src-tauri
-          cache-all-crates: true
-          cache-on-failure: true
+          save-if: false

      - name: Install Node
        uses: actions/setup-node@v4
@@ -454,10 +505,10 @@ jobs:
      - name: Pnpm install and check
        run: |
          pnpm i
-          pnpm check ${{ matrix.target }}
+          pnpm run prebuild ${{ matrix.target }}

-      - name: Release Alpha Version
-        run: pnpm release-alpha-version
+      # - name: Release ${{ env.TAG_CHANNEL }} Version
+      #   run: pnpm release-version ${{ env.TAG_NAME }}

      - name: Download WebView2 Runtime
        run: |
@@ -501,13 +552,13 @@ jobs:
      - name: Upload Release
        uses: softprops/action-gh-release@v2
        with:
-          tag_name: alpha
-          name: "Clash Verge Rev Alpha"
+          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 }} --alpha
+        run: pnpm portable-fixed-webview2 ${{ matrix.target }} --${{ env.TAG_NAME }}
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -0,0 +1,133 @@
+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 }}"
@@ -0,0 +1,561 @@
+name: Auto Build
+
+on:
+  workflow_dispatch:
+  schedule:
+    # UTC+8 0,6,12,18
+    - cron: "0 16,22,4,10 * * *"
+permissions: write-all
+env:
+  TAG_NAME: autobuild
+  TAG_CHANNEL: AutoBuild
+  CARGO_INCREMENTAL: 0
+  RUST_BACKTRACE: short
+concurrency:
+  group: "${{ github.workflow }} - ${{ github.head_ref || github.ref }}"
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+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' }}
+
+  update_tag:
+    name: Update tag
+    runs-on: ubuntu-latest
+    needs: check_commit
+    if: ${{ needs.check_commit.outputs.should_run == 'true' }}
+    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
+
+      - 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/autobuild" >> $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 }}_aarch64.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: Upload Release
+        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 }}
+          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: 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' }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-latest
+            target: x86_64-pc-windows-msvc
+          - os: windows-latest
+            target: aarch64-pc-windows-msvc
+          - os: macos-latest
+            target: aarch64-apple-darwin
+          - os: macos-latest
+            target: x86_64-apple-darwin
+          - os: ubuntu-22.04
+            target: x86_64-unknown-linux-gnu
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      - name: Install Rust Stable
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Add Rust Target
+        run: rustup target add ${{ matrix.target }}
+
+      - name: Rust Cache
+        uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: src-tauri
+          cache-all-crates: true
+          save-if: ${{ github.ref == 'refs/heads/dev' }}
+          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
+
+      - 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 }}
+
+      - name: Release ${{ env.TAG_CHANNEL }} Version
+        run: pnpm release-version autobuild-latest
+
+      - name: Tauri build for Windows-macOS-Linux
+        uses: tauri-apps/tauri-action@v0
+        env:
+          NODE_OPTIONS: "--max_old_space_size=4096"
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
+          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
+          APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_SIGNING_IDENTITY }}
+          APPLE_ID: ${{ secrets.APPLE_ID }}
+          APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
+          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
+        with:
+          tagName: ${{ env.TAG_NAME }}
+          releaseName: "Clash Verge Rev ${{ env.TAG_CHANNEL }}"
+          releaseBody: "More new features are now supported."
+          releaseDraft: false
+          prerelease: true
+          tauriScript: pnpm
+          args: --target ${{ matrix.target }}
+          includeUpdaterJson: true
+
+  autobuild-arm-linux:
+    name: Autobuild ARM Linux
+    needs: [check_commit, update_tag]
+    if: ${{ needs.check_commit.outputs.should_run == 'true' }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-22.04
+            target: aarch64-unknown-linux-gnu
+            arch: arm64
+          - os: ubuntu-22.04
+            target: armv7-unknown-linux-gnueabihf
+            arch: armhf
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      - name: Install Rust Stable
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Add Rust Target
+        run: rustup target add ${{ matrix.target }}
+
+      - name: Rust Cache
+        uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: src-tauri
+          cache-all-crates: true
+          save-if: ${{ github.ref == 'refs/heads/dev' }}
+          shared-key: autobuild-shared
+
+      - 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 }}
+
+      - name: Release ${{ env.TAG_CHANNEL }} Version
+        run: pnpm release-version autobuild-latest
+
+      - name: Setup for linux
+        run: |
+          sudo ls -lR /etc/apt/
+
+          cat > /tmp/sources.list << EOF
+          deb [arch=amd64,i386] http://archive.ubuntu.com/ubuntu jammy main multiverse universe restricted
+          deb [arch=amd64,i386] http://archive.ubuntu.com/ubuntu jammy-security main multiverse universe restricted
+          deb [arch=amd64,i386] http://archive.ubuntu.com/ubuntu jammy-updates main multiverse universe restricted
+          deb [arch=amd64,i386] http://archive.ubuntu.com/ubuntu jammy-backports main multiverse universe restricted
+
+          deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy main multiverse universe restricted
+          deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy-security main multiverse universe restricted
+          deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy-updates main multiverse universe restricted
+          deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy-backports main multiverse universe restricted
+          EOF
+
+          sudo mv /etc/apt/sources.list /etc/apt/sources.list.default
+          sudo mv /tmp/sources.list /etc/apt/sources.list
+
+          sudo dpkg --add-architecture ${{ matrix.arch }}
+          sudo apt-get update -y
+          sudo apt-get -f install -y
+
+          sudo apt-get install -y \
+            linux-libc-dev:${{ matrix.arch }} \
+            libc6-dev:${{ matrix.arch }}
+
+          sudo apt-get install -y \
+            libxslt1.1:${{ matrix.arch }} \
+            libwebkit2gtk-4.1-dev:${{ matrix.arch }} \
+            libayatana-appindicator3-dev:${{ matrix.arch }} \
+            libssl-dev:${{ matrix.arch }} \
+            patchelf:${{ matrix.arch }} \
+            librsvg2-dev:${{ matrix.arch }}
+
+      - name: Install aarch64 tools
+        if: matrix.target == 'aarch64-unknown-linux-gnu'
+        run: |
+          sudo apt install -y \
+            gcc-aarch64-linux-gnu \
+            g++-aarch64-linux-gnu
+
+      - name: Install armv7 tools
+        if: matrix.target == 'armv7-unknown-linux-gnueabihf'
+        run: |
+          sudo apt install -y \
+            gcc-arm-linux-gnueabihf \
+            g++-arm-linux-gnueabihf
+
+      - name: Tauri Build for Linux
+        run: |
+          export PKG_CONFIG_ALLOW_CROSS=1
+          if [ "${{ matrix.target }}" == "aarch64-unknown-linux-gnu" ]; then
+            export PKG_CONFIG_PATH=/usr/lib/aarch64-linux-gnu/pkgconfig/:$PKG_CONFIG_PATH
+            export PKG_CONFIG_SYSROOT_DIR=/usr/aarch64-linux-gnu/
+          elif [ "${{ matrix.target }}" == "armv7-unknown-linux-gnueabihf" ]; then
+            export PKG_CONFIG_PATH=/usr/lib/arm-linux-gnueabihf/pkgconfig/:$PKG_CONFIG_PATH
+            export PKG_CONFIG_SYSROOT_DIR=/usr/arm-linux-gnueabihf/
+          fi
+          pnpm build --target ${{ matrix.target }}
+        env:
+          NODE_OPTIONS: "--max_old_space_size=4096"
+          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+
+      - name: Get Version
+        run: |
+          sudo apt-get update
+          sudo apt-get install jq
+          echo "VERSION=$(cat package.json | jq '.version' | tr -d '"')" >> $GITHUB_ENV
+          echo "BUILDTIME=$(TZ=Asia/Shanghai date)" >> $GITHUB_ENV
+
+      - name: Upload Release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ env.TAG_NAME }}
+          name: "Clash Verge Rev ${{ env.TAG_CHANNEL }}"
+          prerelease: true
+          token: ${{ secrets.GITHUB_TOKEN }}
+          files: |
+            src-tauri/target/${{ matrix.target }}/release/bundle/deb/*.deb
+            src-tauri/target/${{ matrix.target }}/release/bundle/rpm/*.rpm
+
+  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' }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-latest
+            target: x86_64-pc-windows-msvc
+            arch: x64
+          - os: windows-latest
+            target: aarch64-pc-windows-msvc
+            arch: arm64
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      - name: Add Rust Target
+        run: rustup target add ${{ matrix.target }}
+
+      - name: Rust Cache
+        uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: src-tauri
+          cache-all-crates: true
+          save-if: ${{ github.ref == 'refs/heads/dev' }}
+          shared-key: autobuild-shared
+
+      - 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 }}
+
+      - name: Release ${{ env.TAG_CHANNEL }} Version
+        run: pnpm release-version autobuild-latest
+
+      - name: Download WebView2 Runtime
+        run: |
+          invoke-webrequest -uri https://github.com/westinyang/WebView2RuntimeArchive/releases/download/109.0.1518.78/Microsoft.WebView2.FixedVersionRuntime.109.0.1518.78.${{ matrix.arch }}.cab -outfile Microsoft.WebView2.FixedVersionRuntime.109.0.1518.78.${{ matrix.arch }}.cab
+          Expand .\Microsoft.WebView2.FixedVersionRuntime.109.0.1518.78.${{ matrix.arch }}.cab -F:* ./src-tauri
+          Remove-Item .\src-tauri\tauri.windows.conf.json
+          Rename-Item .\src-tauri\webview2.${{ matrix.arch }}.json tauri.windows.conf.json
+
+      - name: Tauri build for Windows
+        id: build
+        uses: tauri-apps/tauri-action@v0
+        env:
+          NODE_OPTIONS: "--max_old_space_size=4096"
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+        with:
+          tauriScript: pnpm
+          args: --target ${{ matrix.target }}
+          includeUpdaterJson: true
+
+      - name: Rename
+        run: |
+          $files = Get-ChildItem ".\src-tauri\target\${{ matrix.target }}\release\bundle\nsis\*-setup.exe"
+          foreach ($file in $files) {
+            $newName = $file.Name -replace "-setup\.exe$", "_fixed_webview2-setup.exe"
+            Rename-Item $file.FullName $newName
+          }
+
+          $files = Get-ChildItem ".\src-tauri\target\${{ matrix.target }}\release\bundle\nsis\*.nsis.zip"
+          foreach ($file in $files) {
+            $newName = $file.Name -replace "-setup\.nsis\.zip$", "_fixed_webview2-setup.nsis.zip"
+            Rename-Item $file.FullName $newName
+          }
+
+          $files = Get-ChildItem ".\src-tauri\target\${{ matrix.target }}\release\bundle\nsis\*-setup.exe.sig"
+          foreach ($file in $files) {
+            $newName = $file.Name -replace "-setup\.exe\.sig$", "_fixed_webview2-setup.exe.sig"
+            Rename-Item $file.FullName $newName
+          }
+
+      - name: Upload Release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ 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.TAG_NAME }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  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,
+      ]
+    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 }}_aarch64.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 }}
@@ -0,0 +1,159 @@
+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=$(date +%m)
+          DAY=$(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
@@ -0,0 +1,220 @@
+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=$(date +%m)
+          DAY=$(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
@@ -0,0 +1,66 @@
+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 Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          run_install: false
+
+      - name: Pnpm install and check
+        run: |
+          pnpm i
+          pnpm run prebuild ${{ matrix.target }}
+
+      - 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
@@ -0,0 +1,64 @@
+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
@@ -2,12 +2,25 @@ 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
+
 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' }}

@@ -20,47 +33,66 @@ 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
-          - os: macos-latest
-            target: x86_64-apple-darwin
-            bundle: dmg
+            id: macos-aarch64
+            input: run_macos_aarch64

    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
-          cache-on-failure: true
-
-      - name: Install Node
-        uses: actions/setup-node@v4
-        with:
-          node-version: "20"
+          shared-key: autobuild-shared

      - uses: pnpm/action-setup@v4
        name: Install pnpm
+        if: github.event.inputs[matrix.input] == 'true'
        with:
          run_install: false

+      - name: Install Node
+        if: github.event.inputs[matrix.input] == 'true'
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+          cache: "pnpm"
+
      - name: Pnpm install and check
+        if: github.event.inputs[matrix.input] == 'true'
        run: |
          pnpm i
-          pnpm check ${{ matrix.target }}
+          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 }}

      - name: Tauri build
+        if: github.event.inputs[matrix.input] == 'true'
        uses: tauri-apps/tauri-action@v0
        env:
          NODE_OPTIONS: "--max_old_space_size=4096"
@@ -78,7 +110,7 @@ jobs:
          args: --target ${{ matrix.target }} -b ${{ matrix.bundle }}

      - name: Upload Artifacts
-        if: matrix.os == 'macos-latest'
+        if: matrix.os == 'macos-latest' && github.event.inputs[matrix.input] == 'true'
        uses: actions/upload-artifact@v4
        with:
          name: ${{ matrix.target }}
@@ -86,7 +118,7 @@ jobs:
          if-no-files-found: error

      - name: Upload Artifacts
-        if: matrix.os == 'windows-latest'
+        if: matrix.os == 'windows-latest' && github.event.inputs[matrix.input] == 'true'
        uses: actions/upload-artifact@v4
        with:
          name: ${{ matrix.target }}
@@ -0,0 +1,50 @@
+# 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
@@ -1,7 +1,12 @@
 name: Release Build

 on:
-  workflow_dispatch:
+  # ! 为了避免重复发布版本，应当通过独特 git tag 触发。
+  # ! 不再使用 workflow_dispatch 触发。
+  # workflow_dispatch:
+  push:
+    tags:
+      - "v*.*.*"
 permissions: write-all
 env:
  CARGO_INCREMENTAL: 0
@@ -12,7 +17,137 @@ 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 }}_aarch64.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: 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
+          prerelease: false
+          token: ${{ secrets.GITHUB_TOKEN }}
+          # generate_release_notes: true
+
  release:
+    name: Release Build
+    needs: [check_tag_version]
    strategy:
      fail-fast: false
      matrix:
@@ -43,8 +178,7 @@ jobs:
        uses: Swatinem/rust-cache@v2
        with:
          workspaces: src-tauri
-          cache-all-crates: true
-          cache-on-failure: true
+          save-if: false

      - name: Install dependencies (ubuntu only)
        if: matrix.os == 'ubuntu-22.04'
@@ -65,7 +199,7 @@ jobs:
      - name: Pnpm install and check
        run: |
          pnpm i
-          pnpm check ${{ matrix.target }}
+          pnpm run prebuild ${{ matrix.target }}

      - name: Tauri build
        uses: tauri-apps/tauri-action@v0
@@ -81,13 +215,20 @@ jobs:
          APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
        with:
-          tagName: v__VERSION__
-          releaseName: "Clash Verge Rev v__VERSION__"
-          releaseBody: "More new features are now supported."
+          tagName: ${{ github.ref_name }}
+          releaseName: "Clash Verge Rev ${{ github.ref_name }}"
+          releaseBody: "Draft release, will be updated later."
+          releaseDraft: true
+          prerelease: false
          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:
@@ -113,7 +254,7 @@ jobs:
        uses: Swatinem/rust-cache@v2
        with:
          workspaces: src-tauri
-          cache-all-crates: true
+          save-if: false

      - name: Install Node
        uses: actions/setup-node@v4
@@ -128,7 +269,7 @@ jobs:
      - name: Pnpm install and check
        run: |
          pnpm i
-          pnpm check ${{ matrix.target }}
+          pnpm run prebuild ${{ matrix.target }}

      - name: "Setup for linux"
        run: |-
@@ -202,13 +343,15 @@ jobs:
        with:
          tag_name: v${{env.VERSION}}
          name: "Clash Verge Rev v${{env.VERSION}}"
-          body: "More new features are now supported."
+          body: "See release notes for detailed changelog."
          token: ${{ secrets.GITHUB_TOKEN }}
          files: |
            src-tauri/target/${{ matrix.target }}/release/bundle/deb/*.deb
            src-tauri/target/${{ matrix.target }}/release/bundle/rpm/*.rpm

  release-for-fixed-webview2:
+    name: Release Build for Fixed WebView2
+    needs: [check_tag_version]
    strategy:
      fail-fast: false
      matrix:
@@ -231,8 +374,7 @@ jobs:
        uses: Swatinem/rust-cache@v2
        with:
          workspaces: src-tauri
-          cache-all-crates: true
-          cache-on-failure: true
+          save-if: false

      - name: Install Node
        uses: actions/setup-node@v4
@@ -247,7 +389,7 @@ jobs:
      - name: Pnpm install and check
        run: |
          pnpm i
-          pnpm check ${{ matrix.target }}
+          pnpm run prebuild ${{ matrix.target }}

      - name: Download WebView2 Runtime
        run: |
@@ -293,7 +435,7 @@ jobs:
        with:
          tag_name: v${{steps.build.outputs.appVersion}}
          name: "Clash Verge Rev v${{steps.build.outputs.appVersion}}"
-          body: "More new features are now supported."
+          body: "See release notes for detailed changelog."
          token: ${{ secrets.GITHUB_TOKEN }}
          files: src-tauri/target/${{ matrix.target }}/release/bundle/nsis/*setup*

@@ -303,6 +445,7 @@ jobs:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

  release-update:
+    name: Release Update
    runs-on: ubuntu-latest
    needs: [release, release-for-linux-arm]
    steps:
@@ -353,8 +496,9 @@ jobs:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

  submit-to-winget:
+    name: Submit to Winget
    runs-on: ubuntu-latest
-    needs: [release-update]
+    needs: [update_tag, release-update]
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
@@ -373,3 +517,97 @@ 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 }}_aarch64.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: release
+          VERSION: ${{ env.VERSION }}
+          DOWNLOAD_URL: ${{ env.DOWNLOAD_URL }}
@@ -9,3 +9,4 @@ scripts/_env.sh
 .vscode
 .tool-versions
 .idea
+.old
@@ -2,12 +2,22 @@

 #pnpm pretty-quick --staged

-# 运行 clippy fmt
-cargo fmt --manifest-path ./src-tauri/Cargo.toml
+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

-if [ $? -ne 0 ]; then
-    echo "rustfmt failed to format the code. Please fix the issues and try again."
-    exit 1
+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 ..
 fi

 #git add .
@@ -1,13 +1,34 @@
 #!/bin/bash

-# 运行 clippy
-# cargo clippy  --manifest-path ./src-tauri/Cargo.toml --fix
+# $1: remote name (e.g., origin)
+# $2: remote url (e.g., git@github.com:clash-verge-rev/clash-verge-rev.git)

-# 如果 clippy 失败，阻止 push
-# if [ $? -ne 0 ]; then
-#    echo "Clippy found issues in sub_crate. Please fix them before pushing."
-#    exit 1
-# fi
+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

-# 允许 push
 exit 0
@@ -0,0 +1,8 @@
+# README.md
+# UPDATELOG.md
+# CONTRIBUTING.md
+
+pnpm-lock.yaml
+
+src-tauri/target/
+src-tauri/gen/
@@ -0,0 +1,16 @@
+{
+  "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"
+}
@@ -8,10 +8,15 @@ 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/v1/guides/getting-started/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/start/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.
@@ -34,20 +39,30 @@ 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
+```
+
 ### Download the Mihomo Core Binary

 You have two options for downloading the clash binary:

 - Automatically download it via the provided script:
+
  ```shell
-  pnpm run check
+  pnpm run prebuild
  # Use '--force' to force update to the latest version
-  # pnpm run check --force
+  # pnpm run prebuild --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
@@ -96,6 +111,29 @@ pnpm portable

 ## Contributing Your Changes

+#### Before commit your changes
+
+If you changed the rust code, it's recommanded to execute code style formatting and quailty checks.
+
+1. Code quailty checks
+
+```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
+```
+
 Once you have made your changes:

 1. Fork the repository.
@@ -18,10 +18,18 @@ A Clash Meta GUI based on <a href="https://github.com/tauri-apps/tauri">Tauri</a
 ## Install

 请到发布页面下载对应的安装包：[Release page](https://github.com/clash-verge-rev/clash-verge-rev/releases)<br>
-Go to the [release page](https://github.com/clash-verge-rev/clash-verge-rev/releases) to download the corresponding installation package<br>
+Go to the [Release page](https://github.com/clash-verge-rev/clash-verge-rev/releases) to download the corresponding installation package<br>
 Supports Windows (x64/x86), Linux (x64/arm64) and macOS 10.15+ (intel/apple).

-### 安装说明和常见问题，请到[文档页](https://clash-verge-rev.github.io/)查看：[Doc](https://clash-verge-rev.github.io/)
+#### 我应当怎样选择发行版
+
+| 版本      | 特征                                     | 链接                                                                                   |
+| :-------- | :--------------------------------------- | :------------------------------------------------------------------------------------- |
+| 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/) 查看

 ---

@@ -29,7 +37,7 @@ Supports Windows (x64/x86), Linux (x64/arm64) and macOS 10.15+ (intel/apple).

 ## Promotion

-[狗狗加速 —— 技术流机场 Doggygo VPN](https://verge.dginv.click/#/register?code=oaxsAGo6)
+#### [狗狗加速 —— 技术流机场 Doggygo VPN](https://verge.dginv.click/#/register?code=oaxsAGo6)

 - 高性能海外机场，免费试用，优惠套餐，解锁流媒体，全球首家支持 Hysteria 协议。
 - 使用 Clash Verge 专属邀请链接注册送 3 天，每天 1G 流量免费试用：[点此注册](https://verge.dginv.click/#/register?code=oaxsAGo6)
@@ -41,6 +49,19 @@ 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 独立服务器优势：
+
+- 🌎 优质网络，回程优化，下载快到飞起
+- 🔧 物理机独享资源，非VPS可比，性能拉满
+- 🧠 适合跑代理、搭建 WEB 站 CDN 站 、搞 CI/CD 或任何高负载应用
+- 💡 支持即开即用，多机房选择，CN2 / IEPL 可选
+- 📦 本项目使用配置已在售，欢迎同款入手！
+- 🎯 想要同款构建体验？[立即下单 YXVM 独立服务器！](https://yxvm.com/aff.php?aff=827)
+
 ## Features

 - 基于性能强劲的 Rust 和 Tauri 2 框架
@@ -67,7 +88,7 @@ To run the development server, execute the following commands after all prerequi

 ```shell
 pnpm i
-pnpm run check
+pnpm run prebuild
 pnpm dev
 ```

@@ -1,47 +1,284 @@
+## 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：
+  - MacOS 下自动升级成功后请关闭程序等待 30 秒重启，因为 MacOS 的端口释放特性，卸载服务后需重启应用等 30 秒才能恢复内核通信。立即启动可能无法正常启动内核。
+  - 墙贴主要为浅色，深色 Tray 图标存在闪烁问题；
+  - 彩色 Tray 图标颜色偏淡；
+
+- 已确认窗口状态管理器存在上游缺陷，已暂时移除窗口大小与位置记忆功能。
+
+### 🐞 修复问题
+
+- 修复首页“代理模式”快速切换导致的卡死问题
+- 修复 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 跨平台备份恢复限制
+
+---
+
 ## 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

@@ -52,23 +289,29 @@
 代号释义： 本次发布在功能上的大幅扩展。新首页设计为用户带来全新交互体验，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 从托盘退出
@@ -85,6 +328,7 @@
   - 修复 MacOS 轻量模式下 Dock 栏图标无法隐藏。

 #### 新增了:
+
 1. **首页**
   - 首页文本过长自动截断
 2. **轻量模式**
@@ -101,6 +345,7 @@
 ## 2.2.0(已下架不再提供)

 #### 新增功能
+
 1. **首页**
   - 新增首页功能，默认启动页面改为首页。
   - 首页流量图卡片显示上传/下载名称。
@@ -132,6 +377,7 @@
   - 新增代理命令。

 #### 修复
+
 1. **系统**
   - 修复 Windows 热键崩溃。
   - 修复 macOS 无框标题。
@@ -145,6 +391,7 @@
   - 修复构建失败问题。

 #### 优化
+
 1. **性能**
   - 重构后端，巨幅性能优化。
   - 优化首页组件性能。
@@ -200,7 +447,7 @@

 - 新增窗口状态实时监控与自动保存功能
 - 增强核心配置变更时的验证与错误处理机制
- 支持通过环境变量`CLASH_VERGE_REV_IP`自定义复制IP地址
+- 支持通过环境变量 `CLASH_VERGE_REV_IP`自定义复制IP地址
 - 添加连接表列宽持久化设置与进程过滤功能
 - 新增代理组首字母导航与动态滚动定位功能
 - 实现连接追踪暂停/恢复功能
@@ -521,7 +768,7 @@
 - 禁用部分 Webview2 快捷键
 - 热键配置新增连接符 + 号
 - 新增部分悬浮提示按钮，用于解释说明
- 当日志等级为`Debug`时（更改需重启软件生效），支持点击内存主动内存回收（绿色文字）
+- 当日志等级为 `Debug`时（更改需重启软件生效），支持点击内存主动内存回收（绿色文字）
 - 设置页面右上角新增 TG 频道链接
 - 各种细节优化和界面性能优化

@@ -561,7 +808,7 @@
 - 禁用部分 Webview2 快捷键
 - 热键配置新增连接符 + 号
 - 新增部分悬浮提示按钮，用于解释说明
- 当日志等级为`Debug`时（更改需重启软件生效），支持点击内存主动内存回收（绿色文字）
+- 当日志等级为 `Debug`时（更改需重启软件生效），支持点击内存主动内存回收（绿色文字）
 - 设置页面右上角新增 TG 频道链接
 - 各种细节优化和界面性能优化

@@ -597,7 +844,7 @@
 - 禁用部分 Webview2 快捷键
 - 热键配置新增连接符 + 号
 - 新增部分悬浮提示按钮，用于解释说明
- 当日志等级为`Debug`时（更改需重启软件生效），支持点击内存主动内存回收（绿色文字）
+- 当日志等级为 `Debug`时（更改需重启软件生效），支持点击内存主动内存回收（绿色文字）
 - 设置页面右上角新增 TG 频道链接

 ### Bugs Fixes
@@ -771,7 +1018,7 @@
 ### Features

 - 缓存代理组图标
- 使用`boa_engine` 代替 `rquickjs`
+- 使用 `boa_engine` 代替 `rquickjs`
 - 支持 Linux armv7

 ### Bugs Fixes
@@ -836,7 +1083,7 @@
 - 支持自定义托盘图标
 - 支持禁用代理组图标
 - 代理组显示当前代理
- 修改 `打开面板` 快捷键为`打开/关闭面板`
+- 修改 `打开面板` 快捷键为 `打开/关闭面板`

 ---

@@ -1000,7 +1247,7 @@

 ### Bugs Fixes

- Windows 下更新时无法覆盖`clash-verge-service.exe`的问题(需要卸载重装一次服务，下次更新生效)
+- Windows 下更新时无法覆盖 `clash-verge-service.exe`的问题(需要卸载重装一次服务，下次更新生效)
 - 窗口最大化按钮变化问题
 - 窗口尺寸保存错误问题
 - 复制环境变量类型无法切换问题
@@ -0,0 +1,4 @@
+files:
+  - source: /src/locales/en.json
+    translation: /src/locales
+    multilingual: 1
@@ -1,113 +1,110 @@
 {
  "name": "clash-verge",
-  "version": "2.2.3",
+  "version": "2.4.0",
  "license": "GPL-3.0-only",
  "scripts": {
-    "dev": "cross-env RUST_BACKTRACE=1 tauri dev -f verge-dev -- --profile fast-dev",
-    "dev:diff": "cross-env RUST_BACKTRACE=1 tauri dev -f verge-dev -- --profile fast-dev",
+    "dev": "cross-env RUST_BACKTRACE=1 tauri dev -f verge-dev",
+    "dev:diff": "cross-env RUST_BACKTRACE=1 tauri dev -f verge-dev",
+    "dev:trace": "cross-env RUST_BACKTRACE=1 RUSTFLAGS=\"--cfg tokio_unstable\" tauri dev -f verge-dev tokio-trace",
    "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",
-    "check": "node scripts/check.mjs",
+    "prebuild": "node scripts/prebuild.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-alpha-version": "node scripts/release-alpha_version.mjs",
-    "prepare": "husky",
-    "clippy": "cargo clippy  --manifest-path ./src-tauri/Cargo.toml"
+    "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",
+    "fmt": "cargo fmt --manifest-path ./src-tauri/Cargo.toml",
+    "clippy": "cargo clippy  --manifest-path ./src-tauri/Cargo.toml",
+    "format": "prettier --write .",
+    "format:check": "prettier --check ."
  },
  "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.0",
+    "@emotion/styled": "^11.14.1",
    "@juggle/resize-observer": "^3.4.0",
-    "@mui/icons-material": "^6.4.8",
-    "@mui/lab": "6.0.0-beta.25",
-    "@mui/material": "^6.4.8",
-    "@mui/x-data-grid": "^7.28.0",
-    "@tauri-apps/api": "2.2.0",
-    "@tauri-apps/plugin-clipboard-manager": "^2.2.2",
-    "@tauri-apps/plugin-dialog": "^2.2.0",
-    "@tauri-apps/plugin-fs": "^2.2.0",
-    "@tauri-apps/plugin-global-shortcut": "^2.2.0",
-    "@tauri-apps/plugin-notification": "^2.2.2",
-    "@tauri-apps/plugin-process": "^2.2.0",
-    "@tauri-apps/plugin-shell": "2.2.0",
-    "@tauri-apps/plugin-updater": "2.3.0",
-    "@types/d3-shape": "^3.1.7",
+    "@mui/icons-material": "^7.3.1",
+    "@mui/lab": "7.0.0-beta.16",
+    "@mui/material": "^7.3.1",
+    "@mui/x-data-grid": "^8.10.2",
+    "@tauri-apps/api": "2.8.0",
+    "@tauri-apps/plugin-clipboard-manager": "^2.3.0",
+    "@tauri-apps/plugin-dialog": "^2.3.3",
+    "@tauri-apps/plugin-fs": "^2.4.2",
+    "@tauri-apps/plugin-global-shortcut": "^2.3.0",
+    "@tauri-apps/plugin-notification": "^2.3.0",
+    "@tauri-apps/plugin-process": "^2.3.0",
+    "@tauri-apps/plugin-shell": "2.3.0",
+    "@tauri-apps/plugin-updater": "2.9.0",
+    "@tauri-apps/plugin-window-state": "^2.4.0",
    "@types/json-schema": "^7.0.15",
-    "ahooks": "^3.8.4",
-    "axios": "^1.8.3",
+    "ahooks": "^3.9.3",
+    "axios": "^1.11.0",
+    "chart.js": "^4.5.0",
    "cli-color": "^2.0.4",
-    "d3-shape": "^3.2.0",
    "dayjs": "1.11.13",
-    "foxact": "^0.2.44",
-    "glob": "^11.0.1",
-    "i18next": "^24.2.3",
-    "js-base64": "^3.7.7",
+    "foxact": "^0.2.49",
+    "glob": "^11.0.3",
+    "i18next": "^25.4.0",
    "js-yaml": "^4.1.0",
+    "json-schema": "^0.4.0",
    "lodash-es": "^4.17.21",
    "monaco-editor": "^0.52.2",
-    "monaco-yaml": "^5.3.1",
+    "monaco-yaml": "^5.4.0",
    "nanoid": "^5.1.5",
-    "peggy": "^4.2.0",
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1",
-    "react-error-boundary": "^4.1.2",
-    "react-hook-form": "^7.54.2",
-    "react-i18next": "^13.5.0",
-    "react-markdown": "^9.1.0",
-    "react-monaco-editor": "^0.56.2",
-    "react-router-dom": "^6.30.0",
-    "react-transition-group": "^4.4.5",
-    "react-virtuoso": "^4.12.5",
-    "recharts": "^2.15.1",
+    "react": "19.1.1",
+    "react-beautiful-dnd": "^13.1.1",
+    "react-chartjs-2": "^5.3.0",
+    "react-dom": "19.1.1",
+    "react-error-boundary": "6.0.0",
+    "react-hook-form": "^7.62.0",
+    "react-i18next": "15.7.0",
+    "react-markdown": "10.1.0",
+    "react-monaco-editor": "0.59.0",
+    "react-router-dom": "7.8.1",
+    "react-virtuoso": "^4.14.0",
    "sockette": "^2.0.6",
-    "swr": "^2.3.3",
+    "swr": "^2.3.6",
    "tar": "^7.4.3",
    "types-pac": "^1.0.3",
-    "zustand": "^5.0.3"
+    "zustand": "^5.0.8"
  },
  "devDependencies": {
-    "@actions/github": "^6.0.0",
-    "@tauri-apps/cli": "2.2.7",
-    "@types/js-cookie": "^3.0.6",
+    "@actions/github": "^6.0.1",
+    "@tauri-apps/cli": "2.8.1",
    "@types/js-yaml": "^4.0.9",
    "@types/lodash-es": "^4.17.12",
-    "@types/react": "^18.3.18",
-    "@types/react-dom": "^18.3.5",
-    "@types/react-transition-group": "^4.4.12",
-    "@vitejs/plugin-legacy": "^6.0.2",
-    "@vitejs/plugin-react": "^4.3.4",
+    "@types/react": "19.1.10",
+    "@types/react-beautiful-dnd": "^13.1.8",
+    "@types/react-dom": "19.1.7",
+    "@vitejs/plugin-legacy": "^7.2.1",
+    "@vitejs/plugin-react": "5.0.1",
    "adm-zip": "^0.5.16",
-    "cross-env": "^7.0.3",
+    "commander": "^14.0.0",
+    "cross-env": "^10.0.0",
    "https-proxy-agent": "^7.0.6",
-    "husky": "^9.1.7",
-    "meta-json-schema": "^1.19.3",
+    "meta-json-schema": "^1.19.12",
    "node-fetch": "^3.3.2",
-    "prettier": "^3.5.3",
-    "pretty-quick": "^4.1.1",
-    "sass": "^1.86.0",
-    "terser": "^5.39.0",
-    "typescript": "^5.8.2",
-    "vite": "^6.2.2",
+    "prettier": "^3.6.2",
+    "prettier-plugin-organize-imports": "^4.2.0",
+    "sass": "^1.90.0",
+    "terser": "^5.43.1",
+    "typescript": "^5.9.2",
+    "vite": "^7.1.3",
    "vite-plugin-monaco-editor": "^1.1.0",
    "vite-plugin-svgr": "^4.3.0"
  },
-  "prettier": {
-    "tabWidth": 2,
-    "semi": true,
-    "singleQuote": false,
-    "endOfLine": "lf"
-  },
  "type": "module",
  "packageManager": "pnpm@9.13.2"
 }
@@ -0,0 +1,42 @@
+{
+  "extends": ["config:recommended", ":disableDependencyDashboard"],
+  "baseBranches": ["dev"],
+  "enabledManagers": ["cargo", "npm"],
+  "labels": ["dependencies"],
+  "ignorePaths": [
+    "**/node_modules/**",
+    "**/bower_components/**",
+    "**/vendor/**",
+    "**/__tests__/**",
+    "**/test/**",
+    "**/tests/**",
+    "**/__fixtures__/**",
+    "**/crate/**",
+    "shared/**"
+  ],
+  "rangeStrategy": "bump",
+  "packageRules": [
+    {
+      "semanticCommitType": "chore",
+      "matchPackageNames": ["*"]
+    },
+    {
+      "description": "Disable node/pnpm version updates",
+      "matchPackageNames": ["node", "pnpm"],
+      "matchDepTypes": ["engines", "packageManager"],
+      "enabled": false
+    },
+    {
+      "description": "Group all cargo dependencies into a single PR",
+      "matchManagers": ["cargo"],
+      "groupName": "cargo dependencies"
+    },
+    {
+      "description": "Group all npm dependencies into a single PR",
+      "matchManagers": ["npm"],
+      "groupName": "npm dependencies"
+    }
+  ],
+  "postUpdateOptions": ["pnpmDedupe"],
+  "ignoreDeps": ["serde_yaml", "sysinfo", "zip", "criterion"]
+}
@@ -0,0 +1,56 @@
+#!/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"
@@ -0,0 +1,102 @@
+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 SRC_DIRS = [
+  path.resolve(__dirname, "../src"),
+  path.resolve(__dirname, "../src-tauri"),
+];
+const exts = [".js", ".ts", ".tsx", ".jsx", ".vue", ".rs"];
+
+// 递归获取所有文件
+function getAllFiles(dir, exts) {
+  let files = [];
+  fs.readdirSync(dir).forEach((file) => {
+    const full = path.join(dir, file);
+    if (fs.statSync(full).isDirectory()) {
+      files = files.concat(getAllFiles(full, exts));
+    } else if (exts.includes(path.extname(full))) {
+      files.push(full);
+    }
+  });
+  return files;
+}
+
+// 读取所有源码内容为一个大字符串
+function getAllSourceContent() {
+  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",
+];
+
+// 主流程
+function processI18nFile(i18nPath, lang, allSource) {
+  const i18n = JSON.parse(fs.readFileSync(i18nPath, "utf8"));
+  const keys = Object.keys(i18n);
+
+  const used = {};
+  const unused = [];
+
+  let checked = 0;
+  const total = keys.length;
+  keys.forEach((key) => {
+    if (WHITELIST_KEYS.includes(key)) {
+      used[key] = i18n[key];
+    } else {
+      // 只查找一次
+      const regex = new RegExp(`["'\`]${key}["'\`]`);
+      if (regex.test(allSource)) {
+        used[key] = i18n[key];
+      } else {
+        unused.push(key);
+      }
+    }
+    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");
+    }
+  });
+
+  // 输出未使用的 key
+  console.log(`\n[${lang}] Unused keys:`, unused);
+
+  // 备份原文件
+  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)}`,
+  );
+  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 allSource = getAllSourceContent();
+  files.forEach((file) => {
+    const lang = path.basename(file, ".json");
+    processI18nFile(path.join(LOCALES_DIR, file), lang, allSource);
+  });
+}
+
+main();
@@ -38,6 +38,17 @@ async function updatePackageVersion(newVersion) {
    const packageJson = JSON.parse(data);
    // 获取键值替换
    let result = packageJson.version.replace("alpha", newVersion);
+    // 检查当前版本号是否已经包含了 alpha- 后缀
+    if (!packageJson.version.includes(`alpha-`)) {
+      // 如果只有 alpha 而没有 alpha-，则替换为 alpha-newVersion
+      result = packageJson.version.replace("alpha", `alpha-${newVersion}`);
+    } else {
+      // 如果已经是 alpha-xxx 格式，则更新 xxx 部分
+      result = packageJson.version.replace(
+        /alpha-[^-]*/,
+        `alpha-${newVersion}`,
+      );
+    }
    console.log("[INFO]: Current version is: ", result);
    packageJson.version = result;
    // 写入版本号
@@ -61,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-compatible",
+  "win32-x64": "mihomo-windows-amd64-v2",
  "win32-ia32": "mihomo-windows-386",
  "win32-arm64": "mihomo-windows-arm64",
-  "darwin-x64": "mihomo-darwin-amd64-compatible",
+  "darwin-x64": "mihomo-darwin-amd64-v2",
  "darwin-arm64": "mihomo-darwin-arm64",
-  "linux-x64": "mihomo-linux-amd64-compatible",
+  "linux-x64": "mihomo-linux-amd64-v2",
  "linux-ia32": "mihomo-linux-386",
  "linux-arm64": "mihomo-linux-arm64",
  "linux-arm": "mihomo-linux-armv7",
@@ -108,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-compatible",
+  "win32-x64": "mihomo-windows-amd64-v2",
  "win32-ia32": "mihomo-windows-386",
  "win32-arm64": "mihomo-windows-arm64",
-  "darwin-x64": "mihomo-darwin-amd64-compatible",
+  "darwin-x64": "mihomo-darwin-amd64-v2",
  "darwin-arm64": "mihomo-darwin-arm64",
-  "linux-x64": "mihomo-linux-amd64-compatible",
+  "linux-x64": "mihomo-linux-amd64-v2",
  "linux-ia32": "mihomo-linux-386",
  "linux-arm64": "mihomo-linux-arm64",
  "linux-arm": "mihomo-linux-armv7",
@@ -0,0 +1,66 @@
+// scripts/publish-version.mjs
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import path from "path";
+
+const rootDir = process.cwd();
+const scriptPath = path.join(rootDir, "scripts", "release-version.mjs");
+
+if (!existsSync(scriptPath)) {
+  console.error("release-version.mjs not found!");
+  process.exit(1);
+}
+
+const versionArg = process.argv[2];
+if (!versionArg) {
+  console.error("Usage: pnpm publish-version <version>");
+  process.exit(1);
+}
+
+// 1. 调用 release-version.mjs
+const runRelease = () =>
+  new Promise((resolve, reject) => {
+    const child = spawn("node", [scriptPath, versionArg], { stdio: "inherit" });
+    child.on("exit", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error("release-version failed"));
+    });
+  });
+
+// 2. 判断是否需要打 tag
+function isSemver(version) {
+  return /^v?\d+\.\d+\.\d+(-[0-9A-Za-z-.]+)?$/.test(version);
+}
+
+async function run() {
+  await runRelease();
+
+  let tag = null;
+  if (versionArg === "alpha") {
+    // 读取 package.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
+    tag = versionArg.startsWith("v") ? versionArg : `v${versionArg}`;
+  }
+
+  if (tag) {
+    // 打 tag 并推送
+    const { execSync } = await import("child_process");
+    try {
+      execSync(`git tag ${tag}`, { stdio: "inherit" });
+      execSync(`git push origin ${tag}`, { stdio: "inherit" });
+      console.log(`[INFO]: Git tag ${tag} created and pushed.`);
+    } catch (e) {
+      console.error(`[ERROR]: Failed to create or push git tag: ${tag}`);
+      process.exit(1);
+    }
+  } else {
+    console.log("[INFO]: No git tag created for this version.");
+  }
+}
+
+run();
@@ -1,96 +0,0 @@
-import fs from "fs/promises";
-import path from "path";
-
-/**
- * 更新 package.json 文件中的版本号
- */
-async function updatePackageVersion() {
-  const _dirname = process.cwd();
-  const packageJsonPath = path.join(_dirname, "package.json");
-  try {
-    const data = await fs.readFile(packageJsonPath, "utf8");
-    const packageJson = JSON.parse(data);
-
-    let result = packageJson.version;
-    if (!result.includes("alpha")) {
-      result = `${result}-alpha`;
-    }
-
-    console.log("[INFO]: Current package.json version is: ", result);
-    packageJson.version = result;
-    await fs.writeFile(
-      packageJsonPath,
-      JSON.stringify(packageJson, null, 2),
-      "utf8",
-    );
-    console.log(`[INFO]: package.json version updated to: ${result}`);
-  } catch (error) {
-    console.error("Error updating package.json version:", error);
-  }
-}
-
-/**
- * 更新 Cargo.toml 文件中的版本号
- */
-async function updateCargoVersion() {
-  const _dirname = process.cwd();
-  const cargoTomlPath = path.join(_dirname, "src-tauri", "Cargo.toml");
-  try {
-    const data = await fs.readFile(cargoTomlPath, "utf8");
-    const lines = data.split("\n");
-
-    const updatedLines = lines.map((line) => {
-      if (line.startsWith("version =")) {
-        const versionMatch = line.match(/version\s*=\s*"([^"]+)"/);
-        if (versionMatch && !versionMatch[1].includes("alpha")) {
-          const newVersion = `${versionMatch[1]}-alpha`;
-          return line.replace(versionMatch[1], newVersion);
-        }
-      }
-      return line;
-    });
-
-    await fs.writeFile(cargoTomlPath, updatedLines.join("\n"), "utf8");
-  } catch (error) {
-    console.error("Error updating Cargo.toml version:", error);
-  }
-}
-
-/**
- * 更新 tauri.conf.json 文件中的版本号
- */
-async function updateTauriConfigVersion() {
-  const _dirname = process.cwd();
-  const tauriConfigPath = path.join(_dirname, "src-tauri", "tauri.conf.json");
-  try {
-    const data = await fs.readFile(tauriConfigPath, "utf8");
-    const tauriConfig = JSON.parse(data);
-
-    let version = tauriConfig.version;
-    if (!version.includes("alpha")) {
-      version = `${version}-alpha`;
-    }
-
-    console.log("[INFO]: Current tauri.conf.json version is: ", version);
-    tauriConfig.version = version;
-    await fs.writeFile(
-      tauriConfigPath,
-      JSON.stringify(tauriConfig, null, 2),
-      "utf8",
-    );
-    console.log(`[INFO]: tauri.conf.json version updated to: ${version}`);
-  } catch (error) {
-    console.error("Error updating tauri.conf.json version:", error);
-  }
-}
-
-/**
- * 主函数，依次更新所有文件的版本号
- */
-async function main() {
-  await updatePackageVersion();
-  await updateCargoVersion();
-  await updateTauriConfigVersion();
-}
-
-main().catch(console.error);
@@ -0,0 +1,294 @@
+/**
+ * CLI tool to update version numbers in package.json, src-tauri/Cargo.toml, and src-tauri/tauri.conf.json.
+ *
+ * Usage:
+ *   pnpm release-version <version>
+ *
+ * <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"
+ *     - "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
+ *   - Update the version field in package.json
+ *   - Update the version field in src-tauri/Cargo.toml
+ *   - Update the version field in src-tauri/tauri.conf.json
+ *
+ * Errors are logged and the process exits with code 1 on failure.
+ */
+
+import fs from "fs/promises";
+import path from "path";
+import { program } from "commander";
+import { execSync } from "child_process";
+
+/**
+ * 获取当前 git 短 commit hash
+ * @returns {string}
+ */
+function getGitShortCommit() {
+  try {
+    return execSync("git rev-parse --short HEAD").toString().trim();
+  } catch (e) {
+    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 (e) {
+    console.warn(
+      "[WARN]: Failed to get latest Tauri commit, fallback to current git short commit",
+    );
+    return getGitShortCommit();
+  }
+}
+
+/**
+ * 生成短时间戳（格式：YYMMDD）或带 commit（格式：YYMMDD.cc39b27）
+ * @param {boolean} withCommit 是否带 commit
+ * @returns {string}
+ */
+function generateShortTimestamp(withCommit = false) {
+  const now = new Date();
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  if (withCommit) {
+    const gitShort = getGitShortCommit();
+    return `${month}${day}.${gitShort}`;
+  }
+  return `${month}${day}`;
+}
+
+/**
+ * 验证版本号格式
+ * @param {string} version
+ * @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,
+  );
+}
+
+/**
+ * 标准化版本号
+ * @param {string} version
+ * @returns {string}
+ */
+function normalizeVersion(version) {
+  return version.startsWith("v") ? version : `v${version}`;
+}
+
+/**
+ * 提取基础版本号（去掉所有 -tag 和 +build 部分）
+ * @param {string} 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, "");
+  return base;
+}
+
+/**
+ * 更新 package.json 版本号
+ * @param {string} newVersion
+ */
+async function updatePackageVersion(newVersion) {
+  const _dirname = process.cwd();
+  const packageJsonPath = path.join(_dirname, "package.json");
+  try {
+    const data = await fs.readFile(packageJsonPath, "utf8");
+    const packageJson = JSON.parse(data);
+
+    console.log(
+      "[INFO]: Current package.json version is: ",
+      packageJson.version,
+    );
+    packageJson.version = newVersion.startsWith("v")
+      ? newVersion.slice(1)
+      : newVersion;
+    await fs.writeFile(
+      packageJsonPath,
+      JSON.stringify(packageJson, null, 2),
+      "utf8",
+    );
+    console.log(
+      `[INFO]: package.json version updated to: ${packageJson.version}`,
+    );
+  } catch (error) {
+    console.error("Error updating package.json version:", error);
+    throw error;
+  }
+}
+
+/**
+ * 更新 Cargo.toml 版本号
+ * @param {string} newVersion
+ */
+async function updateCargoVersion(newVersion) {
+  const _dirname = process.cwd();
+  const cargoTomlPath = path.join(_dirname, "src-tauri", "Cargo.toml");
+  try {
+    const data = await fs.readFile(cargoTomlPath, "utf8");
+    const lines = data.split("\n");
+    const versionWithoutV = newVersion.startsWith("v")
+      ? newVersion.slice(1)
+      : newVersion;
+
+    const updatedLines = lines.map((line) => {
+      if (line.trim().startsWith("version =")) {
+        return line.replace(
+          /version\s*=\s*"[^"]+"/,
+          `version = "${versionWithoutV}"`,
+        );
+      }
+      return line;
+    });
+
+    await fs.writeFile(cargoTomlPath, updatedLines.join("\n"), "utf8");
+    console.log(`[INFO]: Cargo.toml version updated to: ${versionWithoutV}`);
+  } catch (error) {
+    console.error("Error updating Cargo.toml version:", error);
+    throw error;
+  }
+}
+
+/**
+ * 更新 tauri.conf.json 版本号
+ * @param {string} newVersion
+ */
+async function updateTauriConfigVersion(newVersion) {
+  const _dirname = process.cwd();
+  const tauriConfigPath = path.join(_dirname, "src-tauri", "tauri.conf.json");
+  try {
+    const data = await fs.readFile(tauriConfigPath, "utf8");
+    const tauriConfig = JSON.parse(data);
+    const versionWithoutV = newVersion.startsWith("v")
+      ? newVersion.slice(1)
+      : newVersion;
+
+    console.log(
+      "[INFO]: Current tauri.conf.json version is: ",
+      tauriConfig.version,
+    );
+
+    // 使用完整版本信息，包含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}`,
+    );
+  } catch (error) {
+    console.error("Error updating tauri.conf.json version:", error);
+    throw error;
+  }
+}
+
+/**
+ * 获取当前版本号
+ */
+async function getCurrentVersion() {
+  const _dirname = process.cwd();
+  const packageJsonPath = path.join(_dirname, "package.json");
+  try {
+    const data = await fs.readFile(packageJsonPath, "utf8");
+    const packageJson = JSON.parse(data);
+    return packageJson.version;
+  } catch (error) {
+    console.error("Error getting current version:", error);
+    throw error;
+  }
+}
+
+/**
+ * 主函数
+ */
+async function main(versionArg) {
+  if (!versionArg) {
+    console.error("Error: Version argument is required");
+    process.exit(1);
+  }
+
+  try {
+    let newVersion;
+    const validTags = [
+      "alpha",
+      "beta",
+      "rc",
+      "autobuild",
+      "autobuild-latest",
+      "deploytest",
+    ];
+
+    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)}`;
+      } else {
+        newVersion = `${baseVersion}-${versionArg.toLowerCase()}`;
+      }
+    } else {
+      if (!isValidVersion(versionArg)) {
+        console.error("Error: Invalid version format");
+        process.exit(1);
+      }
+      newVersion = normalizeVersion(versionArg);
+    }
+
+    console.log(`[INFO]: Updating versions to: ${newVersion}`);
+    await updatePackageVersion(newVersion);
+    await updateCargoVersion(newVersion);
+    await updateTauriConfigVersion(newVersion);
+    console.log("[SUCCESS]: All version updates completed successfully!");
+  } catch (error) {
+    console.error("[ERROR]: Failed to update versions:", error);
+    process.exit(1);
+  }
+}
+
+program
+  .name("pnpm release-version")
+  .description("Update project version numbers")
+  .argument("<version>", "version tag or full version")
+  .action(main)
+  .parse(process.argv);
@@ -1,197 +0,0 @@
-import fs from "fs/promises";
-import path from "path";
-import { program } from "commander";
-
-/**
- * 验证版本号格式
- * @param {string} version
- * @returns {boolean}
- */
-function isValidVersion(version) {
-  return /^v?\d+\.\d+\.\d+(-(alpha|beta|rc)(\.\d+)?)?$/i.test(version);
-}
-
-/**
- * 标准化版本号（确保v前缀可选）
- * @param {string} version
- * @returns {string}
- */
-function normalizeVersion(version) {
-  return version.startsWith("v") ? version : `v${version}`;
-}
-
-/**
- * 更新 package.json 文件中的版本号
- * @param {string} newVersion 新版本号
- */
-async function updatePackageVersion(newVersion) {
-  const _dirname = process.cwd();
-  const packageJsonPath = path.join(_dirname, "package.json");
-  try {
-    const data = await fs.readFile(packageJsonPath, "utf8");
-    const packageJson = JSON.parse(data);
-
-    console.log(
-      "[INFO]: Current package.json version is: ",
-      packageJson.version,
-    );
-    packageJson.version = newVersion.startsWith("v")
-      ? newVersion.slice(1)
-      : newVersion;
-    await fs.writeFile(
-      packageJsonPath,
-      JSON.stringify(packageJson, null, 2),
-      "utf8",
-    );
-    console.log(
-      `[INFO]: package.json version updated to: ${packageJson.version}`,
-    );
-    return packageJson.version;
-  } catch (error) {
-    console.error("Error updating package.json version:", error);
-    throw error;
-  }
-}
-
-/**
- * 更新 Cargo.toml 文件中的版本号
- * @param {string} newVersion 新版本号
- */
-async function updateCargoVersion(newVersion) {
-  const _dirname = process.cwd();
-  const cargoTomlPath = path.join(_dirname, "src-tauri", "Cargo.toml");
-  try {
-    const data = await fs.readFile(cargoTomlPath, "utf8");
-    const lines = data.split("\n");
-
-    const versionWithoutV = newVersion.startsWith("v")
-      ? newVersion.slice(1)
-      : newVersion;
-
-    const updatedLines = lines.map((line) => {
-      if (line.trim().startsWith("version =")) {
-        return line.replace(
-          /version\s*=\s*"[^"]+"/,
-          `version = "${versionWithoutV}"`,
-        );
-      }
-      return line;
-    });
-
-    await fs.writeFile(cargoTomlPath, updatedLines.join("\n"), "utf8");
-    console.log(`[INFO]: Cargo.toml version updated to: ${versionWithoutV}`);
-  } catch (error) {
-    console.error("Error updating Cargo.toml version:", error);
-    throw error;
-  }
-}
-
-/**
- * 更新 tauri.conf.json 文件中的版本号
- * @param {string} newVersion 新版本号
- */
-async function updateTauriConfigVersion(newVersion) {
-  const _dirname = process.cwd();
-  const tauriConfigPath = path.join(_dirname, "src-tauri", "tauri.conf.json");
-  try {
-    const data = await fs.readFile(tauriConfigPath, "utf8");
-    const tauriConfig = JSON.parse(data);
-
-    const versionWithoutV = newVersion.startsWith("v")
-      ? newVersion.slice(1)
-      : newVersion;
-
-    console.log(
-      "[INFO]: Current tauri.conf.json version is: ",
-      tauriConfig.version,
-    );
-    tauriConfig.version = versionWithoutV;
-    await fs.writeFile(
-      tauriConfigPath,
-      JSON.stringify(tauriConfig, null, 2),
-      "utf8",
-    );
-    console.log(
-      `[INFO]: tauri.conf.json version updated to: ${versionWithoutV}`,
-    );
-  } catch (error) {
-    console.error("Error updating tauri.conf.json version:", error);
-    throw error;
-  }
-}
-
-/**
- * 获取当前版本号（从package.json）
- */
-async function getCurrentVersion() {
-  const _dirname = process.cwd();
-  const packageJsonPath = path.join(_dirname, "package.json");
-  try {
-    const data = await fs.readFile(packageJsonPath, "utf8");
-    const packageJson = JSON.parse(data);
-    return packageJson.version;
-  } catch (error) {
-    console.error("Error getting current version:", error);
-    throw error;
-  }
-}
-
-/**
- * 主函数，更新所有文件的版本号
- * @param {string} versionArg 版本参数（可以是标签或完整版本号）
- */
-async function main(versionArg) {
-  if (!versionArg) {
-    console.error("Error: Version argument is required");
-    process.exit(1);
-  }
-
-  try {
-    let newVersion;
-    const validTags = ["alpha", "beta", "rc"];
-
-    // 判断参数是标签还是完整版本号
-    if (validTags.includes(versionArg.toLowerCase())) {
-      // 标签模式：在当前版本基础上添加标签
-      const currentVersion = await getCurrentVersion();
-      const baseVersion = currentVersion.replace(
-        /-(alpha|beta|rc)(\.\d+)?$/i,
-        "",
-      );
-      newVersion = `${baseVersion}-${versionArg.toLowerCase()}`;
-    } else {
-      // 完整版本号模式
-      if (!isValidVersion(versionArg)) {
-        console.error(
-          "Error: Invalid version format. Expected format: vX.X.X or vX.X.X-tag (e.g. v2.2.3 or v2.2.3-alpha)",
-        );
-        process.exit(1);
-      }
-      newVersion = normalizeVersion(versionArg);
-    }
-
-    console.log(`[INFO]: Updating versions to: ${newVersion}`);
-    await updatePackageVersion(newVersion);
-    await updateCargoVersion(newVersion);
-    await updateTauriConfigVersion(newVersion);
-    console.log("[SUCCESS]: All version updates completed successfully!");
-  } catch (error) {
-    console.error("[ERROR]: Failed to update versions:", error);
-    process.exit(1);
-  }
-}
-
-// Example:
-// pnpm release-version 2.2.3-alpha
-// 设置命令行界面
-program
-  .name("pnpm release-version")
-  .description(
-    "Update project version numbers. Can add tag (alpha/beta/rc) or set full version (e.g. v2.2.3 or v2.2.3-alpha)",
-  )
-  .argument(
-    "<version>",
-    "version tag (alpha/beta/rc) or full version (e.g. v2.2.3 or v2.2.3-alpha)",
-  )
-  .action(main)
-  .parse(process.argv);
@@ -0,0 +1,105 @@
+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，使用默认发布说明");
+    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,
+            '<a href="$2">$1</a>',
+          );
+          processedLine = processedLine.replace(
+            /\*\*([^*]+)\*\*/g,
+            "<b>$1</b>",
+          );
+          return processedLine;
+        }
+      })
+      .join("\n");
+  }
+
+  const formattedContent = convertMarkdownToTelegramHTML(releaseContent);
+
+  const releaseTitle = isAutobuild ? "滚动更新版发布" : "正式发布";
+  const content = `<b>🎉 <a href="https://github.com/clash-verge-rev/clash-verge-rev/releases/tag/v${version}">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${version}`,
+          prefer_large_media: true,
+        },
+        parse_mode: "HTML",
+      },
+    );
+    log_success(`✅ Telegram 通知发送成功到 ${chatId}`);
+  } catch (error) {
+    log_error(
+      `❌ Telegram 通知发送失败到 ${chatId}:`,
+      error.response?.data || error.message,
+    );
+    process.exit(1);
+  }
+}
+
+// 执行函数
+sendTelegramNotification().catch((error) => {
+  log_error("脚本执行失败:", error.message);
+  process.exit(1);
+});
@@ -1,8 +1,8 @@
 [package]
 name = "clash-verge"
-version = "2.2.3"
+version = "2.4.0"
 description = "clash verge"
-authors = ["zzzgydi", "wonfen", "MystiPanda"]
+authors = ["zzzgydi", "Tunglies", "wonfen", "MystiPanda"]
 license = "GPL-3.0-only"
 repository = "https://github.com/clash-verge-rev/clash-verge-rev.git"
 default-run = "clash-verge"
@@ -13,86 +13,103 @@ build = "build.rs"
 identifier = "io.github.clash-verge-rev.clash-verge-rev"

 [build-dependencies]
-tauri-build = { version = "2.1.0", features = [] }
+tauri-build = { version = "2.4.0", features = [] }

 [dependencies]
-warp = "0.3"
-anyhow = "1.0.97"
+warp = { version = "0.4.2", features = ["server"] }
+anyhow = "1.0.99"
 dirs = "6.0"
-open = "5.3"
-log = "0.4"
-dunce = "1.0"
-log4rs = "1"
+open = "5.3.2"
+log = "0.4.27"
+dunce = "1.0.5"
+log4rs = "1.3.0"
 nanoid = "0.4"
-chrono = "0.4.40"
-sysinfo = "0.34"
+chrono = "0.4.41"
+sysinfo = { version = "=0.35.2", features = ["network", "system"] }
 boa_engine = "0.20.0"
-serde_json = "1.0"
-serde_yaml = "0.9"
+serde_json = "1.0.143"
+serde_yaml = "0.9.34"
 once_cell = "1.21.3"
 port_scanner = "0.1.5"
 delay_timer = "0.11.6"
-parking_lot = "0.12"
+parking_lot = "0.12.4"
 percent-encoding = "2.3.1"
-tokio = { version = "1.44", features = [
+tokio = { version = "1.47.1", features = [
  "rt-multi-thread",
  "macros",
  "time",
  "sync",
 ] }
-serde = { version = "1.0", features = ["derive"] }
-reqwest = { version = "0.12", features = ["json", "rustls-tls", "cookies"] }
+serde = { version = "1.0.219", features = ["derive"] }
+reqwest = { version = "0.12.23", features = ["json", "rustls-tls", "cookies"] }
 regex = "1.11.1"
-sysproxy = { git = "https://github.com/clash-verge-rev/sysproxy-rs", rev = "3d748b5" }
-image = "0.25.6"
-imageproc = "0.25.0"
-tauri = { version = "2.4.0", features = [
+sysproxy = { git = "https://github.com/clash-verge-rev/sysproxy-rs" }
+tauri = { version = "2.8.2", features = [
  "protocol-asset",
  "devtools",
  "tray-icon",
  "image-ico",
  "image-png",
 ] }
-network-interface = { version = "2.0.1", features = ["serde"] }
-tauri-plugin-shell = "2.2.0"
-tauri-plugin-dialog = "2.2.0"
-tauri-plugin-fs = "2.2.0"
-tauri-plugin-process = "2.2.0"
-tauri-plugin-clipboard-manager = "2.2.2"
-tauri-plugin-deep-link = "2.2.0"
-tauri-plugin-devtools = "2.0.0"
-zip = "2.5.0"
-reqwest_dav = "0.1.15"
+network-interface = { version = "2.0.3", features = ["serde"] }
+tauri-plugin-shell = "2.3.0"
+tauri-plugin-dialog = "2.3.3"
+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.1"
+tauri-plugin-devtools = "2.0.1"
+tauri-plugin-window-state = "2.4.0"
+zip = "=4.2.0"
+reqwest_dav = "0.2.1"
 aes-gcm = { version = "0.10.3", features = ["std"] }
 base64 = "0.22.1"
-getrandom = "0.3.2"
-tokio-tungstenite = "0.26.2"
-futures = "0.3"
+getrandom = "0.3.3"
+futures = "0.3.31"
 sys-locale = "0.3.2"
-async-trait = "0.1.88"
-mihomo_api = { path = "src_crates/crate_mihomo_api" }
-ab_glyph = "0.2.29"
-tungstenite = "0.26.2"
-libc = "0.2"
+libc = "0.2.175"
+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-rc1"
+dashmap = "6.1.0"
+tauri-plugin-notification = "2.3.0"
+console-subscriber = { version = "0.4.1", optional = true }
+tokio-stream = "0.1.17"

 [target.'cfg(windows)'.dependencies]
 runas = "=1.2.0"
 deelevate = "0.2.0"
 winreg = "0.55.0"
+winapi = { version = "0.3.9", features = [
+  "winbase",
+  "fileapi",
+  "winnt",
+  "handleapi",
+  "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.2.0"
-tauri-plugin-global-shortcut = "2.2.0"
-tauri-plugin-updater = "2.6.1"
-tauri-plugin-window-state = "2.2.1"
+tauri-plugin-autostart = "2.5.0"
+tauri-plugin-global-shortcut = "2.3.0"
+tauri-plugin-updater = "2.9.0"

 [features]
 default = ["custom-protocol"]
 custom-protocol = ["tauri/custom-protocol"]
 verge-dev = []
+tokio-trace = ["console-subscriber"]

 [profile.release]
 panic = "abort"
@@ -103,6 +120,10 @@ strip = true

 [profile.dev]
 incremental = true
+codegen-units = 256 # 增加编译单元，提升编译速度
+opt-level = 0       # 禁用优化，进一步提升编译速度
+debug = true        # 保留调试信息
+strip = false       # 不剥离符号，保留调试信息

 [profile.fast-release]
 inherits = "release" # 继承 release 的配置
@@ -113,25 +134,60 @@ opt-level = 0        # 禁用优化，大幅提升编译速度
 debug = true         # 保留调试信息
 strip = false        # 不剥离符号，保留调试信息

-[profile.fast-dev]
-inherits = "dev"    # 继承 dev 的配置
-codegen-units = 256 # 增加编译单元，提升编译速度
-opt-level = 0       # 禁用优化，进一步提升编译速度
-incremental = true  # 启用增量编译
-debug = true        # 保留调试信息
-strip = false       # 不剥离符号，保留调试信息
-
 [lib]
 name = "app_lib"
 crate-type = ["staticlib", "cdylib", "rlib"]

 [dev-dependencies]
-tempfile = "3.19.1"
+criterion = "0.7.0"

-[workspace]
-members = ["src_crates/crate_mihomo_api"]
+[lints.clippy]
+# Core categories - most important for code safety and correctness
+correctness = { level = "deny", priority = -1 }
+suspicious = { level = "deny", 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" }
+# 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 }
@@ -0,0 +1,91 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+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);
@@ -0,0 +1,9 @@
+{
+  "identifier": "desktop-windows-capability",
+  "description": "permissions for desktop windows applications",
+  "windows": ["main"],
+  "permissions": [
+    "core:webview:allow-create-webview",
+    "core:webview:allow-create-webview-window"
+  ]
+}
@@ -14,8 +14,10 @@
    "updater:allow-download-and-install",
    "process:allow-restart",
    "deep-link:default",
-    "window-state:default",
-    "window-state:default",
-    "autostart:default"
+    "autostart:allow-enable",
+    "autostart:allow-disable",
+    "autostart:allow-is-enabled",
+    "core:window:allow-set-theme",
+    "notification:default"
  ]
 }
@@ -0,0 +1,236 @@
+# 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 = []
@@ -523,7 +523,7 @@ FunctionEnd
    ${If} $0 == 0
      Push $0
      ${If} $1 == 0
-            DetailPrint "Restart Clash Verge Service..."
+            DetailPrint "Restart ${PRODUCTNAME} 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 Clash Verge Service..."
+        DetailPrint "Stop ${PRODUCTNAME} Service..."
        SimpleSC::StopService "clash_verge_service" 1 30
        Pop $0 ; returns an errorcode (<>0) otherwise success (0)
        ${If} $0 == 0
-              DetailPrint "Removing Clash Verge Service..."
+              DetailPrint "Removing ${PRODUCTNAME} Service..."
              SimpleSC::RemoveService "clash_verge_service"
        ${ElseIf} $0 != 0
                  Push $0
                  SimpleSC::GetErrorMessage
                  Pop $0
-                  MessageBox MB_OK|MB_ICONSTOP "Clash Verge Service Stop Error ($0)"
+                  MessageBox MB_OK|MB_ICONSTOP "${PRODUCTNAME} Service Stop Error ($0)"
        ${EndIf}
  ${ElseIf} $1 == 0
-        DetailPrint "Removing Clash Verge Service..."
+        DetailPrint "Removing ${PRODUCTNAME} 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 "$(appRunningOkKill)" IDOK kill IDCANCEL cancel ${|}
+      ${IfThen} $PassiveMode != 1 ${|} MessageBox MB_OKCANCEL "${PRODUCTNAME} 正在运行 $\n点击确定以终止运行" IDOK kill IDCANCEL cancel ${|}
      kill:
        !if "${INSTALLMODE}" == "currentUser"
          nsis_tauri_utils::KillProcessCurrentUser "${MAINBINARYNAME}.exe"
@@ -691,8 +691,6 @@ SectionEnd
  app_check_done:
 !macroend

-
-
 Var VC_REDIST_URL
 Var VC_REDIST_EXE

@@ -701,25 +699,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}

@@ -754,30 +752,44 @@ 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"
@@ -788,7 +800,7 @@ Section Install
  ${If} $R2 != ""
    DeleteRegValue HKCU "$R1" "clash-verge"
  ${EndIf}
-  
+
  ReadRegStr $R2 HKLM "$R1" "clash-verge"
  ${If} $R2 != ""
    DeleteRegValue HKLM "$R1" "clash-verge"
@@ -798,7 +810,7 @@ Section Install
    ; Delete clash-verge.desktop
  IfFileExists "$INSTDIR\Clash Verge.exe" 0 +2
    Delete "$INSTDIR\Clash Verge.exe"
-  
+
  ; Copy main executable
  File "${MAINBINARYSRCPATH}"

@@ -916,22 +928,29 @@ FunctionEnd
 !macroend

 Section Uninstall
+
  !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"
@@ -942,7 +961,7 @@ Section Uninstall
  ${If} $R2 != ""
    DeleteRegValue HKCU "$R1" "clash-verge"
  ${EndIf}
-  
+
  ReadRegStr $R2 HKLM "$R1" "clash-verge"
  ${If} $R2 != ""
    DeleteRegValue HKLM "$R1" "clash-verge"
@@ -974,17 +993,146 @@ 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"

-  ; Remove start menu shortcut
-  !insertmacro MUI_STARTMENU_GETFOLDER Application $AppStartMenuFolder
-  Delete "$SMPROGRAMS\$AppStartMenuFolder\${MAINBINARYNAME}.lnk"
-  RMDir "$SMPROGRAMS\$AppStartMenuFolder"
+  ; 删除所有用户的桌面快捷方式
+  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 desktop shortcuts
-  Delete "$DESKTOP\${MAINBINARYNAME}.lnk"

  ; Remove registry information for add/remove programs
  !if "${INSTALLMODE}" == "both"
@@ -1036,7 +1184,6 @@ FunctionEnd
        System::Free $4
        System::Free $5
        ${IPropertyStore::Commit} $2 ""
-        ${IUnknown::Release} $2 ""
        ${IPersistFile::Save} $1 '("${shortcut}",1)'
      ${EndIf}
      ${IUnknown::Release} $1 ""
@@ -1046,12 +1193,12 @@ FunctionEnd
 !macroend

 Function CreateDesktopShortcut
-  CreateShortcut "$DESKTOP\${MAINBINARYNAME}.lnk" "$INSTDIR\${MAINBINARYNAME}.exe"
-  !insertmacro SetLnkAppUserModelId "$DESKTOP\${MAINBINARYNAME}.lnk"
+  CreateShortcut "$DESKTOP\${PRODUCTNAME}.lnk" "$INSTDIR\${MAINBINARYNAME}.exe"
+  !insertmacro SetLnkAppUserModelId "$DESKTOP\${PRODUCTNAME}.lnk"
 FunctionEnd

 Function CreateStartMenuShortcut
  CreateDirectory "$SMPROGRAMS\$AppStartMenuFolder"
-  CreateShortcut "$SMPROGRAMS\$AppStartMenuFolder\${MAINBINARYNAME}.lnk" "$INSTDIR\${MAINBINARYNAME}.exe"
-  !insertmacro SetLnkAppUserModelId "$SMPROGRAMS\$AppStartMenuFolder\${MAINBINARYNAME}.lnk"
+  CreateShortcut "$SMPROGRAMS\$AppStartMenuFolder\${PRODUCTNAME}.lnk" "$INSTDIR\${MAINBINARYNAME}.exe"
+  !insertmacro SetLnkAppUserModelId "$SMPROGRAMS\$AppStartMenuFolder\${PRODUCTNAME}.lnk"
 FunctionEnd
@@ -11,4 +11,3 @@ merge_derives = true
 use_try_shorthand = false
 use_field_init_shorthand = false
 force_explicit_abi = true
-imports_granularity = "Crate"
@@ -49,7 +49,7 @@ pub fn open_devtools(app_handle: tauri::AppHandle) {
 /// 退出应用
 #[tauri::command]
 pub fn exit_app() {
-    feat::quit(Some(0));
+    feat::quit();
 }

 /// 重启应用
@@ -87,23 +87,18 @@ pub async fn download_icon_cache(url: String, name: String) -> CmdResult<String>
    let icon_cache_dir = wrap_err!(dirs::app_home_dir())?.join("icons").join("cache");
    let icon_path = icon_cache_dir.join(&name);

-    // 如果文件已存在，直接返回路径
    if icon_path.exists() {
        return Ok(icon_path.to_string_lossy().to_string());
    }

-    // 确保缓存目录存在
    if !icon_cache_dir.exists() {
        let _ = std::fs::create_dir_all(&icon_cache_dir);
    }

-    // 使用临时文件名来下载
    let temp_path = icon_cache_dir.join(format!("{}.downloading", &name));

-    // 下载文件到临时位置
    let response = wrap_err!(reqwest::get(&url).await)?;

-    // 检查内容类型是否为图片
    let content_type = response
        .headers()
        .get(reqwest::header::CONTENT_TYPE)
@@ -112,16 +107,13 @@ pub async fn download_icon_cache(url: String, name: String) -> CmdResult<String>

    let is_image = content_type.starts_with("image/");

-    // 获取响应内容
    let content = wrap_err!(response.bytes().await)?;

-    // 检查内容是否为HTML (针对CDN错误页面)
    let is_html = content.len() > 15
        && (content.starts_with(b"<!DOCTYPE html")
            || content.starts_with(b"<html")
            || content.starts_with(b"<?xml"));

-    // 只有当内容确实是图片时才保存
    if is_image && !is_html {
        {
            let mut file = match std::fs::File::create(&temp_path) {
@@ -129,16 +121,14 @@ 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());
                }
            };

            wrap_err!(std::io::copy(&mut content.as_ref(), &mut file))?;
        }

-        // 再次检查目标文件是否已存在，避免重命名覆盖其他线程已完成的文件
        if !icon_path.exists() {
            match std::fs::rename(&temp_path, &icon_path) {
                Ok(_) => {}
@@ -156,7 +146,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}"))
    }
 }

@@ -214,3 +204,42 @@ pub fn copy_icon_file(path: String, icon_info: IconInfo) -> CmdResult<String> {
        Err("file not found".to_string())
    }
 }
+
+/// 通知UI已准备就绪
+#[tauri::command]
+pub fn notify_ui_ready() -> CmdResult<()> {
+    log::info!(target: "app", "前端UI已准备就绪");
+    crate::utils::resolve::mark_ui_ready();
+    Ok(())
+}
+
+/// UI加载阶段
+#[tauri::command]
+pub fn update_ui_stage(stage: String) -> CmdResult<()> {
+    log::info!(target: "app", "UI加载阶段更新: {stage}");
+
+    use crate::utils::resolve::UiReadyStage;
+
+    let stage_enum = match stage.as_str() {
+        "NotStarted" => UiReadyStage::NotStarted,
+        "Loading" => UiReadyStage::Loading,
+        "DomReady" => UiReadyStage::DomReady,
+        "ResourcesLoaded" => UiReadyStage::ResourcesLoaded,
+        "Ready" => UiReadyStage::Ready,
+        _ => {
+            log::warn!(target: "app", "未知的UI加载阶段: {stage}");
+            return Err(format!("未知的UI加载阶段: {stage}"));
+        }
+    };
+
+    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(())
+}
@@ -1,6 +1,19 @@
 use super::CmdResult;
-use crate::{config::*, core::*, feat, module::mihomo::MihomoManager, wrap_err};
+use crate::{
+    config::*,
+    core::*,
+    feat,
+    ipc::{self, IpcManager},
+    logging,
+    process::AsyncHandler,
+    state::proxy::ProxyRequestCache,
+    utils::logging::Type,
+    wrap_err,
+};
 use serde_yaml::Mapping;
+use std::time::Duration;
+
+const CONFIG_REFRESH_INTERVAL: Duration = Duration::from_secs(60);

 /// 复制Clash环境变量
 #[tauri::command]
@@ -12,7 +25,7 @@ pub fn copy_clash_env() -> CmdResult {
 /// 获取Clash信息
 #[tauri::command]
 pub fn get_clash_info() -> CmdResult<ClashInfo> {
-    Ok(Config::clash().latest().get_client_info())
+    Ok(Config::clash().latest_ref().get_client_info())
 }

 /// 修改Clash配置
@@ -31,31 +44,70 @@ pub async fn patch_clash_mode(payload: String) -> CmdResult {
 /// 切换Clash核心
 #[tauri::command]
 pub async fn change_clash_core(clash_core: String) -> CmdResult<Option<String>> {
-    log::info!(target: "app", "changing core to {clash_core}");
+    logging!(info, Type::Config, "changing core to {clash_core}");

    match CoreManager::global()
        .change_core(Some(clash_core.clone()))
        .await
    {
        Ok(_) => {
-            log::info!(target: "app", "core changed to {clash_core}");
-            handle::Handle::notice_message("config_core::change_success", &clash_core);
-            handle::Handle::refresh_clash();
-            Ok(None)
+            // 切换内核后重启内核
+            match CoreManager::global().restart_core().await {
+                Ok(_) => {
+                    logging!(
+                        info,
+                        Type::Core,
+                        "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}");
+                    handle::Handle::notice_message("config_core::change_error", &error_msg);
+                    Ok(Some(error_msg))
+                }
+            }
        }
        Err(err) => {
            let error_msg = err.to_string();
-            log::error!(target: "app", "failed to change core: {error_msg}");
+            logging!(error, Type::Core, "failed to change core: {error_msg}");
            handle::Handle::notice_message("config_core::change_error", &error_msg);
            Ok(Some(error_msg))
        }
    }
 }

+/// 启动核心
+#[tauri::command]
+pub async fn start_core() -> CmdResult {
+    let result = wrap_err!(CoreManager::global().start_core().await);
+    if result.is_ok() {
+        handle::Handle::refresh_clash();
+    }
+    result
+}
+
+/// 关闭核心
+#[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
+}
+
 /// 重启核心
 #[tauri::command]
 pub async fn restart_core() -> CmdResult {
-    wrap_err!(CoreManager::global().restart_core().await)
+    let result = wrap_err!(CoreManager::global().restart_core().await);
+    if result.is_ok() {
+        handle::Handle::refresh_clash();
+    }
+    result
 }

 /// 获取代理延迟
@@ -65,9 +117,11 @@ pub async fn clash_api_get_proxy_delay(
    url: Option<String>,
    timeout: i32,
 ) -> CmdResult<serde_json::Value> {
-    MihomoManager::global()
-        .test_proxy_delay(&name, url, timeout)
-        .await
+    wrap_err!(
+        IpcManager::global()
+            .test_proxy_delay(&name, url, timeout)
+            .await
+    )
 }

 /// 测试URL延迟
@@ -91,7 +145,7 @@ pub async fn save_dns_config(dns_config: Mapping) -> CmdResult {
    // 保存DNS配置到文件
    let yaml_str = serde_yaml::to_string(&dns_config).map_err(|e| e.to_string())?;
    fs::write(&dns_path, yaml_str).map_err(|e| e.to_string())?;
-    log::info!(target: "app", "DNS config saved to {:?}", dns_path);
+    logging!(info, Type::Config, "DNS config saved to {dns_path:?}");

    Ok(())
 }
@@ -104,29 +158,28 @@ pub fn apply_dns_config(apply: bool) -> CmdResult {
        core::{handle, CoreManager},
        utils::dirs,
    };
-    use tauri::async_runtime;

    // 使用spawn来处理异步操作
-    async_runtime::spawn(async move {
+    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);
+                    logging!(error, Type::Config, "Failed to get home dir: {e}");
                    return;
                }
            };

            if !dns_path.exists() {
-                log::warn!(target: "app", "DNS config file not found");
+                logging!(warn, Type::Config, "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);
+                    logging!(error, Type::Config, "Failed to read DNS config: {e}");
                    return;
                }
            };
@@ -139,51 +192,67 @@ pub fn apply_dns_config(apply: bool) -> CmdResult {
                    patch
                }
                Err(e) => {
-                    log::error!(target: "app", "Failed to parse DNS config: {}", e);
+                    logging!(error, Type::Config, "Failed to parse DNS config: {e}");
                    return;
                }
            };

-            log::info!(target: "app", "Applying DNS config from file");
+            logging!(info, Type::Config, "Applying DNS config from file");

            // 重新生成配置，确保DNS配置被正确应用
            // 这里不调用patch_clash以避免将DNS配置写入config.yaml
            Config::runtime()
-                .latest()
+                .draft_mut()
                .patch_config(patch_config.clone());

            // 首先重新生成配置
-            if let Err(err) = Config::generate().await {
-                log::error!(target: "app", "Failed to regenerate config with DNS: {}", err);
+            if let Err(err) = Config::generate() {
+                logging!(
+                    error,
+                    Type::Config,
+                    "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);
+                logging!(
+                    error,
+                    Type::Config,
+                    "Failed to apply config with DNS: {err}"
+                );
            } else {
-                log::info!(target: "app", "DNS config successfully applied");
+                logging!(info, Type::Config, "DNS config successfully applied");
                handle::Handle::refresh_clash();
            }
        } else {
            // 当关闭DNS设置时，不需要对配置进行任何修改
            // 直接重新生成配置，让enhance函数自动跳过DNS配置的加载
-            log::info!(target: "app", "DNS settings disabled, regenerating config");
+            logging!(
+                info,
+                Type::Config,
+                "DNS settings disabled, regenerating config"
+            );

            // 重新生成配置
-            if let Err(err) = Config::generate().await {
-                log::error!(target: "app", "Failed to regenerate config: {}", err);
+            if let Err(err) = Config::generate() {
+                logging!(error, Type::Config, "Failed to regenerate config: {err}");
                return;
            }

            // 应用新配置
            match CoreManager::global().update_config().await {
                Ok(_) => {
-                    log::info!(target: "app", "Config regenerated successfully");
+                    logging!(info, Type::Config, "Config regenerated successfully");
                    handle::Handle::refresh_clash();
                }
                Err(err) => {
-                    log::error!(target: "app", "Failed to apply regenerated config: {}", err);
+                    logging!(
+                        error,
+                        Type::Config,
+                        "Failed to apply regenerated config: {err}"
+                    );
                }
            }
        }
@@ -221,3 +290,340 @@ pub async fn get_dns_config_content() -> CmdResult<String> {
    let content = fs::read_to_string(&dns_path).map_err(|e| e.to_string())?;
    Ok(content)
 }
+
+/// 验证DNS配置文件
+#[tauri::command]
+pub async fn validate_dns_config() -> CmdResult<(bool, String)> {
+    use crate::{core::CoreManager, utils::dirs};
+
+    let app_dir = dirs::app_home_dir().map_err(|e| e.to_string())?;
+    let dns_path = app_dir.join("dns_config.yaml");
+    let dns_path_str = dns_path.to_str().unwrap_or_default();
+
+    if !dns_path.exists() {
+        return Ok((false, "DNS config file not found".to_string()));
+    }
+
+    match CoreManager::global()
+        .validate_config_file(dns_path_str, None)
+        .await
+    {
+        Ok(result) => Ok(result),
+        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 = ProxyRequestCache::global();
+    let key = ProxyRequestCache::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 = ProxyRequestCache::global();
+    let key = ProxyRequestCache::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(())
+}
@@ -7,3 +7,9 @@ pub async fn entry_lightweight_mode() -> CmdResult {
    lightweight::entry_lightweight_mode();
    Ok(())
 }
+
+#[tauri::command]
+pub async fn exit_lightweight_mode() -> CmdResult {
+    lightweight::exit_lightweight_mode();
+    Ok(())
+}
@@ -1,3 +1,4 @@
+use crate::{logging, utils::logging::Type};
 use chrono::Local;
 use regex::Regex;
 use reqwest::Client;
@@ -37,7 +38,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()
 }

@@ -163,7 +164,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
@@ -207,7 +208,7 @@ async fn check_chatgpt_combined(client: &Client) -> Vec<UnlockItem> {
            if let Ok(body) = response.text().await {
                let body_lower = body.to_lowercase();
                if body_lower.contains("unsupported_country") {
-                    "Unsupported Country"
+                    "Unsupported Country/Region"
                } else {
                    "Yes"
                }
@@ -250,12 +251,28 @@ async fn check_gemini(client: &Client) -> UnlockItem {
                let status = if is_ok { "Yes" } else { "No" };

                // 尝试提取国家代码
-                let re = Regex::new(r#",2,1,200,"([A-Z]{3})""#).unwrap();
+                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 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}")
                    })
                });

@@ -303,12 +320,28 @@ async fn check_youtube_premium(client: &Client) -> UnlockItem {
                    }
                } else if body_lower.contains("ad-free") {
                    // 尝试解析国家代码
-                    let re = Regex::new(r#"id="country-code"[^>]*>([^<]+)<"#).unwrap();
+                    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 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}")
                        })
                    });

@@ -350,11 +383,16 @@ async fn check_bahamut_anime(client: &Client) -> UnlockItem {
    let cookie_store = Arc::new(reqwest::cookie::Jar::default());

    // 使用带Cookie的客户端
-    let client_with_cookies = reqwest::Client::builder()
+    let client_with_cookies = match 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()
-        .unwrap_or_else(|_| client.clone());
+        .build() {
+        Ok(client) => client,
+        Err(e) => {
+            logging!(error, Type::Network, "Failed to create client with cookies for Bahamut Anime: {}", e);
+            client.clone()
+        }
+    };

    // 第一步：获取设备ID (会自动保存Cookie)
    let device_url = "https://ani.gamer.com.tw/ajax/getdeviceid.php";
@@ -363,10 +401,21 @@ async fn check_bahamut_anime(client: &Client) -> UnlockItem {
            match response.text().await {
                Ok(text) => {
                    // 使用正则提取deviceid
-                    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()
+                    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()
+                        }
+                    }
                }
                Err(_) => String::new(),
            }
@@ -384,10 +433,8 @@ 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) => {
@@ -423,17 +470,25 @@ async fn check_bahamut_anime(client: &Client) -> UnlockItem {
        .await
    {
        Ok(response) => match response.text().await {
-            Ok(body) => {
-                let region_re = Regex::new(r#"data-geo="([^"]+)"#).unwrap();
-                region_re
+            Ok(body) => match Regex::new(r#"data-geo="([^"]+)"#) {
+                Ok(region_re) => 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}")
+                    }),
+                Err(e) => {
+                    logging!(
+                        error,
+                        Type::Network,
+                        "Failed to compile region regex for Bahamut Anime: {}",
+                        e
+                    );
+                    None
+                }
+            },
            Err(_) => None,
        },
        Err(_) => None,
@@ -470,7 +525,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(),
@@ -487,7 +542,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(),
@@ -497,8 +552,40 @@ async fn check_netflix(client: &Client) -> UnlockItem {
    }

    // 获取状态码
-    let status1 = result1.unwrap().status().as_u16();
-    let status2 = result2.unwrap().status().as_u16();
+    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()),
+            };
+        }
+    };

    // 根据状态码判断解锁状况
    if status1 == 404 && status2 == 404 {
@@ -541,7 +628,7 @@ async fn check_netflix(client: &Client) -> UnlockItem {
                            return UnlockItem {
                                name: "Netflix".to_string(),
                                status: "Yes".to_string(),
-                                region: Some(format!("{}{}", emoji, region_code)),
+                                region: Some(format!("{emoji}{region_code}")),
                                check_time: Some(get_local_date_string()),
                            };
                        }
@@ -557,7 +644,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(),
@@ -570,7 +657,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()),
        }
@@ -614,7 +701,7 @@ async fn check_netflix_cdn(client: &Client) -> UnlockItem {
                                    return UnlockItem {
                                        name: "Netflix".to_string(),
                                        status: "Yes".to_string(),
-                                        region: Some(format!("{}{}", emoji, country)),
+                                        region: Some(format!("{emoji}{country}")),
                                        check_time: Some(get_local_date_string()),
                                    };
                                }
@@ -631,7 +718,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(),
@@ -642,7 +729,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(),
@@ -687,7 +774,23 @@ async fn check_disney_plus(client: &Client) -> UnlockItem {
        };
    }

-    let device_response = device_result.unwrap();
+    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()),
+            };
+        }
+    };

    // 检查是否 403 错误
    if device_response.status().as_u16() == 403 {
@@ -712,7 +815,23 @@ async fn check_disney_plus(client: &Client) -> UnlockItem {
    };

    // 提取 assertion
-    let re = Regex::new(r#""assertion"\s*:\s*"([^"]+)"#).unwrap();
+    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 assertion = match re.captures(&device_body) {
        Some(caps) => caps.get(1).map(|m| m.as_str().to_string()),
        None => None,
@@ -731,7 +850,18 @@ async fn check_disney_plus(client: &Client) -> UnlockItem {
    let token_url = "https://disney.api.edge.bamgrid.com/token";

    // 构建请求体 - 使用表单数据格式而非 JSON
-    let assertion_str = assertion.unwrap();
+    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 token_body = [
        (
            "grant_type",
@@ -764,7 +894,23 @@ async fn check_disney_plus(client: &Client) -> UnlockItem {
        };
    }

-    let token_response = token_result.unwrap();
+    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_status = token_response.status();

    // 保存原始响应用于调试
@@ -800,10 +946,20 @@ async fn check_disney_plus(client: &Client) -> UnlockItem {
            .map(|s| s.to_string()),
        Err(_) => {
            // 如果 JSON 解析失败，尝试使用正则表达式
-            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()))
+            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
+                }
+            }
        }
    };

@@ -827,7 +983,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()
+        refresh_token.unwrap_or_default()
    );

    let graphql_result = client
@@ -859,21 +1015,56 @@ async fn check_disney_plus(client: &Client) -> UnlockItem {
    };

    // 解析 GraphQL 响应获取区域信息
-    let graphql_response = graphql_result.unwrap();
+    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_status = graphql_response.status();
-    let graphql_body_text = (graphql_response.text().await).unwrap_or_default();
+    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()
+        }
+    };

    // 如果 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) => {
-                    let region_re = Regex::new(r#"region"\s*:\s*"([^"]+)"#).unwrap();
-                    region_re
+                Ok(body) => match Regex::new(r#"region"\s*:\s*"([^"]+)"#) {
+                    Ok(region_re) => region_re
                        .captures(&body)
-                        .and_then(|caps| caps.get(1).map(|m| m.as_str().to_string()))
-                }
+                        .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
+                    }
+                },
                Err(_) => None,
            },
            Err(_) => None,
@@ -884,7 +1075,7 @@ async fn check_disney_plus(client: &Client) -> UnlockItem {
            return UnlockItem {
                name: "Disney+".to_string(),
                status: "Yes".to_string(),
-                region: Some(format!("{}{} (from main page)", emoji, region)),
+                region: Some(format!("{emoji}{region} (from main page)")),
                check_time: Some(get_local_date_string()),
            };
        }
@@ -900,28 +1091,59 @@ async fn check_disney_plus(client: &Client) -> UnlockItem {
                region: None,
                check_time: Some(get_local_date_string()),
            };
-        } else {
+        }
+        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
+            );
            return UnlockItem {
                name: "Disney+".to_string(),
-                status: format!(
-                    "Failed (GraphQL error: {}, status: {})",
-                    graphql_body_text.chars().take(50).collect::<String>() + "...",
-                    graphql_status.as_u16()
-                ),
+                status: "Failed (Regex Error)".to_string(),
                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 = Regex::new(r#""inSupportedLocation"\s*:\s*(false|true)"#).unwrap();
+    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 in_supported_location = supported_re
        .captures(&graphql_body_text)
        .and_then(|caps| caps.get(1).map(|m| m.as_str() == "true"));
@@ -931,12 +1153,20 @@ 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) => {
-                    let region_re = Regex::new(r#"region"\s*:\s*"([^"]+)"#).unwrap();
-                    region_re
+                Ok(body) => match Regex::new(r#"region"\s*:\s*"([^"]+)"#) {
+                    Ok(region_re) => region_re
                        .captures(&body)
-                        .and_then(|caps| caps.get(1).map(|m| m.as_str().to_string()))
-                }
+                        .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
+                    }
+                },
                Err(_) => None,
            },
            Err(_) => None,
@@ -947,7 +1177,7 @@ async fn check_disney_plus(client: &Client) -> UnlockItem {
            return UnlockItem {
                name: "Disney+".to_string(),
                status: "Yes".to_string(),
-                region: Some(format!("{}{} (from main page)", emoji, region)),
+                region: Some(format!("{emoji}{region} (from main page)")),
                check_time: Some(get_local_date_string()),
            };
        }
@@ -960,7 +1190,18 @@ async fn check_disney_plus(client: &Client) -> UnlockItem {
        };
    }

-    let region = region_code.unwrap();
+    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()),
+            };
+        }
+    };

    // 判断日本地区
    if region == "JP" {
@@ -968,7 +1209,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()),
        };
    }
@@ -990,7 +1231,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()),
            }
        }
@@ -999,13 +1240,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()),
        },
@@ -1030,13 +1271,47 @@ async fn check_prime_video(client: &Client) -> UnlockItem {
    }

    // 解析响应内容
-    match result.unwrap().text().await {
+    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 {
        Ok(body) => {
            // 检查是否被地区限制
            let is_blocked = body.contains("isServiceRestricted");

            // 提取地区信息
-            let region_re = Regex::new(r#""currentTerritory":"([^"]+)"#).unwrap();
+            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_code = region_re
                .captures(&body)
                .and_then(|caps| caps.get(1).map(|m| m.as_str().to_string()));
@@ -1056,7 +1331,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()),
                };
            }
@@ -1170,7 +1445,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}")),
    };

    // 创建共享的结果集
@@ -1184,8 +1459,8 @@ pub async fn check_media_unlock() -> Result<Vec<UnlockItem>, String> {

    // 添加哔哩哔哩大陆检测任务
    {
-        let client = client_arc.clone();
-        let results = results.clone();
+        let client = Arc::clone(&client_arc);
+        let results = Arc::clone(&results);
        tasks.spawn(async move {
            let result = check_bilibili_china_mainland(&client).await;
            let mut results = results.lock().await;
@@ -1195,8 +1470,8 @@ pub async fn check_media_unlock() -> Result<Vec<UnlockItem>, String> {

    // 添加哔哩哔哩港澳台检测任务
    {
-        let client = client_arc.clone();
-        let results = results.clone();
+        let client = Arc::clone(&client_arc);
+        let results = Arc::clone(&results);
        tasks.spawn(async move {
            let result = check_bilibili_hk_mc_tw(&client).await;
            let mut results = results.lock().await;
@@ -1206,8 +1481,8 @@ pub async fn check_media_unlock() -> Result<Vec<UnlockItem>, String> {

    // 添加合并的ChatGPT检测任务
    {
-        let client = client_arc.clone();
-        let results = results.clone();
+        let client = Arc::clone(&client_arc);
+        let results = Arc::clone(&results);
        tasks.spawn(async move {
            let chatgpt_results = check_chatgpt_combined(&client).await;
            let mut results = results.lock().await;
@@ -1217,8 +1492,8 @@ pub async fn check_media_unlock() -> Result<Vec<UnlockItem>, String> {

    // 添加Gemini检测任务
    {
-        let client = client_arc.clone();
-        let results = results.clone();
+        let client = Arc::clone(&client_arc);
+        let results = Arc::clone(&results);
        tasks.spawn(async move {
            let result = check_gemini(&client).await;
            let mut results = results.lock().await;
@@ -1228,8 +1503,8 @@ pub async fn check_media_unlock() -> Result<Vec<UnlockItem>, String> {

    // 添加YouTube Premium检测任务
    {
-        let client = client_arc.clone();
-        let results = results.clone();
+        let client = Arc::clone(&client_arc);
+        let results = Arc::clone(&results);
        tasks.spawn(async move {
            let result = check_youtube_premium(&client).await;
            let mut results = results.lock().await;
@@ -1239,8 +1514,8 @@ pub async fn check_media_unlock() -> Result<Vec<UnlockItem>, String> {

    // 添加动画疯检测任务
    {
-        let client = client_arc.clone();
-        let results = results.clone();
+        let client = Arc::clone(&client_arc);
+        let results = Arc::clone(&results);
        tasks.spawn(async move {
            let result = check_bahamut_anime(&client).await;
            let mut results = results.lock().await;
@@ -1250,8 +1525,8 @@ pub async fn check_media_unlock() -> Result<Vec<UnlockItem>, String> {

    // 添加 Netflix 检测任务
    {
-        let client = client_arc.clone();
-        let results = results.clone();
+        let client = Arc::clone(&client_arc);
+        let results = Arc::clone(&results);
        tasks.spawn(async move {
            let result = check_netflix(&client).await;
            let mut results = results.lock().await;
@@ -1261,8 +1536,8 @@ pub async fn check_media_unlock() -> Result<Vec<UnlockItem>, String> {

    // 添加 Disney+ 检测任务
    {
-        let client = client_arc.clone();
-        let results = results.clone();
+        let client = Arc::clone(&client_arc);
+        let results = Arc::clone(&results);
        tasks.spawn(async move {
            let result = check_disney_plus(&client).await;
            let mut results = results.lock().await;
@@ -1272,8 +1547,8 @@ pub async fn check_media_unlock() -> Result<Vec<UnlockItem>, String> {

    // 添加 Prime Video 检测任务
    {
-        let client = client_arc.clone();
-        let results = results.clone();
+        let client = Arc::clone(&client_arc);
+        let results = Arc::clone(&results);
        tasks.spawn(async move {
            let result = check_prime_video(&client).await;
            let mut results = results.lock().await;
@@ -1284,14 +1559,22 @@ 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 = Arc::try_unwrap(results)
-        .expect("无法获取结果，可能仍有引用存在")
-        .into_inner();
+    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());
+        }
+    };

    Ok(results)
 }
@@ -1,6 +1,5 @@
 use anyhow::Result;

-// Common result type used by command functions
 pub type CmdResult<T = ()> = Result<T, String>;

 // Command modules
@@ -1,13 +1,17 @@
 use super::CmdResult;
+use crate::core::{async_proxy_query::AsyncProxyQuery, EventDrivenProxyManager};
+use crate::process::AsyncHandler;
 use crate::wrap_err;
 use network_interface::NetworkInterface;
 use serde_yaml::Mapping;
-use sysproxy::{Autoproxy, Sysproxy};

 /// get the system proxy
 #[tauri::command]
-pub fn get_sys_proxy() -> CmdResult<Mapping> {
-    let current = wrap_err!(Sysproxy::get_system_proxy())?;
+pub async fn get_sys_proxy() -> CmdResult<Mapping> {
+    log::debug!(target: "app", "异步获取系统代理配置");
+
+    let current = AsyncProxyQuery::get_system_proxy().await;
+
    let mut map = Mapping::new();
    map.insert("enable".into(), current.enable.into());
    map.insert(
@@ -16,21 +20,50 @@ pub 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 fn get_auto_proxy() -> CmdResult<Mapping> {
-    let current = wrap_err!(Autoproxy::get_auto_proxy())?;
+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();
+    // 异步请求更新，立即返回缓存数据
+    AsyncHandler::spawn(move || async move {
+        let _ = proxy_manager.get_auto_proxy_async().await;
+    });

    let mut map = Mapping::new();
    map.insert("enable".into(), current.enable.into());
-    map.insert("url".into(), current.url.into());
+    map.insert("url".into(), current.url.clone().into());

+    log::debug!(target: "app", "返回自动代理配置（缓存）: enable={}, url={}", current.enable, current.url);
    Ok(map)
 }

+/// 获取系统主机名
+#[tauri::command]
+pub fn get_system_hostname() -> CmdResult<String> {
+    use gethostname::gethostname;
+
+    // 获取系统主机名，处理可能的非UTF-8字符
+    let hostname = match gethostname().into_string() {
+        Ok(name) => name,
+        Err(os_string) => {
+            // 对于包含非UTF-8的主机名，使用调试格式化
+            let fallback = format!("{os_string:?}");
+            // 去掉可能存在的引号
+            fallback.trim_matches('"').to_string()
+        }
+    };
+
+    Ok(hostname)
+}
+
 /// 获取网络接口列表
 #[tauri::command]
 pub fn get_network_interfaces() -> Vec<String> {
@@ -1,17 +1,123 @@
 use super::CmdResult;
 use crate::{
    config::{Config, IProfiles, PrfItem, PrfOption},
-    core::{handle, tray::Tray, CoreManager},
-    feat, logging, ret_err,
+    core::{handle, timer::Timer, tray::Tray, CoreManager},
+    feat, logging,
+    process::AsyncHandler,
+    ret_err,
    utils::{dirs, help, logging::Type},
    wrap_err,
 };
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::Duration;
+use tokio::sync::{Mutex, RwLock};

-/// 获取配置文件列表
+// 全局互斥锁防止并发配置更新
+static PROFILE_UPDATE_MUTEX: Mutex<()> = Mutex::const_new(());
+
+// 全局请求序列号跟踪，用于避免队列化执行
+static CURRENT_REQUEST_SEQUENCE: AtomicU64 = AtomicU64::new(0);
+
+static CURRENT_PROCESSING_PROFILE: RwLock<Option<String>> = RwLock::const_new(None);
+
+/// 清理配置处理状态
+async fn cleanup_processing_state(sequence: u64, reason: &str) {
+    *CURRENT_PROCESSING_PROFILE.write().await = None;
+    logging!(
+        info,
+        Type::Cmd,
+        true,
+        "{}，清理状态，序列号: {}",
+        reason,
+        sequence
+    );
+}
+
+/// 获取配置文件避免锁竞争
 #[tauri::command]
-pub fn get_profiles() -> CmdResult<IProfiles> {
-    let _ = Tray::global().update_menu();
-    Ok(Config::profiles().data().clone())
+pub async fn get_profiles() -> CmdResult<IProfiles> {
+    // 策略1: 尝试快速获取latest数据
+    let latest_result = tokio::time::timeout(
+        Duration::from_millis(500),
+        AsyncHandler::spawn_blocking(move || {
+            let profiles = Config::profiles();
+            let latest = profiles.latest_ref();
+            IProfiles {
+                current: latest.current.clone(),
+                items: latest.items.clone(),
+            }
+        }),
+    )
+    .await;
+
+    match latest_result {
+        Ok(Ok(profiles)) => {
+            logging!(info, Type::Cmd, false, "快速获取配置列表成功");
+            return Ok(profiles);
+        }
+        Ok(Err(join_err)) => {
+            logging!(warn, Type::Cmd, true, "快速获取配置任务失败: {}", join_err);
+        }
+        Err(_) => {
+            logging!(warn, Type::Cmd, true, "快速获取配置超时(500ms)");
+        }
+    }
+
+    // 策略2: 如果快速获取失败，尝试获取data()
+    let data_result = tokio::time::timeout(
+        Duration::from_secs(2),
+        AsyncHandler::spawn_blocking(move || {
+            let profiles = Config::profiles();
+            let data = profiles.latest_ref();
+            IProfiles {
+                current: data.current.clone(),
+                items: data.items.clone(),
+            }
+        }),
+    )
+    .await;
+
+    match data_result {
+        Ok(Ok(profiles)) => {
+            logging!(info, Type::Cmd, false, "获取draft配置列表成功");
+            return Ok(profiles);
+        }
+        Ok(Err(join_err)) => {
+            logging!(
+                error,
+                Type::Cmd,
+                true,
+                "获取draft配置任务失败: {}",
+                join_err
+            );
+        }
+        Err(_) => {
+            logging!(error, Type::Cmd, true, "获取draft配置超时(2秒)");
+        }
+    }
+
+    // 策略3: fallback，尝试重新创建配置
+    logging!(
+        warn,
+        Type::Cmd,
+        true,
+        "所有获取配置策略都失败，尝试fallback"
+    );
+
+    match AsyncHandler::spawn_blocking(IProfiles::new).await {
+        Ok(profiles) => {
+            logging!(info, Type::Cmd, true, "使用fallback配置成功");
+            Ok(profiles)
+        }
+        Err(err) => {
+            logging!(error, Type::Cmd, true, "fallback配置也失败: {}", err);
+            // 返回空配置避免崩溃
+            Ok(IProfiles {
+                current: None,
+                items: Some(vec![]),
+            })
+        }
+    }
 }

 /// 增强配置文件
@@ -25,33 +131,129 @@ pub async fn enhance_profiles() -> CmdResult {
 /// 导入配置文件
 #[tauri::command]
 pub async fn import_profile(url: String, option: Option<PrfOption>) -> CmdResult {
-    let item = wrap_err!(PrfItem::from_url(&url, None, None, option).await)?;
-    wrap_err!(Config::profiles().data().append_item(item))
+    logging!(info, Type::Cmd, true, "[导入订阅] 开始导入: {}", url);
+
+    // 使用超时保护避免长时间阻塞
+    let import_result = tokio::time::timeout(
+        Duration::from_secs(60), // 60秒超时
+        async {
+            let item = PrfItem::from_url(&url, None, None, option).await?;
+            logging!(info, Type::Cmd, true, "[导入订阅] 下载完成，开始保存配置");
+
+            // 获取导入前的配置数量用于验证
+            let pre_count = Config::profiles()
+                .latest_ref()
+                .items
+                .as_ref()
+                .map_or(0, |items| items.len());
+
+            Config::profiles().data_mut().append_item(item.clone())?;
+
+            // 验证导入是否成功
+            let post_count = Config::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 {
+                // 在异步块中重新获取锁，避免跨await问题
+                let save_result = { Config::profiles().data_mut().save_file() };
+
+                if let Err(e) = save_result {
+                    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())
+        }
+    }
 }

 /// 重新排序配置文件
 #[tauri::command]
 pub async fn reorder_profile(active_id: String, over_id: String) -> CmdResult {
-    wrap_err!(Config::profiles().data().reorder(active_id, over_id))
+    wrap_err!(Config::profiles().data_mut().reorder(active_id, over_id))
 }

 /// 创建配置文件
 #[tauri::command]
 pub async fn create_profile(item: PrfItem, file_data: Option<String>) -> CmdResult {
    let item = wrap_err!(PrfItem::from(item, file_data).await)?;
-    wrap_err!(Config::profiles().data().append_item(item))
+    wrap_err!(Config::profiles().data_mut().append_item(item))
 }

 /// 更新配置文件
 #[tauri::command]
 pub async fn update_profile(index: String, option: Option<PrfOption>) -> CmdResult {
-    wrap_err!(feat::update_profile(index, option).await)
+    wrap_err!(feat::update_profile(index, option, Some(true)).await)
 }

 /// 删除配置文件
 #[tauri::command]
 pub async fn delete_profile(index: String) -> CmdResult {
-    let should_update = wrap_err!({ Config::profiles().data().delete_item(index) })?;
+    let should_update = wrap_err!({ Config::profiles().data_mut().delete_item(index) })?;
+
+    // 删除后自动清理冗余文件
+    let _ = Config::profiles().latest_ref().auto_cleanup();
+
    if should_update {
        wrap_err!(CoreManager::global().update_config().await)?;
        handle::Handle::refresh_clash();
@@ -62,10 +264,63 @@ pub async fn delete_profile(index: String) -> CmdResult {
 /// 修改profiles的配置
 #[tauri::command]
 pub async fn patch_profiles_config(profiles: IProfiles) -> CmdResult<bool> {
-    logging!(info, Type::Cmd, true, "开始修改配置文件");
+    // 为当前请求分配序列号
+    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 mutex_result =
+        tokio::time::timeout(Duration::from_millis(100), PROFILE_UPDATE_MUTEX.lock()).await;
+
+    let _guard = match mutex_result {
+        Ok(guard) => guard,
+        Err(_) => {
+            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,
+                "强制获取锁以处理最新请求: {}",
+                current_sequence
+            );
+            PROFILE_UPDATE_MUTEX.lock().await
+        }
+    };
+
+    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);
+    }

    // 保存当前配置，以便在验证失败时恢复
-    let current_profile = Config::profiles().latest().current.clone();
+    let current_profile = Config::profiles().latest_ref().current.clone();
    logging!(info, Type::Cmd, true, "当前配置: {:?}", current_profile);

    // 如果要切换配置，先检查目标配置文件是否有语法错误
@@ -74,21 +329,23 @@ pub async fn patch_profiles_config(profiles: IProfiles) -> CmdResult<bool> {
            logging!(info, Type::Cmd, true, "正在切换到新配置: {}", new_profile);

            // 获取目标配置文件路径
-            let profiles_config = Config::profiles();
-            let profiles_data = profiles_config.latest();
-            let config_file_result = match profiles_data.get_item(new_profile) {
-                Ok(item) => {
-                    if let Some(file) = &item.file {
-                        let path = dirs::app_profiles_dir().map(|dir| dir.join(file));
-                        path.ok()
-                    } else {
+            let config_file_result = {
+                let profiles_config = Config::profiles();
+                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 {
+                            None
+                        }
+                    }
+                    Err(e) => {
+                        logging!(error, Type::Cmd, true, "获取目标配置信息失败: {}", e);
                        None
                    }
                }
-                Err(e) => {
-                    logging!(error, Type::Cmd, true, "获取目标配置信息失败: {}", e);
-                    None
-                }
            };

            // 如果获取到文件路径，检查YAML语法
@@ -108,29 +365,52 @@ pub async fn patch_profiles_config(profiles: IProfiles) -> CmdResult<bool> {
                    return Ok(false);
                }

-                match std::fs::read_to_string(&file_path) {
-                    Ok(content) => match serde_yaml::from_str::<serde_yaml::Value>(&content) {
-                        Ok(_) => {
-                            logging!(info, Type::Cmd, true, "目标配置文件语法正确");
+                // 超时保护
+                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::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);
+                            }
                        }
-                        Err(err) => {
-                            let error_msg = format!(" {}", err);
-                            logging!(
-                                error,
-                                Type::Cmd,
-                                true,
-                                "目标配置文件存在YAML语法错误:{}",
-                                error_msg
-                            );
-                            handle::Handle::notice_message(
-                                "config_validate::yaml_syntax_error",
-                                &error_msg,
-                            );
-                            return Ok(false);
-                        }
-                    },
-                    Err(err) => {
-                        let error_msg = format!("无法读取目标配置文件: {}", err);
+                    }
+                    Ok(Err(err)) => {
+                        let error_msg = format!("无法读取目标配置文件: {err}");
                        logging!(error, Type::Cmd, true, "{}", error_msg);
                        handle::Handle::notice_message(
                            "config_validate::file_read_error",
@@ -138,26 +418,156 @@ pub async fn patch_profiles_config(profiles: IProfiles) -> CmdResult<bool> {
                        );
                        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);
+    }
+
+    if let Some(ref profile) = target_profile {
+        *CURRENT_PROCESSING_PROFILE.write().await = Some(profile.clone());
+        logging!(
+            info,
+            Type::Cmd,
+            true,
+            "设置当前处理profile: {}, 序列号: {}",
+            profile,
+            current_sequence
+        );
+    }
+
    // 更新profiles配置
-    logging!(info, Type::Cmd, true, "正在更新配置草稿");
-    let _ = Config::profiles().draft().patch_config(profiles);
+    logging!(
+        info,
+        Type::Cmd,
+        true,
+        "正在更新配置草稿，序列号: {}",
+        current_sequence
+    );
+
+    let current_value = profiles.current.clone();
+
+    let _ = Config::profiles().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().discard();
+        return Ok(false);
+    }
+
+    // 为配置更新添加超时保护
+    logging!(
+        info,
+        Type::Cmd,
+        true,
+        "开始内核配置更新，序列号: {}",
+        current_sequence
+    );
+    let update_result = tokio::time::timeout(
+        Duration::from_secs(30), // 30秒超时
+        CoreManager::global().update_config(),
+    )
+    .await;

    // 更新配置并进行验证
-    match CoreManager::global().update_config().await {
-        Ok((true, _)) => {
-            logging!(info, Type::Cmd, true, "配置更新成功");
-            handle::Handle::refresh_clash();
-            let _ = Tray::global().update_tooltip();
+    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().discard();
+                return Ok(false);
+            }
+
+            logging!(
+                info,
+                Type::Cmd,
+                true,
+                "配置更新成功，序列号: {}",
+                current_sequence
+            );
            Config::profiles().apply();
-            wrap_err!(Config::profiles().data().save_file())?;
+            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}");
+                }
+            });
+
+            crate::process::AsyncHandler::spawn(|| async move {
+                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_mut().save_file() {
+                    log::warn!(target: "app", "异步保存配置文件失败: {e}");
+                }
+            });
+
+            // 立即通知前端配置变更
+            if let Some(current) = &current_value {
+                logging!(
+                    info,
+                    Type::Cmd,
+                    true,
+                    "向前端发送配置变更事件: {}, 序列号: {}",
+                    current,
+                    current_sequence
+                );
+                handle::Handle::notify_profile_changed(current.clone());
+            }
+
+            cleanup_processing_state(current_sequence, "配置切换完成").await;
+
            Ok(true)
        }
-        Ok((false, error_msg)) => {
+        Ok(Ok((false, error_msg))) => {
            logging!(warn, Type::Cmd, true, "配置验证失败: {}", error_msg);
            Config::profiles().discard();
            // 如果验证失败，恢复到之前的配置
@@ -174,20 +584,83 @@ pub async fn patch_profiles_config(profiles: IProfiles) -> CmdResult<bool> {
                    items: None,
                };
                // 静默恢复，不触发验证
-                wrap_err!({ Config::profiles().draft().patch_config(restore_profiles) })?;
+                wrap_err!({
+                    Config::profiles()
+                        .draft_mut()
+                        .patch_config(restore_profiles)
+                })?;
                Config::profiles().apply();
-                wrap_err!(Config::profiles().data().save_file())?;
+
+                crate::process::AsyncHandler::spawn(|| async move {
+                    if let Err(e) = Config::profiles().data_mut().save_file() {
+                        log::warn!(target: "app", "异步保存恢复配置文件失败: {e}");
+                    }
+                });
+
                logging!(info, Type::Cmd, true, "成功恢复到之前的配置");
            }

            // 发送验证错误通知
            handle::Handle::notice_message("config_validate::error", &error_msg);
+
+            cleanup_processing_state(current_sequence, "配置验证失败").await;
+
            Ok(false)
        }
-        Err(e) => {
-            logging!(warn, Type::Cmd, true, "更新过程发生错误: {}", e);
+        Ok(Err(e)) => {
+            logging!(
+                warn,
+                Type::Cmd,
+                true,
+                "更新过程发生错误: {}, 序列号: {}",
+                e,
+                current_sequence
+            );
            Config::profiles().discard();
            handle::Handle::notice_message("config_validate::boot_error", e.to_string());
+
+            cleanup_processing_state(current_sequence, "更新过程错误").await;
+
+            Ok(false)
+        }
+        Err(_) => {
+            // 超时处理
+            let timeout_msg = "配置更新超时(30秒)，可能是配置验证或核心通信阻塞";
+            logging!(
+                error,
+                Type::Cmd,
+                true,
+                "{}, 序列号: {}",
+                timeout_msg,
+                current_sequence
+            );
+            Config::profiles().discard();
+
+            if let Some(prev_profile) = current_profile {
+                logging!(
+                    info,
+                    Type::Cmd,
+                    true,
+                    "超时后尝试恢复到之前的配置: {}, 序列号: {}",
+                    prev_profile,
+                    current_sequence
+                );
+                let restore_profiles = IProfiles {
+                    current: Some(prev_profile),
+                    items: None,
+                };
+                wrap_err!({
+                    Config::profiles()
+                        .draft_mut()
+                        .patch_config(restore_profiles)
+                })?;
+                Config::profiles().apply();
+            }
+
+            handle::Handle::notice_message("config_validate::timeout", timeout_msg);
+
+            cleanup_processing_state(current_sequence, "配置更新超时").await;
+
            Ok(false)
        }
    }
@@ -211,7 +684,35 @@ pub async fn patch_profiles_config_by_profile_index(
 /// 修改某个profile item的
 #[tauri::command]
 pub fn patch_profile(index: String, profile: PrfItem) -> CmdResult {
-    wrap_err!(Config::profiles().data().patch_item(index, profile))?;
+    // 保存修改前检查是否有更新 update_interval
+    let update_interval_changed =
+        if let Ok(old_profile) = Config::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
+        };
+
+    // 保存修改
+    wrap_err!(Config::profiles()
+        .data_mut()
+        .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() {
+                logging!(error, Type::Timer, "刷新定时器失败: {}", e);
+            } else {
+                // 刷新成功后发送自定义事件，不触发配置重载
+                crate::core::handle::Handle::notify_timer_updated(index_clone);
+            }
+        });
+    }
+
    Ok(())
 }

@@ -219,7 +720,7 @@ pub fn patch_profile(index: String, profile: PrfItem) -> CmdResult {
 #[tauri::command]
 pub fn view_profile(app_handle: tauri::AppHandle, index: String) -> CmdResult {
    let file = {
-        wrap_err!(Config::profiles().latest().get_item(&index))?
+        wrap_err!(Config::profiles().latest_ref().get_item(&index))?
            .file
            .clone()
            .ok_or("the file field is null")
@@ -237,8 +738,16 @@ pub fn view_profile(app_handle: tauri::AppHandle, index: String) -> CmdResult {
 #[tauri::command]
 pub fn read_profile_file(index: String) -> CmdResult<String> {
    let profiles = Config::profiles();
-    let profiles = profiles.latest();
+    let profiles = profiles.latest_ref();
    let item = wrap_err!(profiles.get_item(&index))?;
    let data = wrap_err!(item.read_file())?;
    Ok(data)
 }
+
+/// 获取下一次更新时间
+#[tauri::command]
+pub fn get_next_update_time(uid: String) -> CmdResult<Option<i64>> {
+    let timer = Timer::global();
+    let next_time = timer.get_next_update_time(&uid);
+    Ok(next_time)
+}
@@ -1,24 +1,47 @@
 use super::CmdResult;
-use crate::module::mihomo::MihomoManager;
+use crate::{ipc::IpcManager, logging, state::proxy::ProxyRequestCache, utils::logging::Type};
+use std::time::Duration;
+
+const PROXIES_REFRESH_INTERVAL: Duration = Duration::from_secs(60);
+const PROVIDERS_REFRESH_INTERVAL: Duration = Duration::from_secs(60);

 #[tauri::command]
 pub async fn get_proxies() -> CmdResult<serde_json::Value> {
-    let mannager = MihomoManager::global();
+    let manager = IpcManager::global();
+    let cache = ProxyRequestCache::global();
+    let key = ProxyRequestCache::make_key("proxies", "default");
+    let value = cache
+        .get_or_fetch(key, PROXIES_REFRESH_INTERVAL, || async {
+            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())
+}

-    mannager
-        .refresh_proxies()
-        .await
-        .map(|_| mannager.get_proxies())
-        .or_else(|_| Ok(mannager.get_proxies()))
+/// 强制刷新代理缓存用于profile切换
+#[tauri::command]
+pub async fn force_refresh_proxies() -> CmdResult<serde_json::Value> {
+    let cache = ProxyRequestCache::global();
+    let key = ProxyRequestCache::make_key("proxies", "default");
+    cache.map.remove(&key);
+    get_proxies().await
 }

 #[tauri::command]
 pub async fn get_providers_proxies() -> CmdResult<serde_json::Value> {
-    let mannager = MihomoManager::global();
-
-    mannager
-        .refresh_providers_proxies()
-        .await
-        .map(|_| mannager.get_providers_proxies())
-        .or_else(|_| Ok(mannager.get_providers_proxies()))
+    let manager = IpcManager::global();
+    let cache = ProxyRequestCache::global();
+    let key = ProxyRequestCache::make_key("providers", "default");
+    let value = cache
+        .get_or_fetch(key, PROVIDERS_REFRESH_INTERVAL, || async {
+            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())
 }
@@ -7,14 +7,14 @@ use std::collections::HashMap;
 /// 获取运行时配置
 #[tauri::command]
 pub fn get_runtime_config() -> CmdResult<Option<Mapping>> {
-    Ok(Config::runtime().latest().config.clone())
+    Ok(Config::runtime().latest_ref().config.clone())
 }

 /// 获取运行时YAML配置
 #[tauri::command]
 pub fn get_runtime_yaml() -> CmdResult<String> {
    let runtime = Config::runtime();
-    let runtime = runtime.latest();
+    let runtime = runtime.latest_ref();
    let config = runtime.config.as_ref();
    wrap_err!(config
        .ok_or(anyhow::anyhow!("failed to parse config to yaml file"))
@@ -26,11 +26,11 @@ pub fn get_runtime_yaml() -> CmdResult<String> {
 /// 获取运行时存在的键
 #[tauri::command]
 pub fn get_runtime_exists() -> CmdResult<Vec<String>> {
-    Ok(Config::runtime().latest().exists_keys.clone())
+    Ok(Config::runtime().latest_ref().exists_keys.clone())
 }

 /// 获取运行时日志
 #[tauri::command]
 pub fn get_runtime_logs() -> CmdResult<HashMap<String, Vec<(String, String)>>> {
-    Ok(Config::runtime().latest().chain_logs.clone())
+    Ok(Config::runtime().latest_ref().chain_logs.clone())
 }
@@ -1,5 +1,11 @@
 use super::CmdResult;
-use crate::{config::*, core::*, utils::dirs, wrap_err};
+use crate::{
+    config::*,
+    core::*,
+    logging,
+    utils::{dirs, logging::Type},
+    wrap_err,
+};
 use std::fs;

 /// 保存profiles的配置
@@ -12,7 +18,7 @@ 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();
-        let profiles_guard = profiles.latest();
+        let profiles_guard = profiles.latest_ref();
        let item = wrap_err!(profiles_guard.get_item(&index))?;
        // 确定是否为merge类型文件
        let is_merge = item.itype.as_ref().is_some_and(|t| t == "merge");
@@ -23,32 +29,64 @@ pub async fn save_profile_file(index: String, file_data: Option<String>) -> CmdR
    };

    // 保存新的配置文件
-    wrap_err!(fs::write(&file_path, file_data.clone().unwrap()))?;
+    let file_data = file_data.ok_or("file_data is None")?;
+    wrap_err!(fs::write(&file_path, &file_data))?;

    let file_path_str = file_path.to_string_lossy().to_string();
-    println!(
+    logging!(
+        info,
+        Type::Config,
+        true,
        "[cmd配置save] 开始验证配置文件: {}, 是否为merge文件: {}",
-        file_path_str, is_merge_file
+        file_path_str,
+        is_merge_file
    );

    // 对于 merge 文件，只进行语法验证，不进行后续内核验证
    if is_merge_file {
-        println!("[cmd配置save] 检测到merge文件，只进行语法验证");
+        logging!(
+            info,
+            Type::Config,
+            true,
+            "[cmd配置save] 检测到merge文件，只进行语法验证"
+        );
        match CoreManager::global()
            .validate_config_file(&file_path_str, Some(true))
            .await
        {
            Ok((true, _)) => {
-                println!("[cmd配置save] merge文件语法验证通过");
+                logging!(
+                    info,
+                    Type::Config,
+                    true,
+                    "[cmd配置save] merge文件语法验证通过"
+                );
                // 成功后尝试更新整体配置
-                if let Err(e) = CoreManager::global().update_config().await {
-                    println!("[cmd配置save] 更新整体配置时发生错误: {}", e);
-                    log::warn!(target: "app", "更新整体配置时发生错误: {}", e);
+                match CoreManager::global().update_config().await {
+                    Ok(_) => {
+                        // 配置更新成功，刷新前端
+                        handle::Handle::refresh_clash();
+                    }
+                    Err(e) => {
+                        logging!(
+                            warn,
+                            Type::Config,
+                            true,
+                            "[cmd配置save] 更新整体配置时发生错误: {}",
+                            e
+                        );
+                    }
                }
                return Ok(());
            }
            Ok((false, error_msg)) => {
-                println!("[cmd配置save] merge文件语法验证失败: {}", error_msg);
+                logging!(
+                    warn,
+                    Type::Config,
+                    true,
+                    "[cmd配置save] merge文件语法验证失败: {}",
+                    error_msg
+                );
                // 恢复原始配置文件
                wrap_err!(fs::write(&file_path, original_content))?;
                // 发送合并文件专用错误通知
@@ -57,7 +95,13 @@ pub async fn save_profile_file(index: String, file_data: Option<String>) -> CmdR
                return Ok(());
            }
            Err(e) => {
-                println!("[cmd配置save] 验证过程发生错误: {}", e);
+                logging!(
+                    error,
+                    Type::Config,
+                    true,
+                    "[cmd配置save] 验证过程发生错误: {}",
+                    e
+                );
                // 恢复原始配置文件
                wrap_err!(fs::write(&file_path, original_content))?;
                return Err(e.to_string());
@@ -71,11 +115,17 @@ pub async fn save_profile_file(index: String, file_data: Option<String>) -> CmdR
        .await
    {
        Ok((true, _)) => {
-            println!("[cmd配置save] 验证成功");
+            logging!(info, Type::Config, true, "[cmd配置save] 验证成功");
            Ok(())
        }
        Ok((false, error_msg)) => {
-            println!("[cmd配置save] 验证失败: {}", error_msg);
+            logging!(
+                warn,
+                Type::Config,
+                true,
+                "[cmd配置save] 验证失败: {}",
+                error_msg
+            );
            // 恢复原始配置文件
            wrap_err!(fs::write(&file_path, original_content))?;

@@ -90,24 +140,42 @@ pub async fn save_profile_file(index: String, file_data: Option<String>) -> CmdR
                || (!file_path_str.ends_with(".js") && !is_script_error)
            {
                // 普通YAML错误使用YAML通知处理
-                println!("[cmd配置save] YAML配置文件验证失败，发送通知");
+                logging!(
+                    info,
+                    Type::Config,
+                    "[cmd配置save] YAML配置文件验证失败，发送通知"
+                );
                let result = (false, error_msg.clone());
                crate::cmd::validate::handle_yaml_validation_notice(&result, "YAML配置文件");
            } else if is_script_error {
                // 脚本错误使用专门的通知处理
-                println!("[cmd配置save] 脚本文件验证失败，发送通知");
+                logging!(
+                    info,
+                    Type::Config,
+                    "[cmd配置save] 脚本文件验证失败，发送通知"
+                );
                let result = (false, error_msg.clone());
                crate::cmd::validate::handle_script_validation_notice(&result, "脚本文件");
            } else {
                // 普通配置错误使用一般通知
-                println!("[cmd配置save] 其他类型验证失败，发送一般通知");
+                logging!(
+                    info,
+                    Type::Config,
+                    "[cmd配置save] 其他类型验证失败，发送一般通知"
+                );
                handle::Handle::notice_message("config_validate::error", &error_msg);
            }

            Ok(())
        }
        Err(e) => {
-            println!("[cmd配置save] 验证过程发生错误: {}", e);
+            logging!(
+                error,
+                Type::Config,
+                true,
+                "[cmd配置save] 验证过程发生错误: {}",
+                e
+            );
            // 恢复原始配置文件
            wrap_err!(fs::write(&file_path, original_content))?;
            Err(e.to_string())
@@ -3,13 +3,15 @@ use crate::{
    core::{service, CoreManager},
    utils::i18n::t,
 };
+use anyhow::Result;

-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");
+async fn execute_service_operation_sync<F, E>(service_op: F, op_type: &str) -> CmdResult
+where
+    F: FnOnce() -> Result<(), E>,
+    E: ToString + std::fmt::Debug,
+{
+    if let Err(e) = service_op() {
+        let emsg = format!("{} {} failed: {}", op_type, "Service", e.to_string());
        return Err(t(emsg.as_str()));
    }
    if CoreManager::global().restart_core().await.is_err() {
@@ -21,20 +23,28 @@ async fn execute_service_operation(

 #[tauri::command]
 pub async fn install_service() -> CmdResult {
-    execute_service_operation(service::install_service(), "Install").await
+    execute_service_operation_sync(service::install_service, "Install").await
 }

 #[tauri::command]
 pub async fn uninstall_service() -> CmdResult {
-    execute_service_operation(service::uninstall_service(), "Uninstall").await
+    execute_service_operation_sync(service::uninstall_service, "Uninstall").await
 }

 #[tauri::command]
 pub async fn reinstall_service() -> CmdResult {
-    execute_service_operation(service::reinstall_service(), "Reinstall").await
+    execute_service_operation_sync(service::reinstall_service, "Reinstall").await
 }

 #[tauri::command]
 pub async fn repair_service() -> CmdResult {
-    execute_service_operation(service::force_reinstall_service(), "Repair").await
+    execute_service_operation_sync(service::force_reinstall_service, "Repair").await
+}
+
+#[tauri::command]
+pub async fn is_service_available() -> CmdResult<bool> {
+    service::is_service_available()
+        .await
+        .map(|_| true)
+        .map_err(|e| e.to_string())
 }
@@ -1,7 +1,9 @@
 use super::CmdResult;
 use crate::{
    core::{handle, CoreManager},
+    logging,
    module::sysinfo::PlatformSpecification,
+    utils::logging::Type,
 };
 use once_cell::sync::Lazy;
 use std::{
@@ -23,28 +25,30 @@ static APP_START_TIME: Lazy<AtomicI64> = Lazy::new(|| {

 #[tauri::command]
 pub async fn export_diagnostic_info() -> CmdResult<()> {
-    let sysinfo = PlatformSpecification::new_async().await;
-    let info = format!("{:?}", sysinfo);
+    let sysinfo = PlatformSpecification::new_sync();
+    let info = format!("{sysinfo:?}");

-    let app_handle = handle::Handle::global().app_handle().unwrap();
+    let app_handle = handle::Handle::global()
+        .app_handle()
+        .ok_or("Failed to get app handle")?;
    let cliboard = app_handle.clipboard();
    if cliboard.write_text(info).is_err() {
-        log::error!(target: "app", "Failed to write to clipboard");
+        logging!(error, Type::System, "Failed to write to clipboard");
    }
    Ok(())
 }

 #[tauri::command]
 pub async fn get_system_info() -> CmdResult<String> {
-    let sysinfo = PlatformSpecification::new_async().await;
-    let info = format!("{:?}", sysinfo);
+    let sysinfo = PlatformSpecification::new_sync();
+    let info = format!("{sysinfo:?}");
    Ok(info)
 }

 /// 获取当前内核运行模式
 #[tauri::command]
 pub async fn get_running_mode() -> Result<String, String> {
-    Ok(CoreManager::global().get_running_mode().await.to_string())
+    Ok(CoreManager::global().get_running_mode().to_string())
 }

 /// 获取应用的运行时间（毫秒）
@@ -6,8 +6,8 @@ mod platform {
    use super::CmdResult;
    use crate::{core::win_uwp, wrap_err};

-    pub async fn invoke_uwp_tool() -> CmdResult {
-        wrap_err!(win_uwp::invoke_uwptools().await)
+    pub fn invoke_uwp_tool() -> CmdResult {
+        wrap_err!(win_uwp::invoke_uwptools())
    }
 }

@@ -16,7 +16,7 @@ mod platform {
 mod platform {
    use super::CmdResult;

-    pub async fn invoke_uwp_tool() -> CmdResult {
+    pub 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().await
+    platform::invoke_uwp_tool()
 }
@@ -1,5 +1,5 @@
 use super::CmdResult;
-use crate::core::*;
+use crate::{core::*, logging, utils::logging::Type};

 /// 发送脚本验证通知消息
 #[tauri::command]
@@ -28,7 +28,14 @@ pub fn handle_script_validation_notice(result: &(bool, String), file_type: &str)
            "config_validate::script_error"
        };

-        log::warn!(target: "app", "{} 验证失败: {}", file_type, error_msg);
+        logging!(
+            warn,
+            Type::Config,
+            true,
+            "{} 验证失败: {}",
+            file_type,
+            error_msg
+        );
        handle::Handle::notice_message(status, error_msg);
    }
 }
@@ -36,7 +43,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> {
-    log::info!(target: "app", "验证脚本文件: {}", file_path);
+    logging!(info, Type::Config, true, "验证脚本文件: {}", file_path);

    match CoreManager::global()
        .validate_config_file(&file_path, None)
@@ -48,7 +55,13 @@ pub async fn validate_script_file(file_path: String) -> CmdResult<bool> {
        }
        Err(e) => {
            let error_msg = e.to_string();
-            log::error!(target: "app", "验证脚本文件过程发生错误: {}", error_msg);
+            logging!(
+                error,
+                Type::Config,
+                true,
+                "验证脚本文件过程发生错误: {}",
+                error_msg
+            );
            handle::Handle::notice_message("config_validate::process_terminated", &error_msg);
            Ok(false)
        }
@@ -60,7 +73,14 @@ 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;
-        println!("[通知] 处理{}验证错误: {}", file_type, error_msg);
+        logging!(
+            info,
+            Type::Config,
+            true,
+            "[通知] 处理{}验证错误: {}",
+            file_type,
+            error_msg
+        );

        // 检查是否为merge文件
        let is_merge_file = file_type.contains("合并");
@@ -97,8 +117,22 @@ pub fn handle_yaml_validation_notice(result: &(bool, String), file_type: &str) {
            }
        };

-        log::warn!(target: "app", "{} 验证失败: {}", file_type, error_msg);
-        println!("[通知] 发送通知: status={}, msg={}", status, error_msg);
+        logging!(
+            warn,
+            Type::Config,
+            true,
+            "{} 验证失败: {}",
+            file_type,
+            error_msg
+        );
+        logging!(
+            info,
+            Type::Config,
+            true,
+            "[通知] 发送通知: status={}, msg={}",
+            status,
+            error_msg
+        );
        handle::Handle::notice_message(status, error_msg);
    }
 }
@@ -5,8 +5,8 @@ use crate::{config::*, feat, wrap_err};
 #[tauri::command]
 pub fn get_verge_config() -> CmdResult<IVergeResponse> {
    let verge = Config::verge();
-    let verge_data = verge.data().clone();
-    Ok(IVergeResponse::from(verge_data))
+    let verge_data = verge.latest_ref().clone();
+    Ok(IVergeResponse::from(*verge_data))
 }

 /// 修改Verge配置
@@ -11,10 +11,10 @@ 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().draft_mut().patch_config(patch.clone());
    Config::verge().apply();
    Config::verge()
-        .data()
+        .latest_ref()
        .save_file()
        .map_err(|err| err.to_string())?;
    core::backup::WebDavClient::global().reset();
@@ -1,3 +1,5 @@
+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};
@@ -17,9 +19,17 @@ impl IClashTemp {
            Ok(mut map) => {
                template.0.keys().for_each(|key| {
                    if !map.contains_key(key) {
-                        map.insert(key.clone(), template.0.get(key).unwrap().clone());
+                        if let Some(value) = template.0.get(key) {
+                            map.insert(key.clone(), value.clone());
+                        }
                    }
                });
+                // 确保 secret 字段存在且不为空
+                if let Some(Value::String(s)) = map.get_mut("secret") {
+                    if s.is_empty() {
+                        *s = "set-your-secret".to_string();
+                    }
+                }
                Self(Self::guard(map))
            }
            Err(err) => {
@@ -32,13 +42,13 @@ impl IClashTemp {
    pub fn template() -> Self {
        let mut map = Mapping::new();
        let mut tun = Mapping::new();
+        let mut cors_map = Mapping::new();
        tun.insert("enable".into(), false.into());
        tun.insert("stack".into(), "gvisor".into());
        tun.insert("auto-route".into(), true.into());
        tun.insert("strict-route".into(), false.into());
        tun.insert("auto-detect-interface".into(), true.into());
        tun.insert("dns-hijack".into(), vec!["any:53"].into());
-
        #[cfg(not(target_os = "windows"))]
        map.insert("redir-port".into(), 7895.into());
        #[cfg(target_os = "linux")]
@@ -46,14 +56,37 @@ impl IClashTemp {
        map.insert("mixed-port".into(), 7897.into());
        map.insert("socks-port".into(), 7898.into());
        map.insert("port".into(), 7899.into());
-        map.insert("log-level".into(), "info".into());
+        map.insert("log-level".into(), "warning".into());
        map.insert("allow-lan".into(), false.into());
+        map.insert("ipv6".into(), true.into());
        map.insert("mode".into(), "rule".into());
        map.insert("external-controller".into(), "127.0.0.1:9097".into());
-        let mut cors_map = Mapping::new();
+        #[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!["*"].into());
-        map.insert("secret".into(), "".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",
+                "https://board.zash.run.place",
+            ]
+            .into(),
+        );
+        map.insert("secret".into(), "set-your-secret".into());
        map.insert("tun".into(), tun.into());
        map.insert("external-controller-cors".into(), cors_map.into());
        map.insert("unified-delay".into(), true.into());
@@ -68,7 +101,12 @@ 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_server_ctrl(&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();
+
        #[cfg(not(target_os = "windows"))]
        config.insert("redir-port".into(), redir_port.into());
        #[cfg(target_os = "linux")]
@@ -77,6 +115,17 @@ impl IClashTemp {
        config.insert("socks-port".into(), socks_port.into());
        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(),
+        );
        config
    }

@@ -225,6 +274,26 @@ impl IClashTemp {
            .unwrap_or("127.0.0.1:9097".into())
    }

+    pub fn guard_external_controller(config: &Mapping) -> String {
+        // 在初始化阶段，直接返回配置中的值，不进行额外检查
+        // 这样可以避免在配置加载期间的循环依赖
+        Self::guard_server_ctrl(config)
+    }
+
+    pub fn guard_external_controller_with_setting(config: &Mapping) -> String {
+        // 检查 enable_external_controller 设置，用于运行时配置生成
+        let enable_external_controller = Config::verge()
+            .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()) {
@@ -237,6 +306,17 @@ 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)]
@@ -316,6 +396,13 @@ fn test_clash_info() {
    );
 }

+#[derive(Default, Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "kebab-case")]
+pub struct IClashExternalControllerCors {
+    pub allow_origins: Option<Vec<String>>,
+    pub allow_private_network: Option<bool>,
+}
+
 #[derive(Default, Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
 #[serde(rename_all = "kebab-case")]
 pub struct IClash {
@@ -329,6 +416,7 @@ pub struct IClash {
    pub dns: Option<IClashDNS>,
    pub tun: Option<IClashTUN>,
    pub interface_name: Option<String>,
+    pub external_controller_cors: Option<IClashExternalControllerCors>,
 }

 #[derive(Default, Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
@@ -3,6 +3,7 @@ use crate::{
    config::PrfItem,
    core::{handle, CoreManager},
    enhance, logging,
+    process::AsyncHandler,
    utils::{dirs, help, logging::Type},
 };
 use anyhow::{anyhow, Result};
@@ -14,10 +15,10 @@ pub const RUNTIME_CONFIG: &str = "clash-verge.yaml";
 pub const CHECK_CONFIG: &str = "clash-verge-check.yaml";

 pub struct Config {
-    clash_config: Draft<IClashTemp>,
-    verge_config: Draft<IVerge>,
-    profiles_config: Draft<IProfiles>,
-    runtime_config: Draft<IRuntime>,
+    clash_config: Draft<Box<IClashTemp>>,
+    verge_config: Draft<Box<IVerge>>,
+    profiles_config: Draft<Box<IProfiles>>,
+    runtime_config: Draft<Box<IRuntime>>,
 }

 impl Config {
@@ -25,49 +26,53 @@ impl 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()),
+            clash_config: Draft::from(Box::new(IClashTemp::new())),
+            verge_config: Draft::from(Box::new(IVerge::new())),
+            profiles_config: Draft::from(Box::new(IProfiles::new())),
+            runtime_config: Draft::from(Box::new(IRuntime::new())),
        })
    }

-    pub fn clash() -> Draft<IClashTemp> {
+    pub fn clash() -> Draft<Box<IClashTemp>> {
        Self::global().clash_config.clone()
    }

-    pub fn verge() -> Draft<IVerge> {
+    pub fn verge() -> Draft<Box<IVerge>> {
        Self::global().verge_config.clone()
    }

-    pub fn profiles() -> Draft<IProfiles> {
+    pub fn profiles() -> Draft<Box<IProfiles>> {
        Self::global().profiles_config.clone()
    }

-    pub fn runtime() -> Draft<IRuntime> {
+    pub fn runtime() -> Draft<Box<IRuntime>> {
        Self::global().runtime_config.clone()
    }

    /// 初始化订阅
    pub async fn init_config() -> Result<()> {
        if Self::profiles()
-            .data()
+            .latest_ref()
            .get_item(&"Merge".to_string())
            .is_err()
        {
            let merge_item = PrfItem::from_merge(Some("Merge".to_string()))?;
-            Self::profiles().data().append_item(merge_item.clone())?;
+            Self::profiles()
+                .data_mut()
+                .append_item(merge_item.clone())?;
        }
        if Self::profiles()
-            .data()
+            .latest_ref()
            .get_item(&"Script".to_string())
            .is_err()
        {
            let script_item = PrfItem::from_script(Some("Script".to_string()))?;
-            Self::profiles().data().append_item(script_item.clone())?;
+            Self::profiles()
+                .data_mut()
+                .append_item(script_item.clone())?;
        }
        // 生成运行时配置
-        if let Err(err) = Self::generate().await {
+        if let Err(err) = Self::generate() {
            logging!(error, Type::Config, true, "生成运行时配置失败: {}", err);
        } else {
            logging!(info, Type::Config, true, "生成运行时配置成功");
@@ -91,8 +96,7 @@ impl Config {
                            error_msg
                        );
                        CoreManager::global()
-                            .use_default_config("config_validate::boot_error", &error_msg)
-                            .await?;
+                            .use_default_config("config_validate::boot_error", &error_msg)?;
                        Some(("config_validate::boot_error", error_msg))
                    } else {
                        logging!(info, Type::Config, true, "配置验证成功");
@@ -102,22 +106,19 @@ impl Config {
                Err(err) => {
                    logging!(warn, Type::Config, true, "验证进程执行失败: {}", err);
                    CoreManager::global()
-                        .use_default_config("config_validate::process_terminated", "")
-                        .await?;
+                        .use_default_config("config_validate::process_terminated", "")?;
                    Some(("config_validate::process_terminated", String::new()))
                }
            }
        } else {
            logging!(warn, Type::Config, true, "生成配置文件失败，使用默认配置");
-            CoreManager::global()
-                .use_default_config("config_validate::error", "")
-                .await?;
+            CoreManager::global().use_default_config("config_validate::error", "")?;
            Some(("config_validate::error", String::new()))
        };

        // 在单独的任务中发送通知
        if let Some((msg_type, msg_content)) = validation_result {
-            tauri::async_runtime::spawn(async move {
+            AsyncHandler::spawn(move || async move {
                sleep(Duration::from_secs(2)).await;
                handle::Handle::notice_message(msg_type, &msg_content);
            });
@@ -134,7 +135,7 @@ impl Config {
        };

        let runtime = Config::runtime();
-        let runtime = runtime.latest();
+        let runtime = runtime.latest_ref();
        let config = runtime
            .config
            .as_ref()
@@ -145,14 +146,14 @@ impl Config {
    }

    /// 生成订阅存好
-    pub async fn generate() -> Result<()> {
-        let (config, exists_keys, logs) = enhance::enhance().await;
+    pub fn generate() -> Result<()> {
+        let (config, exists_keys, logs) = enhance::enhance();

-        *Config::runtime().draft() = IRuntime {
+        *Config::runtime().draft_mut() = Box::new(IRuntime {
            config: Some(config),
            exists_keys,
            chain_logs: logs,
-        };
+        });

        Ok(())
    }
@@ -163,3 +164,42 @@ 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>>>()
+        );
+    }
+}
@@ -1,127 +1,154 @@
-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<Mutex<(T, Option<T>)>>,
+    inner: Arc<RwLock<(T, Option<T>)>>,
 }

-macro_rules! draft_define {
-    ($id: ident) => {
-        impl Draft<$id> {
-            #[allow(unused)]
-            pub fn data(&self) -> MappedMutexGuard<$id> {
-                MutexGuard::map(self.inner.lock(), |guard| &mut guard.0)
-            }
-
-            pub fn latest(&self) -> MappedMutexGuard<$id> {
-                MutexGuard::map(self.inner.lock(), |inner| {
-                    if inner.1.is_none() {
-                        &mut inner.0
-                    } else {
-                        inner.1.as_mut().unwrap()
-                    }
-                })
-            }
-
-            pub fn draft(&self) -> MappedMutexGuard<$id> {
-                MutexGuard::map(self.inner.lock(), |inner| {
-                    if inner.1.is_none() {
-                        inner.1 = Some(inner.0.clone());
-                    }
-
-                    inner.1.as_mut().unwrap()
-                })
-            }
-
-            pub fn apply(&self) -> Option<$id> {
-                let mut inner = self.inner.lock();
-
-                match inner.1.take() {
-                    Some(draft) => {
-                        let old_value = inner.0.to_owned();
-                        inner.0 = draft.to_owned();
-                        Some(old_value)
-                    }
-                    None => None,
-                }
-            }
-
-            pub fn discard(&self) -> Option<$id> {
-                let mut inner = self.inner.lock();
-                inner.1.take()
-            }
+impl<T: Clone + ToOwned> From<T> for Draft<T> {
+    fn from(data: T) -> Self {
+        Self {
+            inner: Arc::new(RwLock::new((data, None))),
        }
-
-        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);
+/// 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")
+                })
+            });
+        }
+        // 已存在草稿，升级为写锁映射
+        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()
+    }
+}

 #[test]
-fn test_draft() {
-    let verge = IVerge {
+fn test_draft_box() {
+    use super::IVerge;
+
+    // 1. 创建 Draft<Box<IVerge>>
+    let verge = Box::new(IVerge {
        enable_auto_launch: Some(true),
        enable_tun_mode: Some(false),
        ..IVerge::default()
-    };
-
+    });
    let draft = Draft::from(verge);

-    assert_eq!(draft.data().enable_auto_launch, Some(true));
-    assert_eq!(draft.data().enable_tun_mode, Some(false));
+    // 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.draft().enable_auto_launch, Some(true));
-    assert_eq!(draft.draft().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));
+    }

-    let mut d = draft.draft();
-    d.enable_auto_launch = Some(false);
-    d.enable_tun_mode = Some(true);
-    drop(d);
+    // 4. 修改草稿
+    {
+        let mut d = draft.draft_mut();
+        d.enable_auto_launch = Some(false);
+        d.enable_tun_mode = Some(true);
+    }

-    assert_eq!(draft.data().enable_auto_launch, Some(true));
-    assert_eq!(draft.data().enable_tun_mode, Some(false));
+    // 正式数据未变
+    assert_eq!(draft.data_mut().enable_auto_launch, Some(true));
+    assert_eq!(draft.data_mut().enable_tun_mode, Some(false));

-    assert_eq!(draft.draft().enable_auto_launch, Some(false));
-    assert_eq!(draft.draft().enable_tun_mode, Some(true));
+    // 草稿已变
+    {
+        let latest = draft.latest_ref();
+        assert_eq!(latest.enable_auto_launch, Some(false));
+        assert_eq!(latest.enable_tun_mode, Some(true));
+    }

-    assert_eq!(draft.latest().enable_auto_launch, Some(false));
-    assert_eq!(draft.latest().enable_tun_mode, Some(true));
+    // 5. 提交草稿
+    assert!(draft.apply().is_some()); // 第一次提交应有返回
+    assert!(draft.apply().is_none()); // 第二次提交返回 None

-    assert!(draft.apply().is_some());
-    assert!(draft.apply().is_none());
+    // 正式数据已更新
+    {
+        let data = draft.data_mut();
+        assert_eq!(data.enable_auto_launch, Some(false));
+        assert_eq!(data.enable_tun_mode, Some(true));
+    }

-    assert_eq!(draft.data().enable_auto_launch, Some(false));
-    assert_eq!(draft.data().enable_tun_mode, Some(true));
+    // 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.draft().enable_auto_launch, Some(false));
-    assert_eq!(draft.draft().enable_tun_mode, Some(true));
+    // 7. 丢弃草稿
+    assert!(draft.discard().is_some()); // 第一次丢弃返回 Some
+    assert!(draft.discard().is_none()); // 再次丢弃返回 None

-    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));
+    // 8. 草稿已被丢弃，新的 draft_mut() 会重新 clone
+    assert_eq!(draft.draft_mut().enable_auto_launch, Some(false));
 }
@@ -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())
 }
@@ -1,10 +1,13 @@
-use crate::utils::{dirs, help, resolve::VERSION, tmpl};
+use crate::utils::{
+    dirs, help,
+    network::{NetworkManager, ProxyType},
+    tmpl,
+};
 use anyhow::{bail, Context, Result};
 use reqwest::StatusCode;
 use serde::{Deserialize, Serialize};
 use serde_yaml::Mapping;
-use std::fs;
-use sysproxy::Sysproxy;
+use std::{fs, time::Duration};

 use super::Config;

@@ -89,6 +92,12 @@ pub struct PrfOption {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub update_interval: Option<u64>,

+    /// for `remote` profile
+    /// HTTP request timeout in seconds
+    /// default is 60 seconds
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub timeout_seconds: Option<u64>,
+
    /// for `remote` profile
    /// disable certificate validation
    /// default is `false`
@@ -122,6 +131,7 @@ impl PrfOption {
                a.rules = b.rules.or(a.rules);
                a.proxies = b.proxies.or(a.proxies);
                a.groups = b.groups.or(a.groups);
+                a.timeout_seconds = b.timeout_seconds.or(a.timeout_seconds);
                Some(a)
            }
            t => t.0.or(t.1),
@@ -137,12 +147,15 @@ impl PrfItem {
            bail!("type should not be null");
        }

-        match item.itype.unwrap().as_str() {
+        let itype = item
+            .itype
+            .ok_or_else(|| anyhow::anyhow!("type should not be null"))?;
+        match itype.as_str() {
            "remote" => {
-                if item.url.is_none() {
-                    bail!("url should not be null");
-                }
-                let url = item.url.as_ref().unwrap().as_str();
+                let url = item
+                    .url
+                    .as_ref()
+                    .ok_or_else(|| anyhow::anyhow!("url should not be null"))?;
                let name = item.name;
                let desc = item.desc;
                PrfItem::from_url(url, name, desc, item.option).await
@@ -176,29 +189,37 @@ impl PrfItem {

        if merge.is_none() {
            let merge_item = PrfItem::from_merge(None)?;
-            Config::profiles().data().append_item(merge_item.clone())?;
+            Config::profiles()
+                .data_mut()
+                .append_item(merge_item.clone())?;
            merge = merge_item.uid;
        }
        if script.is_none() {
            let script_item = PrfItem::from_script(None)?;
-            Config::profiles().data().append_item(script_item.clone())?;
+            Config::profiles()
+                .data_mut()
+                .append_item(script_item.clone())?;
            script = script_item.uid;
        }
        if rules.is_none() {
            let rules_item = PrfItem::from_rules()?;
-            Config::profiles().data().append_item(rules_item.clone())?;
+            Config::profiles()
+                .data_mut()
+                .append_item(rules_item.clone())?;
            rules = rules_item.uid;
        }
        if proxies.is_none() {
            let proxies_item = PrfItem::from_proxies()?;
            Config::profiles()
-                .data()
+                .data_mut()
                .append_item(proxies_item.clone())?;
            proxies = proxies_item.uid;
        }
        if groups.is_none() {
            let groups_item = PrfItem::from_groups()?;
-            Config::profiles().data().append_item(groups_item.clone())?;
+            Config::profiles()
+                .data_mut()
+                .append_item(groups_item.clone())?;
            groups = groups_item.uid;
        }
        Ok(PrfItem {
@@ -240,58 +261,39 @@ impl PrfItem {
            opt_ref.is_some_and(|o| o.danger_accept_invalid_certs.unwrap_or(false));
        let user_agent = opt_ref.and_then(|o| o.user_agent.clone());
        let update_interval = opt_ref.and_then(|o| o.update_interval);
+        let timeout = opt_ref.and_then(|o| o.timeout_seconds).unwrap_or(20);
        let mut merge = opt_ref.and_then(|o| o.merge.clone());
        let mut script = opt_ref.and_then(|o| o.script.clone());
        let mut rules = opt_ref.and_then(|o| o.rules.clone());
        let mut proxies = opt_ref.and_then(|o| o.proxies.clone());
        let mut groups = opt_ref.and_then(|o| o.groups.clone());
-        let mut builder = reqwest::ClientBuilder::new().use_rustls_tls().no_proxy();

-        // 使用软件自己的代理
-        if self_proxy {
-            let port = Config::verge()
-                .latest()
-                .verge_mixed_port
-                .unwrap_or(Config::clash().data().get_mixed_port());
-
-            let proxy_scheme = format!("http://127.0.0.1:{port}");
-
-            if let Ok(proxy) = reqwest::Proxy::http(&proxy_scheme) {
-                builder = builder.proxy(proxy);
-            }
-            if let Ok(proxy) = reqwest::Proxy::https(&proxy_scheme) {
-                builder = builder.proxy(proxy);
-            }
-            if let Ok(proxy) = reqwest::Proxy::all(&proxy_scheme) {
-                builder = builder.proxy(proxy);
-            }
-        }
-        // 使用系统代理
-        else if with_proxy {
-            if let Ok(p @ Sysproxy { enable: true, .. }) = Sysproxy::get_system_proxy() {
-                let proxy_scheme = format!("http://{}:{}", p.host, p.port);
-
-                if let Ok(proxy) = reqwest::Proxy::http(&proxy_scheme) {
-                    builder = builder.proxy(proxy);
-                }
-                if let Ok(proxy) = reqwest::Proxy::https(&proxy_scheme) {
-                    builder = builder.proxy(proxy);
-                }
-                if let Ok(proxy) = reqwest::Proxy::all(&proxy_scheme) {
-                    builder = builder.proxy(proxy);
-                }
-            }
-        }
-
-        let version = match VERSION.get() {
-            Some(v) => format!("clash-verge/v{}", v),
-            None => "clash-verge/unknown".to_string(),
+        // 选择代理类型
+        let proxy_type = if self_proxy {
+            ProxyType::Localhost
+        } else if with_proxy {
+            ProxyType::System
+        } else {
+            ProxyType::None
        };

-        builder = builder.danger_accept_invalid_certs(accept_invalid_certs);
-        builder = builder.user_agent(user_agent.unwrap_or(version));
-
-        let resp = builder.build()?.get(url).send().await?;
+        // 使用网络管理器发送请求
+        let resp = match NetworkManager::global()
+            .get_with_interrupt(
+                url,
+                proxy_type,
+                Some(timeout),
+                user_agent.clone(),
+                accept_invalid_certs,
+            )
+            .await
+        {
+            Ok(r) => r,
+            Err(e) => {
+                tokio::time::sleep(Duration::from_millis(100)).await;
+                bail!("failed to fetch remote profile: {}", e);
+            }
+        };

        let status_code = resp.status();
        if !StatusCode::is_success(&status_code) {
@@ -375,29 +377,37 @@ impl PrfItem {

        if merge.is_none() {
            let merge_item = PrfItem::from_merge(None)?;
-            Config::profiles().data().append_item(merge_item.clone())?;
+            Config::profiles()
+                .data_mut()
+                .append_item(merge_item.clone())?;
            merge = merge_item.uid;
        }
        if script.is_none() {
            let script_item = PrfItem::from_script(None)?;
-            Config::profiles().data().append_item(script_item.clone())?;
+            Config::profiles()
+                .data_mut()
+                .append_item(script_item.clone())?;
            script = script_item.uid;
        }
        if rules.is_none() {
            let rules_item = PrfItem::from_rules()?;
-            Config::profiles().data().append_item(rules_item.clone())?;
+            Config::profiles()
+                .data_mut()
+                .append_item(rules_item.clone())?;
            rules = rules_item.uid;
        }
        if proxies.is_none() {
            let proxies_item = PrfItem::from_proxies()?;
            Config::profiles()
-                .data()
+                .data_mut()
                .append_item(proxies_item.clone())?;
            proxies = proxies_item.uid;
        }
        if groups.is_none() {
            let groups_item = PrfItem::from_groups()?;
-            Config::profiles().data().append_item(groups_item.clone())?;
+            Config::profiles()
+                .data_mut()
+                .append_item(groups_item.clone())?;
            groups = groups_item.uid;
        }

@@ -542,22 +552,20 @@ impl PrfItem {

    /// get the file data
    pub fn read_file(&self) -> Result<String> {
-        if self.file.is_none() {
-            bail!("could not find the file");
-        }
-
-        let file = self.file.clone().unwrap();
+        let file = self
+            .file
+            .clone()
+            .ok_or_else(|| anyhow::anyhow!("could not find the file"))?;
        let path = dirs::app_profiles_dir()?.join(file);
        fs::read_to_string(path).context("failed to read the file")
    }

    /// save the file data
    pub fn save_file(&self, data: String) -> Result<()> {
-        if self.file.is_none() {
-            bail!("could not find the file");
-        }
-
-        let file = self.file.clone().unwrap();
+        let file = self
+            .file
+            .clone()
+            .ok_or_else(|| anyhow::anyhow!("could not find the file"))?;
        let path = dirs::app_profiles_dir()?.join(file);
        fs::write(path, data.as_bytes()).context("failed to save the file")
    }
@@ -3,7 +3,7 @@ use crate::utils::{dirs, help};
 use anyhow::{bail, Context, Result};
 use serde::{Deserialize, Serialize};
 use serde_yaml::Mapping;
-use std::{fs, io::Write};
+use std::{collections::HashSet, fs, io::Write};

 /// Define the `profiles.yaml` schema
 #[derive(Default, Debug, Clone, Deserialize, Serialize)]
@@ -15,6 +15,14 @@ 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() {
@@ -69,10 +77,11 @@ impl IProfiles {
        }

        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;
+            if let Some(items) = self.items.as_ref() {
+                let some_uid = Some(current);
+                if items.iter().any(|e| e.uid == some_uid) {
+                    self.current = some_uid;
+                }
            }
        }

@@ -119,13 +128,15 @@ impl IProfiles {
                bail!("the file should not be null");
            }

-            let file = item.file.clone().unwrap();
+            let file = item.file.clone().ok_or_else(|| {
+                anyhow::anyhow!("file field is required when file_data is provided")
+            })?;
            let path = dirs::app_profiles_dir()?.join(&file);

            fs::File::create(path)
-                .with_context(|| format!("failed to create file \"{}\"", file))?
+                .with_context(|| format!("failed to create file \"{file}\""))?
                .write(file_data.as_bytes())
-                .with_context(|| format!("failed to write to file \"{}\"", file))?;
+                .with_context(|| format!("failed to write to file \"{file}\""))?;
        }

        if self.current.is_none()
@@ -160,11 +171,12 @@ impl IProfiles {
            }
        }

-        if old_index.is_none() || new_index.is_none() {
-            return Ok(());
-        }
-        let item = items.remove(old_index.unwrap());
-        items.insert(new_index.unwrap(), item);
+        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);
        self.items = Some(items);
        self.save_file()
    }
@@ -226,9 +238,9 @@ impl IProfiles {
                        let path = dirs::app_profiles_dir()?.join(&file);

                        fs::File::create(path)
-                            .with_context(|| format!("failed to create file \"{}\"", file))?
+                            .with_context(|| format!("failed to create file \"{file}\""))?
                            .write(file_data.as_bytes())
-                            .with_context(|| format!("failed to write to file \"{}\"", file))?;
+                            .with_context(|| format!("failed to write to file \"{file}\""))?;
                    }

                    break;
@@ -485,4 +497,197 @@ 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()) {
+                if 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 {
+                    if itype == "remote" || itype == "local" {
+                        if let Some(option) = &item.option {
+                            // 收集关联的扩展文件
+                            if let Some(merge_uid) = &option.merge {
+                                if let Ok(merge_item) = self.get_item(merge_uid) {
+                                    if let Some(file) = &merge_item.file {
+                                        active_files.insert(file.clone());
+                                    }
+                                }
+                            }
+
+                            if let Some(script_uid) = &option.script {
+                                if let Ok(script_item) = self.get_item(script_uid) {
+                                    if let Some(file) = &script_item.file {
+                                        active_files.insert(file.clone());
+                                    }
+                                }
+                            }
+
+                            if let Some(rules_uid) = &option.rules {
+                                if let Ok(rules_item) = self.get_item(rules_uid) {
+                                    if let Some(file) = &rules_item.file {
+                                        active_files.insert(file.clone());
+                                    }
+                                }
+                            }
+
+                            if let Some(proxies_uid) = &option.proxies {
+                                if let Ok(proxies_item) = self.get_item(proxies_uid) {
+                                    if let Some(file) = &proxies_item.file {
+                                        active_files.insert(file.clone());
+                                    }
+                                }
+                            }
+
+                            if let Some(groups_uid) = &option.groups {
+                                if let Ok(groups_item) = self.get_item(groups_uid) {
+                                    if 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)
+        })
+    }
+
+    pub fn auto_cleanup(&self) -> Result<()> {
+        match self.cleanup_orphaned_files() {
+            Ok(result) => {
+                if !result.deleted_files.is_empty() {
+                    log::info!(
+                        target: "app",
+                        "自动清理完成，删除了 {} 个冗余文件",
+                        result.deleted_files.len()
+                    );
+                }
+                Ok(())
+            }
+            Err(e) => {
+                log::warn!(target: "app", "自动清理失败: {e}");
+                Ok(())
+            }
+        }
+    }
 }
@@ -1,6 +1,7 @@
 use crate::{
    config::{deserialize_encrypted, serialize_encrypted, DEFAULT_PAC},
-    utils::{dirs, help, i18n},
+    logging,
+    utils::{dirs, help, i18n, logging::Type},
 };
 use anyhow::Result;
 use log::LevelFilter;
@@ -88,6 +89,9 @@ pub struct IVerge {
    /// pac script content
    pub pac_file_content: Option<String>,

+    /// proxy host address
+    pub proxy_host: Option<String>,
+
    /// theme setting
    pub theme_setting: Option<IVergeTheme>,

@@ -131,12 +135,9 @@ pub struct IVerge {
    pub test_list: Option<Vec<IVergeTestItem>>,

    /// 日志清理
-    /// 0: 不清理; 1: 7天; 2: 30天; 3: 90天
+    /// 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>,
@@ -197,6 +198,12 @@ 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>,
 }
@@ -226,6 +233,93 @@ pub struct IVergeTheme {
 }

 impl IVerge {
+    /// 有效的clash核心名称
+    pub const VALID_CLASH_CORES: &'static [&'static str] = &["verge-mihomo", "verge-mihomo-alpha"];
+
+    /// 验证并修正配置文件中的clash_core值
+    pub fn validate_and_fix_config() -> Result<()> {
+        let config_path = dirs::verge_path()?;
+        let mut config = match help::read_yaml::<IVerge>(&config_path) {
+            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"))?;
+            logging!(
+                info,
+                Type::Config,
+                true,
+                "配置文件修正完成，需要重新加载配置"
+            );
+
+            Self::reload_config_after_fix(config)?;
+        } else {
+            logging!(
+                info,
+                Type::Config,
+                true,
+                "clash_core配置验证通过: {:?}",
+                config.clash_core
+            );
+        }
+
+        Ok(())
+    }
+
+    /// 配置修正后重新加载配置
+    fn reload_config_after_fix(updated_config: IVerge) -> Result<()> {
+        use crate::config::Config;
+
+        let config_draft = Config::verge();
+        *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"))
@@ -272,10 +366,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()),
-            enable_random_port: Some(false),
+            proxy_host: Some("127.0.0.1".into()),
            #[cfg(not(target_os = "windows"))]
            verge_redir_port: Some(7895),
            #[cfg(not(target_os = "windows"))]
@@ -295,18 +390,19 @@ impl IVerge {
            auto_close_connection: Some(true),
            auto_check_update: Some(true),
            enable_builtin_enhanced: Some(true),
-            auto_log_clean: Some(3),
+            auto_log_clean: Some(2), // 1: 1天, 2: 7天, 3: 30天, 4: 90天
            webdav_url: None,
            webdav_username: None,
            webdav_password: None,
-            enable_tray_speed: Some(true),
+            enable_tray_speed: Some(false),
            enable_tray_icon: Some(true),
            enable_global_hotkey: Some(true),
            enable_auto_light_weight_mode: Some(false),
            auto_light_weight_minutes: Some(10),
-            enable_dns_settings: Some(true),
+            enable_dns_settings: Some(false),
            home_cards: None,
            service_state: None,
+            enable_external_controller: Some(false),
            ..Self::default()
        }
    }
@@ -347,7 +443,7 @@ impl IVerge {
        patch!(enable_tun_mode);
        patch!(enable_auto_launch);
        patch!(enable_silent_start);
-        patch!(enable_random_port);
+        patch!(enable_hover_jump_navigator);
        #[cfg(not(target_os = "windows"))]
        patch!(verge_redir_port);
        #[cfg(not(target_os = "windows"))]
@@ -368,7 +464,7 @@ impl IVerge {
        patch!(proxy_guard_duration);
        patch!(proxy_auto_config);
        patch!(pac_file_content);
-
+        patch!(proxy_host);
        patch!(theme_setting);
        patch!(web_ui_list);
        patch!(clash_core);
@@ -394,6 +490,7 @@ impl IVerge {
        patch!(enable_dns_settings);
        patch!(home_cards);
        patch!(service_state);
+        patch!(enable_external_controller);
    }

    /// 在初始化前尝试拿到单例端口的值
@@ -452,6 +549,7 @@ pub struct IVergeResponse {
    pub proxy_guard_duration: Option<u64>,
    pub proxy_auto_config: Option<bool>,
    pub pac_file_content: Option<String>,
+    pub proxy_host: Option<String>,
    pub theme_setting: Option<IVergeTheme>,
    pub web_ui_list: Option<Vec<String>>,
    pub clash_core: Option<String>,
@@ -464,7 +562,6 @@ 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"))]
@@ -487,11 +584,15 @@ 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,
@@ -520,9 +621,10 @@ impl From<IVerge> for IVergeResponse {
            proxy_guard_duration: verge.proxy_guard_duration,
            proxy_auto_config: verge.proxy_auto_config,
            pac_file_content: verge.pac_file_content,
+            proxy_host: verge.proxy_host,
            theme_setting: verge.theme_setting,
            web_ui_list: verge.web_ui_list,
-            clash_core: verge.clash_core,
+            clash_core: Some(valid_clash_core),
            hotkeys: verge.hotkeys,
            auto_close_connection: verge.auto_close_connection,
            auto_check_update: verge.auto_check_update,
@@ -532,7 +634,6 @@ 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"))]
@@ -555,6 +656,8 @@ 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,
        }
    }
@@ -0,0 +1,533 @@
+#[cfg(target_os = "windows")]
+use crate::process::AsyncHandler;
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+use tokio::time::{timeout, Duration};
+
+#[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::{RegCloseKey, RegOpenKeyExW, RegQueryValueExW, HKEY_CURRENT_USER};
+
+        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") {
+            if !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 {
+            if 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 {
+                        if 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::{RegCloseKey, RegOpenKeyExW, RegQueryValueExW, HKEY_CURRENT_USER};
+
+        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) {
+                    if 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") {
+            if let Ok(proxy_info) = Self::parse_proxy_url(&http_proxy) {
+                return Ok(proxy_info);
+            }
+        }
+
+        if let Ok(https_proxy) = std::env::var("https_proxy") {
+            if 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 {
+            if 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) {
+                        if 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(),
+        })
+    }
+}
@@ -15,6 +15,9 @@ use std::{
 use tokio::time::timeout;
 use zip::write::SimpleFileOptions;

+// 应用版本常量，来自 tauri.conf.json
+const APP_VERSION: &str = env!("CARGO_PKG_VERSION");
+
 const TIMEOUT_UPLOAD: u64 = 300; // 上传超时 5 分钟
 const TIMEOUT_DOWNLOAD: u64 = 300; // 下载超时 5 分钟
 const TIMEOUT_LIST: u64 = 3; // 列表超时 30 秒
@@ -75,7 +78,7 @@ impl WebDavClient {
            if let Some(cfg) = lock.as_ref() {
                cfg.clone()
            } else {
-                let verge = Config::verge().latest().clone();
+                let verge = Config::verge().latest_ref().clone();
                if verge.webdav_url.is_none()
                    || verge.webdav_username.is_none()
                    || verge.webdav_password.is_none()
@@ -105,19 +108,28 @@ impl WebDavClient {
                reqwest::Client::builder()
                    .danger_accept_invalid_certs(true)
                    .timeout(Duration::from_secs(op.timeout()))
-                    .build()
-                    .unwrap(),
+                    .user_agent(format!("clash-verge/{APP_VERSION} ({OS} WebDAV-Client)"))
+                    .redirect(reqwest::redirect::Policy::custom(|attempt| {
+                        // 允许所有请求类型的重定向，包括PUT
+                        if attempt.previous().len() >= 5 {
+                            attempt.error("重定向次数过多")
+                        } else {
+                            attempt.follow()
+                        }
+                    }))
+                    .build()?,
            )
            .set_host(config.url)
            .set_auth(reqwest_dav::Auth::Basic(config.username, config.password))
            .build()?;

-        // 确保备份目录存在
-        let list_result = client
+        // 尝试检查目录是否存在，如果不存在尝试创建，但创建失败不报错
+        if client
            .list(dirs::BACKUP_DIR, reqwest_dav::Depth::Number(0))
-            .await;
-        if list_result.is_err() {
-            client.mkcol(dirs::BACKUP_DIR).await?;
+            .await
+            .is_err()
+        {
+            let _ = client.mkcol(dirs::BACKUP_DIR).await;
        }

        // 缓存客户端
@@ -137,9 +149,41 @@ impl WebDavClient {
    pub async fn upload(&self, file_path: PathBuf, file_name: String) -> Result<(), Error> {
        let client = self.get_client(Operation::Upload).await?;
        let webdav_path: String = format!("{}/{}", dirs::BACKUP_DIR, file_name);
-        let fut = client.put(webdav_path.as_ref(), fs::read(file_path)?);
-        timeout(Duration::from_secs(TIMEOUT_UPLOAD), fut).await??;
-        Ok(())
+
+        // 读取文件并上传，如果失败尝试一次重试
+        let file_content = fs::read(&file_path)?;
+
+        // 添加超时保护
+        let upload_result = timeout(
+            Duration::from_secs(TIMEOUT_UPLOAD),
+            client.put(&webdav_path, file_content.clone()),
+        )
+        .await;
+
+        match upload_result {
+            Err(_) => {
+                log::warn!("Upload timed out, retrying once");
+                tokio::time::sleep(Duration::from_millis(500)).await;
+                timeout(
+                    Duration::from_secs(TIMEOUT_UPLOAD),
+                    client.put(&webdav_path, file_content),
+                )
+                .await??;
+                Ok(())
+            }
+
+            Ok(Err(e)) => {
+                log::warn!("Upload failed, retrying once: {e}");
+                tokio::time::sleep(Duration::from_millis(500)).await;
+                timeout(
+                    Duration::from_secs(TIMEOUT_UPLOAD),
+                    client.put(&webdav_path, file_content),
+                )
+                .await??;
+                Ok(())
+            }
+            Ok(Ok(_)) => Ok(()),
+        }
    }

    pub async fn download(&self, filename: String, storage_path: PathBuf) -> Result<(), Error> {
@@ -189,7 +233,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!("{}-backup-{}.zip", OS, now);
+    let zip_file_name = format!("{OS}-backup-{now}.zip");
    let zip_path = temp_dir().join(&zip_file_name);

    let file = fs::File::create(&zip_path)?;
@@ -198,12 +242,17 @@ 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.unwrap();
+            let entry = entry?;
            let path = entry.path();
            if path.is_file() {
-                let backup_path = format!("profiles/{}", entry.file_name().to_str().unwrap());
+                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);
                zip.start_file(backup_path, options)?;
-                zip.write_all(fs::read(path).unwrap().as_slice())?;
+                let file_content = fs::read(&path)?;
+                zip.write_all(&file_content)?;
            }
        }
    }
@@ -1,13 +1,13 @@
-#[cfg(target_os = "macos")]
-use crate::core::tray::Tray;
 use crate::{
    config::*,
    core::{
        handle,
        service::{self},
    },
+    ipc::IpcManager,
    logging, logging_error,
-    module::mihomo::MihomoManager,
+    process::AsyncHandler,
+    singleton_lazy,
    utils::{
        dirs,
        help::{self},
@@ -15,10 +15,16 @@ use crate::{
    },
 };
 use anyhow::Result;
-use once_cell::sync::OnceCell;
-use std::{fmt, path::PathBuf, sync::Arc};
+use chrono::Local;
+use parking_lot::Mutex;
+use std::{
+    fmt,
+    fs::{create_dir_all, File},
+    io::Write,
+    path::PathBuf,
+    sync::Arc,
+};
 use tauri_plugin_shell::{process::CommandChild, ShellExt};
-use tokio::sync::Mutex;

 #[derive(Debug)]
 pub struct CoreManager {
@@ -47,7 +53,7 @@ impl fmt::Display for RunningMode {
    }
 }

-const CLASH_CORES: [&str; 2] = ["verge-mihomo", "verge-mihomo-alpha"];
+use crate::config::IVerge;

 impl CoreManager {
    /// 检查文件是否为脚本文件
@@ -131,16 +137,16 @@ impl CoreManager {
        Ok(false)
    }
    /// 使用默认配置
-    pub async fn use_default_config(&self, msg_type: &str, msg_content: &str) -> Result<()> {
+    pub fn use_default_config(&self, msg_type: &str, msg_content: &str) -> Result<()> {
        let runtime_path = dirs::app_home_dir()?.join(RUNTIME_CONFIG);
-        *Config::runtime().draft() = IRuntime {
-            config: Some(Config::clash().latest().0.clone()),
+        *Config::runtime().draft_mut() = Box::new(IRuntime {
+            config: Some(Config::clash().latest_ref().0.clone()),
            exists_keys: vec![],
            chain_logs: Default::default(),
-        };
+        });
        help::save_yaml(
            &runtime_path,
-            &Config::clash().latest().0,
+            &Config::clash().latest_ref().0,
            Some("# Clash Verge Runtime"),
        )?;
        handle::Handle::notice_message(msg_type, msg_content);
@@ -167,7 +173,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));
        }
@@ -181,7 +187,7 @@ impl CoreManager {
                "检测到Merge文件，仅进行语法检查: {}",
                config_path
            );
-            return self.validate_file_syntax(config_path).await;
+            return self.validate_file_syntax(config_path);
        }

        // 检查是否为脚本文件
@@ -213,7 +219,7 @@ impl CoreManager {
                "检测到脚本文件，使用JavaScript验证: {}",
                config_path
            );
-            return self.validate_script_file(config_path).await;
+            return self.validate_script_file(config_path);
        }

        // 对YAML配置文件使用Clash内核验证
@@ -242,11 +248,14 @@ impl CoreManager {
            config_path
        );

-        let clash_core = { Config::verge().latest().clash_core.clone() };
-        let clash_core = clash_core.unwrap_or("verge-mihomo".into());
+        let clash_core = Config::verge().latest_ref().get_valid_clash_core();
        logging!(info, Type::Config, true, "使用内核: {}", clash_core);

-        let app_handle = handle::Handle::global().app_handle().unwrap();
+        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_dir = dirs::app_home_dir()?;
        let app_dir_str = dirs::path_to_str(&app_dir)?;
        logging!(info, Type::Config, true, "验证目录: {}", app_dir_str);
@@ -280,7 +289,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()
            };
@@ -294,14 +303,14 @@ impl CoreManager {
        }
    }
    /// 只进行文件语法检查，不进行完整验证
-    async fn validate_file_syntax(&self, config_path: &str) -> Result<(bool, String)> {
+    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));
            }
@@ -315,19 +324,19 @@ impl CoreManager {
            }
            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))
            }
        }
    }
    /// 验证脚本文件语法
-    async fn validate_script_file(&self, path: &str) -> Result<(bool, String)> {
+    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));
@@ -360,7 +369,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))
@@ -379,7 +388,7 @@ impl CoreManager {

        // 1. 先生成新的配置内容
        logging!(info, Type::Config, true, "生成新的配置内容");
-        Config::generate().await?;
+        Config::generate()?;

        // 2. 验证配置
        match self.validate_config().await {
@@ -409,10 +418,7 @@ impl CoreManager {
            logging_error!(Type::Core, true, "{}", msg);
            msg
        });
-        match MihomoManager::global()
-            .put_configs_force(run_path_str?)
-            .await
-        {
+        match IpcManager::global().put_configs_force(run_path_str?).await {
            Ok(_) => {
                Config::runtime().apply();
                logging!(info, Type::Core, true, "Configuration updated successfully");
@@ -429,19 +435,326 @@ impl CoreManager {
 }

 impl CoreManager {
-    async fn start_core_by_sidecar(&self) -> Result<()> {
+    /// 清理多余的 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 {
+                            if 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, Process32FirstW, Process32NextW, PROCESSENTRY32W,
+                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};
+
+            let result = 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?;
+
+            result
+        }
+
+        #[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())
+        }
+    }
+
+    fn start_core_by_sidecar(&self) -> Result<()> {
        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()
-            .latest()
-            .clash_core
-            .clone()
-            .unwrap_or("verge-mihomo".to_string());
+        let clash_core = Config::verge().latest_ref().get_valid_clash_core();
        let config_dir = dirs::app_home_dir()?;
-        let (_, child) = app_handle
+
+        let service_log_dir = dirs::app_home_dir()?.join("logs").join("service");
+        create_dir_all(&service_log_dir)?;
+
+        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 mut log_file = File::create(log_path)?;
+
+        let (mut rx, child) = app_handle
            .shell()
            .sidecar(&clash_core)?
            .args([
@@ -451,6 +764,23 @@ impl CoreManager {
                dirs::path_to_str(config_file)?,
            ])
            .spawn()?;
+
+        AsyncHandler::spawn(move || 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!(
            trace,
@@ -459,14 +789,14 @@ impl CoreManager {
            "Started core by sidecar pid: {}",
            pid
        );
-        *self.child_sidecar.lock().await = Some(child);
-        self.set_running_mode(RunningMode::Sidecar).await;
+        *self.child_sidecar.lock() = Some(child);
+        self.set_running_mode(RunningMode::Sidecar);
        Ok(())
    }
-    async fn stop_core_by_sidecar(&self) -> Result<()> {
+    fn stop_core_by_sidecar(&self) -> Result<()> {
        logging!(trace, Type::Core, true, "Stopping core by sidecar");

-        if let Some(child) = self.child_sidecar.lock().await.take() {
+        if let Some(child) = self.child_sidecar.lock().take() {
            let pid = child.pid();
            child.kill()?;
            logging!(
@@ -477,7 +807,7 @@ impl CoreManager {
                pid
            );
        }
-        self.set_running_mode(RunningMode::NotRunning).await;
+        self.set_running_mode(RunningMode::NotRunning);
        Ok(())
    }
 }
@@ -487,118 +817,249 @@ impl CoreManager {
        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).await;
+        self.set_running_mode(RunningMode::Service);
        Ok(())
    }
    async fn stop_core_by_service(&self) -> Result<()> {
        logging!(trace, Type::Core, true, "Stopping core by service");
        service::stop_core_by_service().await?;
-        self.set_running_mode(RunningMode::NotRunning).await;
+        self.set_running_mode(RunningMode::NotRunning);
        Ok(())
    }
 }

-impl CoreManager {
-    pub fn global() -> &'static CoreManager {
-        static CORE_MANAGER: OnceCell<CoreManager> = OnceCell::new();
-        CORE_MANAGER.get_or_init(|| CoreManager {
+impl Default for CoreManager {
+    fn default() -> Self {
+        CoreManager {
            running: Arc::new(Mutex::new(RunningMode::NotRunning)),
            child_sidecar: Arc::new(Mutex::new(None)),
-        })
+        }
+    }
+}
+
+// Use simplified singleton_lazy macro
+singleton_lazy!(CoreManager, CORE_MANAGER, CoreManager::default);
+
+impl CoreManager {
+    // 当服务安装失败时的回退逻辑
+    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() {
+                logging!(
+                    warn,
+                    Type::Core,
+                    true,
+                    "服务重装失败 during attempt_service_init: {}",
+                    e
+                );
+                return Err(e);
+            }
+            // 如果重装成功，还需要尝试启动服务
+            logging!(info, Type::Core, true, "服务重装成功，尝试启动服务");
+        }
+
+        if let Err(e) = self.start_core_by_service().await {
+            logging!(
+                warn,
+                Type::Core,
+                true,
+                "通过服务启动核心失败 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");

+        // 应用启动时先清理任何遗留的 mihomo 进程
+        if let Err(e) = self.cleanup_orphaned_mihomo_processes().await {
+            logging!(
+                warn,
+                Type::Core,
+                true,
+                "应用初始化时清理多余 mihomo 进程失败: {}",
+                e
+            );
+        }
+
+        let mut core_started_successfully = false;
+
        if service::is_service_available().await.is_ok() {
-            logging!(info, Type::Core, true, "服务可用，直接使用服务模式");
-
-            // 检查版本是否需要重装
-            if service::check_service_needs_reinstall().await {
-                logging!(info, Type::Core, true, "服务版本不匹配，执行重装");
-                service::reinstall_service().await?;
+            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模式回退。"
+                    );
+                }
            }
-
-            self.start_core_by_service().await?;
        } else {
-            // 服务不可用，获取服务状态
+            logging!(
+                info,
+                Type::Core,
+                true,
+                "服务初始不可用 (is_service_available 调用失败)"
+            );
+        }
+
+        if !core_started_successfully {
+            logging!(
+                info,
+                Type::Core,
+                true,
+                "核心未通过服务模式启动，执行Sidecar回退或首次安装逻辑"
+            );
+
            let service_state = service::ServiceState::get();
-            let has_service_install_record = service_state.last_install_time > 0;

            if service_state.prefer_sidecar {
                logging!(
                    info,
                    Type::Core,
                    true,
-                    "用户偏好Sidecar模式，使用Sidecar模式启动"
+                    "用户偏好Sidecar模式或先前服务启动失败，使用Sidecar模式启动"
                );
-                self.start_core_by_sidecar().await?;
-            }
-            // 检查是否已经有服务安装记录，如果没有，则尝试安装
-            else if !has_service_install_record {
-                logging!(info, Type::Core, true, "首次运行，服务不可用，尝试安装");
+                self.start_core_by_sidecar()?;
+                // 如果 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() {
+                        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()?;

-                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() {
-                            self.start_core_by_service().await?;
-                            logging!(info, Type::Core, true, "服务启动成功");
-                        } else {
-                            logging!(
-                                warn,
-                                Type::Core,
-                                true,
-                                "服务安装成功但未能连接，回退到Sidecar模式"
-                            );
-
-                            self.start_core_by_sidecar().await?;
+                            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()?;
+                                }
+                            } 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()?;
+                            }
+                        }
+                        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()?;
                        }
                    }
-                    Err(err) => {
-                        // 安装失败，记录错误并使用sidecar模式
-                        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()?;
                }
-            } else {
-                logging!(
-                    info,
-                    Type::Core,
-                    true,
-                    "有服务安装记录但服务不可用，使用Sidecar模式"
-                );
-                self.start_core_by_sidecar().await?;
            }
        }

-        logging!(trace, Type::Core, "Initied core");
-        #[cfg(target_os = "macos")]
-        logging_error!(Type::Core, true, Tray::global().subscribe_traffic().await);
+        logging!(trace, Type::Core, "Initied core logic completed");
+        // #[cfg(target_os = "macos")]
+        // logging_error!(Type::Core, true, Tray::global().subscribe_traffic().await);
        Ok(())
    }

-    pub async fn set_running_mode(&self, mode: RunningMode) {
-        let mut guard = self.running.lock().await;
+    pub fn set_running_mode(&self, mode: RunningMode) {
+        let mut guard = self.running.lock();
        *guard = mode;
    }

-    pub async fn get_running_mode(&self) -> RunningMode {
-        let guard = self.running.lock().await;
+    pub fn get_running_mode(&self) -> RunningMode {
+        let guard = self.running.lock();
        (*guard).clone()
    }

@@ -606,7 +1067,7 @@ impl CoreManager {
    pub async fn start_core(&self) -> Result<()> {
        if service::is_service_available().await.is_ok() {
            if service::check_service_needs_reinstall().await {
-                service::reinstall_service().await?;
+                service::reinstall_service()?;
            }
            logging!(info, Type::Core, true, "服务可用，使用服务模式启动");
            self.start_core_by_service().await?;
@@ -620,10 +1081,10 @@ impl CoreManager {
                    true,
                    "服务不可用，根据用户偏好使用Sidecar模式"
                );
-                self.start_core_by_sidecar().await?;
+                self.start_core_by_sidecar()?;
            } else {
                logging!(info, Type::Core, true, "服务不可用，使用Sidecar模式");
-                self.start_core_by_sidecar().await?;
+                self.start_core_by_sidecar()?;
            }
        }
        Ok(())
@@ -631,9 +1092,9 @@ impl CoreManager {

    /// 停止核心运行
    pub async fn stop_core(&self) -> Result<()> {
-        match self.get_running_mode().await {
+        match self.get_running_mode() {
            RunningMode::Service => self.stop_core_by_service().await,
-            RunningMode::Sidecar => self.stop_core_by_sidecar().await,
+            RunningMode::Sidecar => self.stop_core_by_sidecar(),
            RunningMode::NotRunning => Ok(()),
        }
    }
@@ -641,6 +1102,7 @@ impl CoreManager {
    /// 重启内核
    pub async fn restart_core(&self) -> Result<()> {
        self.stop_core().await?;
+
        self.start_core().await?;
        Ok(())
    }
@@ -652,16 +1114,20 @@ impl CoreManager {
            logging!(error, Type::Core, true, "{}", error_message);
            return Err(error_message.to_string());
        }
-        let core: &str = &clash_core.clone().unwrap();
-        if !CLASH_CORES.contains(&core) {
-            let error_message = format!("Clash core invalid name: {}", core);
+        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}");
            logging!(error, Type::Core, true, "{}", error_message);
            return Err(error_message);
        }

-        Config::verge().draft().clash_core = clash_core.clone();
+        Config::verge().draft_mut().clash_core = clash_core.clone();
        Config::verge().apply();
-        logging_error!(Type::Core, true, Config::verge().latest().save_file());
+        logging_error!(Type::Core, true, Config::verge().latest_ref().save_file());

        let run_path = Config::generate_file(ConfigType::Run).map_err(|e| {
            let msg = e.to_string();
@@ -0,0 +1,582 @@
+use parking_lot::RwLock;
+use std::sync::Arc;
+use tokio::sync::{mpsc, oneshot};
+use tokio::time::{sleep, timeout, Duration};
+use tokio_stream::{wrappers::UnboundedReceiverStream, StreamExt};
+
+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();
+
+        Self::start_event_loop(Arc::clone(&state), event_rx, query_rx);
+
+        Self {
+            state,
+            event_sender: event_tx,
+            query_sender: query_tx,
+        }
+    }
+
+    /// 获取自动代理配置（缓存）
+    pub fn get_auto_proxy_cached(&self) -> Autoproxy {
+        self.state.read().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();
+        }
+
+        match timeout(Duration::from_secs(5), rx).await {
+            Ok(Ok(result)) => result,
+            _ => {
+                log::warn!(target: "app", "查询超时，返回缓存数据");
+                self.get_auto_proxy_cached()
+            }
+        }
+    }
+
+    /// 通知配置变更
+    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 fn start_event_loop(
+        state: Arc<RwLock<ProxyState>>,
+        event_rx: mpsc::UnboundedReceiver<ProxyEvent>,
+        query_rx: mpsc::UnboundedReceiver<QueryRequest>,
+    ) {
+        AsyncHandler::spawn(move || async move {
+            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();
+        });
+
+        auto_proxy
+    }
+
+    async fn initialize_proxy_state(state: &Arc<RwLock<ProxyState>>) {
+        log::info!(target: "app", "初始化代理状态");
+
+        let config = Self::get_proxy_config();
+        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;
+        });
+
+        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();
+
+        Self::update_state_timestamp(state, |s| {
+            s.sys_enabled = config.sys_enabled;
+            s.pac_enabled = config.pac_enabled;
+        });
+
+        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();
+            (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();
+
+        Self::update_state_timestamp(state, |s| {
+            s.auto_proxy = current.clone();
+        });
+
+        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;
+            });
+        }
+    }
+
+    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();
+
+        Self::update_state_timestamp(state, |s| {
+            s.sys_proxy = current.clone();
+        });
+
+        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;
+            });
+        }
+    }
+
+    async fn enable_system_proxy(state: &Arc<RwLock<ProxyState>>) {
+        log::info!(target: "app", "启用系统代理");
+
+        let pac_enabled = state.read().pac_enabled;
+
+        if pac_enabled {
+            let expected = Self::get_expected_pac_config();
+            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();
+            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();
+            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();
+            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);
+        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,
+        }
+    }
+
+    // 统一的状态更新方法
+    fn update_state_timestamp<F>(state: &Arc<RwLock<ProxyState>>, update_fn: F)
+    where
+        F: FnOnce(&mut ProxyState),
+    {
+        let mut state_guard = state.write();
+        update_fn(&mut state_guard);
+        state_guard.last_updated = std::time::Instant::now();
+    }
+
+    fn get_proxy_config() -> ProxyConfig {
+        let (sys_enabled, pac_enabled, guard_enabled) = {
+            let verge_config = Config::verge();
+            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,
+        }
+    }
+
+    fn get_expected_pac_config() -> Autoproxy {
+        let proxy_host = {
+            let verge_config = Config::verge();
+            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"),
+        }
+    }
+
+    fn get_expected_sys_proxy() -> Sysproxy {
+        let verge_config = Config::verge();
+        let verge = verge_config.latest_ref();
+        let port = verge
+            .verge_mixed_port
+            .unwrap_or(Config::clash().latest_ref().get_mixed_port());
+        let proxy_host = verge
+            .proxy_host
+            .clone()
+            .unwrap_or_else(|| "127.0.0.1".to_string());
+
+        Sysproxy {
+            enable: true,
+            host: proxy_host,
+            port,
+            bypass: Self::get_bypass_config(),
+        }
+    }
+
+    fn get_bypass_config() -> String {
+        let (use_default, custom_bypass) = {
+            let verge_config = Config::verge();
+            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(())
+    }
+}
@@ -1,9 +1,37 @@
-use once_cell::sync::OnceCell;
+use crate::singleton;
 use parking_lot::RwLock;
-use std::{sync::Arc, time::Duration};
+use std::{
+    sync::{
+        atomic::{AtomicU64, Ordering},
+        mpsc, Arc,
+    },
+    thread,
+    time::{Duration, Instant},
+};
 use tauri::{AppHandle, Emitter, Manager, WebviewWindow};

-use crate::{logging, logging_error, utils::logging::Type};
+use crate::{logging, utils::logging::Type};
+
+/// 不同类型的前端通知
+#[derive(Debug, Clone)]
+enum FrontendEvent {
+    RefreshClash,
+    RefreshVerge,
+    NoticeMessage { status: String, message: String },
+    ProfileChanged { current_profile_id: String },
+    TimerUpdated { profile_index: String },
+    StartupCompleted,
+    ProfileUpdateStarted { uid: String },
+    ProfileUpdateCompleted { uid: String },
+}
+
+/// 事件发送统计和监控
+#[derive(Debug, Default)]
+struct EventStats {
+    total_sent: AtomicU64,
+    total_errors: AtomicU64,
+    last_error_time: RwLock<Option<Instant>>,
+}

 /// 存储启动期间的错误消息
 #[derive(Debug, Clone)]
@@ -12,30 +40,258 @@ struct ErrorMessage {
    message: String,
 }

-#[derive(Debug, Default, Clone)]
+/// 全局前端通知系统
+#[derive(Debug)]
+struct NotificationSystem {
+    sender: Option<mpsc::Sender<FrontendEvent>>,
+    worker_handle: Option<thread::JoinHandle<()>>,
+    is_running: bool,
+    stats: EventStats,
+    last_emit_time: RwLock<Instant>,
+    /// 当通知系统失败超过阈值时，进入紧急模式
+    emergency_mode: RwLock<bool>,
+}
+
+impl Default for NotificationSystem {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl NotificationSystem {
+    fn new() -> Self {
+        Self {
+            sender: None,
+            worker_handle: None,
+            is_running: false,
+            stats: EventStats::default(),
+            last_emit_time: RwLock::new(Instant::now()),
+            emergency_mode: RwLock::new(false),
+        }
+    }
+
+    /// 启动通知处理线程
+    fn start(&mut self) {
+        if self.is_running {
+            return;
+        }
+
+        let (tx, rx) = mpsc::channel();
+        self.sender = Some(tx);
+        self.is_running = true;
+
+        *self.last_emit_time.write() = Instant::now();
+
+        match 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;
+                            };
+
+                            let is_emergency = *system.emergency_mode.read();
+
+                            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();
+
+                                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);
+                                            // 记录成功发送的事件
+                                            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;
+                                            }
+                                        }
+                                    }
+                                } 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 {
+                                log::warn!("No window found, skipping event emit.");
+                            }
+                            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}");
+            }
+        }
+    }
+
+    /// 发送事件到队列
+    fn send_event(&self, event: FrontendEvent) -> bool {
+        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:?}");
+                    self.stats.total_errors.fetch_add(1, Ordering::SeqCst);
+                    *self.stats.last_error_time.write() = Some(Instant::now());
+                    false
+                }
+            }
+        } else {
+            log::warn!("Notification system not started, can't send event");
+            false
+        }
+    }
+
+    fn shutdown(&mut self) {
+        log::info!("NotificationSystem shutdown initiated");
+        self.is_running = false;
+
+        // 先关闭发送端，让接收端知道不会再有新消息
+        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:?}");
+                }
+            }
+        }
+
+        log::info!("NotificationSystem shutdown completed");
+    }
+}
+
+#[derive(Debug, Clone)]
 pub struct Handle {
    pub app_handle: Arc<RwLock<Option<AppHandle>>>,
    pub is_exiting: Arc<RwLock<bool>>,
-    /// 存储启动过程中产生的错误消息队列
    startup_errors: Arc<RwLock<Vec<ErrorMessage>>>,
    startup_completed: Arc<RwLock<bool>>,
+    notification_system: Arc<RwLock<Option<NotificationSystem>>>,
 }

-impl Handle {
-    pub fn global() -> &'static Handle {
-        static HANDLE: OnceCell<Handle> = OnceCell::new();
-
-        HANDLE.get_or_init(|| Handle {
+impl Default for Handle {
+    fn default() -> Self {
+        Self {
            app_handle: Arc::new(RwLock::new(None)),
            is_exiting: Arc::new(RwLock::new(false)),
            startup_errors: Arc::new(RwLock::new(Vec::new())),
            startup_completed: Arc::new(RwLock::new(false)),
-        })
+            notification_system: Arc::new(RwLock::new(Some(NotificationSystem::new()))),
+        }
+    }
+}
+
+// Use singleton macro
+singleton!(Handle, HANDLE);
+
+impl Handle {
+    pub fn new() -> Self {
+        Self::default()
    }

    pub fn init(&self, app_handle: &AppHandle) {
-        let mut handle = self.app_handle.write();
-        *handle = Some(app_handle.clone());
+        {
+            let mut handle = self.app_handle.write();
+            *handle = Some(app_handle.clone());
+        }
+
+        let mut system_opt = self.notification_system.write();
+        if let Some(system) = system_opt.as_mut() {
+            system.start();
+        }
    }

    pub fn app_handle(&self) -> Option<AppHandle> {
@@ -43,7 +299,7 @@ impl Handle {
    }

    pub fn get_window(&self) -> Option<WebviewWindow> {
-        let app_handle = self.app_handle().unwrap();
+        let app_handle = self.app_handle()?;
        let window: Option<WebviewWindow> = app_handle.get_webview_window("main");
        if window.is_none() {
            log::debug!(target:"app", "main window not found");
@@ -52,43 +308,113 @@ impl Handle {
    }

    pub fn refresh_clash() {
-        if let Some(window) = Self::global().get_window() {
-            logging_error!(
-                Type::Frontend,
-                true,
-                window.emit("verge://refresh-clash-config", "yes")
-            );
+        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::RefreshClash);
        }
    }

    pub fn refresh_verge() {
-        if let Some(window) = Self::global().get_window() {
-            logging_error!(
-                Type::Frontend,
-                true,
-                window.emit("verge://refresh-verge-config", "yes")
+        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::RefreshVerge);
+        }
+    }
+
+    pub fn notify_profile_changed(profile_id: String) {
+        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::ProfileChanged {
+                current_profile_id: profile_id,
+            });
+        } else {
+            log::warn!(
+                "Notification system not initialized when trying to send ProfileChanged event."
            );
        }
    }

-    #[allow(unused)]
-    pub fn refresh_profiles() {
-        if let Some(window) = Self::global().get_window() {
-            logging_error!(
-                Type::Frontend,
-                true,
-                window.emit("verge://refresh-profiles-config", "yes")
+    pub fn notify_timer_updated(profile_index: String) {
+        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::TimerUpdated { profile_index });
+        } else {
+            log::warn!(
+                "Notification system not initialized when trying to send TimerUpdated event."
            );
        }
    }

-    /// 通知前端显示消息，如果在启动过程中，则将消息存入启动错误队列
+    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() {
+            return;
+        }
+
+        let system_opt = handle.notification_system.read();
+        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.");
+        }
+    }
+
+    pub fn notify_profile_update_completed(uid: String) {
+        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::ProfileUpdateCompleted { uid });
+        } else {
+            log::warn!("Notification system not initialized when trying to send ProfileUpdateCompleted event.");
+        }
+    }
+
+    /// 通知前端显示消息队列
    pub fn notice_message<S: Into<String>, M: Into<String>>(status: S, msg: M) {
        let handle = Self::global();
        let status_str = status.into();
        let msg_str = msg.into();

-        // 检查是否正在启动过程中
        if !*handle.startup_completed.read() {
            logging!(
                info,
@@ -99,7 +425,6 @@ impl Handle {
                msg_str
            );

-            // 将消息添加到启动错误队列
            let mut errors = handle.startup_errors.write();
            errors.push(ErrorMessage {
                status: status_str,
@@ -108,17 +433,19 @@ impl Handle {
            return;
        }

-        // 已经完成启动，直接发送消息
-        if let Some(window) = handle.get_window() {
-            logging_error!(
-                Type::Frontend,
-                true,
-                window.emit("verge://notice-message", (status_str, msg_str))
-            );
+        if handle.is_exiting() {
+            return;
+        }
+
+        let system_opt = handle.notification_system.read();
+        if let Some(system) = system_opt.as_ref() {
+            system.send_event(FrontendEvent::NoticeMessage {
+                status: status_str,
+                message: msg_str,
+            });
        }
    }

-    /// 标记启动已完成，并发送所有启动阶段累积的错误消息
    pub fn mark_startup_completed(&self) {
        {
            let mut completed = self.startup_completed.write();
@@ -147,27 +474,47 @@ impl Handle {
            errors.len()
        );

-        // 等待2秒以确保前端已完全加载，延迟发送错误通知
-        if let Some(window) = self.get_window() {
-            let window_clone = window.clone();
-            let errors_clone = errors.clone();
+        // 启动单独线程处理启动错误，避免阻塞主线程
+        let thread_result = thread::Builder::new()
+            .name("startup-errors-sender".into())
+            .spawn(move || {
+                thread::sleep(Duration::from_secs(2));

-            tauri::async_runtime::spawn(async move {
-                tokio::time::sleep(Duration::from_secs(2)).await;
+                let handle = Handle::global();
+                if handle.is_exiting() {
+                    return;
+                }

-                for error in errors_clone {
-                    let _ =
-                        window_clone.emit("verge://notice-message", (error.status, error.message));
-                    // 每条消息之间间隔500ms，避免消息堆积
-                    tokio::time::sleep(Duration::from_millis(500)).await;
+                let system_opt = handle.notification_system.read();
+                if let Some(system) = system_opt.as_ref() {
+                    for error in errors {
+                        if handle.is_exiting() {
+                            break;
+                        }
+
+                        system.send_event(FrontendEvent::NoticeMessage {
+                            status: error.status,
+                            message: error.message,
+                        });
+
+                        thread::sleep(Duration::from_millis(300));
+                    }
                }
            });
+
+        if let Err(e) = thread_result {
+            log::error!("Failed to spawn startup errors thread: {e}");
        }
    }

    pub fn set_is_exiting(&self) {
        let mut is_exiting = self.is_exiting.write();
        *is_exiting = true;
+
+        let mut system_opt = self.notification_system.write();
+        if let Some(system) = system_opt.as_mut() {
+            system.shutdown();
+        }
    }

    pub fn is_exiting(&self) -> bool {
@@ -1,48 +1,292 @@
+use crate::utils::notification::{notify_event, NotificationEvent};
 use crate::{
-    config::Config,
-    core::handle,
-    feat, logging, logging_error,
-    module::lightweight::entry_lightweight_mode,
-    utils::{logging::Type, resolve},
+    config::Config, core::handle, feat, logging, logging_error,
+    module::lightweight::entry_lightweight_mode, singleton_with_logging, utils::logging::Type,
 };
 use anyhow::{bail, Result};
-use once_cell::sync::OnceCell;
 use parking_lot::Mutex;
-use std::{collections::HashMap, sync::Arc};
-use tauri::{async_runtime, Manager};
+use std::{collections::HashMap, fmt, str::FromStr, 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 {
-    pub fn global() -> &'static Hotkey {
-        static HOTKEY: OnceCell<Hotkey> = OnceCell::new();
-
-        HOTKEY.get_or_init(|| Hotkey {
+    fn new() -> Self {
+        Self {
            current: Arc::new(Mutex::new(Vec::new())),
-        })
+        }
    }

+    /// Execute the function associated with a hotkey function enum
+    fn execute_function(function: HotkeyFunction, app_handle: &tauri::AppHandle) {
+        match function {
+            HotkeyFunction::OpenOrCloseDashboard => {
+                logging!(
+                    debug,
+                    Type::Hotkey,
+                    true,
+                    "=== Hotkey Dashboard Window Operation Start ==="
+                );
+
+                logging!(
+                    info,
+                    Type::Hotkey,
+                    true,
+                    "Using unified WindowManager for hotkey operation (bypass debounce)"
+                );
+
+                crate::feat::open_or_close_dashboard_hotkey();
+
+                logging!(
+                    debug,
+                    Type::Hotkey,
+                    "=== Hotkey Dashboard Window Operation End ==="
+                );
+                notify_event(app_handle, NotificationEvent::DashboardToggled);
+            }
+            HotkeyFunction::ClashModeRule => {
+                feat::change_clash_mode("rule".into());
+                notify_event(
+                    app_handle,
+                    NotificationEvent::ClashModeChanged { mode: "Rule" },
+                );
+            }
+            HotkeyFunction::ClashModeGlobal => {
+                feat::change_clash_mode("global".into());
+                notify_event(
+                    app_handle,
+                    NotificationEvent::ClashModeChanged { mode: "Global" },
+                );
+            }
+            HotkeyFunction::ClashModeDirect => {
+                feat::change_clash_mode("direct".into());
+                notify_event(
+                    app_handle,
+                    NotificationEvent::ClashModeChanged { mode: "Direct" },
+                );
+            }
+            HotkeyFunction::ToggleSystemProxy => {
+                feat::toggle_system_proxy();
+                notify_event(app_handle, NotificationEvent::SystemProxyToggled);
+            }
+            HotkeyFunction::ToggleTunMode => {
+                feat::toggle_tun_mode(None);
+                notify_event(app_handle, NotificationEvent::TunModeToggled);
+            }
+            HotkeyFunction::EntryLightweightMode => {
+                entry_lightweight_mode();
+                notify_event(app_handle, NotificationEvent::LightweightModeEntered);
+            }
+            HotkeyFunction::Quit => {
+                notify_event(app_handle, NotificationEvent::AppQuit);
+                feat::quit();
+            }
+            #[cfg(target_os = "macos")]
+            HotkeyFunction::Hide => {
+                feat::hide();
+                notify_event(app_handle, NotificationEvent::AppHidden);
+            }
+        }
+    }
+
+    #[cfg(target_os = "macos")]
+    /// Register a system hotkey using enum
+    pub 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)
+    }
+
+    #[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
+    pub 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 app_handle_clone = app_handle.clone();
+        let is_quit = matches!(function, HotkeyFunction::Quit);
+
+        let _ = manager.on_shortcut(hotkey, move |app_handle, hotkey_event, event| {
+            if event.state == ShortcutState::Pressed {
+                logging!(debug, Type::Hotkey, "Hotkey pressed: {:?}", hotkey_event);
+
+                if hotkey_event.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");
+                            Self::execute_function(function, &app_handle_clone);
+                        }
+                    }
+                } else {
+                    logging!(debug, Type::Hotkey, "Executing function directly");
+
+                    let is_enable_global_hotkey = Config::verge()
+                        .latest_ref()
+                        .enable_global_hotkey
+                        .unwrap_or(true);
+
+                    if is_enable_global_hotkey {
+                        Self::execute_function(function, &app_handle_clone);
+                    } 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, &app_handle_clone);
+                        }
+                    }
+                }
+            }
+        });
+
+        logging!(
+            debug,
+            Type::Hotkey,
+            "Successfully registered hotkey {} for {}",
+            hotkey,
+            function
+        );
+        Ok(())
+    }
+}
+
+// Use unified singleton macro
+singleton_with_logging!(Hotkey, INSTANCE, "Hotkey");
+
+impl Hotkey {
    pub fn init(&self) -> Result<()> {
        let verge = Config::verge();
-        let enable_global_hotkey = verge.latest().enable_global_hotkey.unwrap_or(true);
+        let enable_global_hotkey = verge.latest_ref().enable_global_hotkey.unwrap_or(true);

        logging!(
            debug,
            Type::Hotkey,
            true,
-            "Initializing hotkeys with enable: {}",
+            "Initializing global hotkeys: {}",
            enable_global_hotkey
        );

-        // 如果全局热键被禁用，则不注册热键
        if !enable_global_hotkey {
            return Ok(());
        }

-        if let Some(hotkeys) = verge.latest().hotkeys.as_ref() {
+        if let Some(hotkeys) = verge.latest_ref().hotkeys.as_ref() {
            logging!(
                debug,
                Type::Hotkey,
@@ -80,7 +324,6 @@ impl Hotkey {
                            logging!(
                                debug,
                                Type::Hotkey,
-                                true,
                                "Successfully registered hotkey {} -> {}",
                                key,
                                func
@@ -103,173 +346,34 @@ impl Hotkey {
            }
            self.current.lock().clone_from(hotkeys);
        } else {
-            logging!(debug, Type::Hotkey, true, "No hotkeys configured");
+            logging!(debug, Type::Hotkey, "No hotkeys configured");
        }

        Ok(())
    }

    pub fn reset(&self) -> Result<()> {
-        let app_handle = handle::Handle::global().app_handle().unwrap();
+        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();
        manager.unregister_all()?;
        Ok(())
    }

+    /// Register a hotkey with string-based function (backward compatibility)
    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,
-            true,
-            "Attempting to register hotkey: {} for function: {}",
-            hotkey,
-            func
-        );
-
-        if manager.is_registered(hotkey) {
-            logging!(
-                debug,
-                Type::Hotkey,
-                true,
-                "Hotkey {} was already registered, unregistering first",
-                hotkey
-            );
-            manager.unregister(hotkey)?;
-        }
-
-        let f = match func.trim() {
-            "open_or_close_dashboard" => {
-                logging!(
-                    debug,
-                    Type::Hotkey,
-                    true,
-                    "Registering open_or_close_dashboard function"
-                );
-                || {
-                    logging!(
-                        debug,
-                        Type::Hotkey,
-                        true,
-                        "=== Hotkey Dashboard Window Operation Start ==="
-                    );
-
-                    // 使用 spawn_blocking 来确保在正确的线程上执行
-                    async_runtime::spawn_blocking(|| {
-                        logging!(
-                            debug,
-                            Type::Hotkey,
-                            true,
-                            "Toggle dashboard window visibility"
-                        );
-
-                        // 检查窗口是否存在
-                        if let Some(window) = handle::Handle::global().get_window() {
-                            // 如果窗口可见，则隐藏它
-                            if window.is_visible().unwrap_or(false) {
-                                logging!(info, Type::Window, true, "Window is visible, hiding it");
-                                let _ = window.hide();
-                            } else {
-                                // 如果窗口不可见，则显示它
-                                logging!(info, Type::Window, true, "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,
-                                true,
-                                "Window does not exist, creating a new one"
-                            );
-                            resolve::create_window(true);
-                        }
-                    });
-
-                    logging!(
-                        debug,
-                        Type::Hotkey,
-                        true,
-                        "=== Hotkey Dashboard Window Operation End ==="
-                    );
-                }
-            }
-            "clash_mode_rule" => || feat::change_clash_mode("rule".into()),
-            "clash_mode_global" => || feat::change_clash_mode("global".into()),
-            "clash_mode_direct" => || feat::change_clash_mode("direct".into()),
-            "toggle_system_proxy" => || feat::toggle_system_proxy(),
-            "toggle_tun_mode" => || feat::toggle_tun_mode(None),
-            "entry_lightweight_mode" => || entry_lightweight_mode(),
-            "quit" => || feat::quit(Some(0)),
-            #[cfg(target_os = "macos")]
-            "hide" => || feat::hide(),
-
-            _ => {
-                logging!(error, Type::Hotkey, true, "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, true, "Hotkey pressed: {:?}", hotkey);
-
-                if hotkey.key == Code::KeyQ && is_quit {
-                    if let Some(window) = app_handle.get_webview_window("main") {
-                        if window.is_focused().unwrap_or(false) {
-                            logging!(debug, Type::Hotkey, true, "Executing quit function");
-                            f();
-                        }
-                    }
-                } else {
-                    // 直接执行函数，不做任何状态检查
-                    logging!(debug, Type::Hotkey, true, "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,
-            true,
-            "Successfully registered hotkey {} for {}",
-            hotkey,
-            func
-        );
-        Ok(())
+        let function = HotkeyFunction::from_str(func)?;
+        self.register_hotkey_with_function(hotkey, function)
    }

    pub fn unregister(&self, hotkey: &str) -> Result<()> {
-        let app_handle = handle::Handle::global().app_handle().unwrap();
+        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();
        manager.unregister(hotkey)?;
-        logging!(debug, Type::Hotkey, true, "Unregister hotkey {}", hotkey);
+        logging!(debug, Type::Hotkey, "Unregister hotkey {}", hotkey);
        Ok(())
    }

@@ -285,7 +389,7 @@ impl Hotkey {
        });

        add.iter().for_each(|(key, func)| {
-            logging_error!(Type::Hotkey, true, self.register(key, func));
+            logging_error!(Type::Hotkey, self.register(key, func));
        });

        *current = new_hotkeys;
@@ -300,9 +404,9 @@ impl Hotkey {
            let func = iter.next();
            let key = iter.next();

-            if func.is_some() && key.is_some() {
-                let func = func.unwrap().trim();
-                let key = key.unwrap().trim();
+            if let (Some(func), Some(key)) = (func, key) {
+                let func = func.trim();
+                let key = key.trim();
                map.insert(key, func);
            }
        });
@@ -340,7 +444,17 @@ impl Hotkey {

 impl Drop for Hotkey {
    fn drop(&mut self) {
-        let app_handle = handle::Handle::global().app_handle().unwrap();
+        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;
+            }
+        };
        if let Err(e) = app_handle.global_shortcut().unregister_all() {
            logging!(
                error,
@@ -1,12 +1,15 @@
+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;
+pub mod service_ipc;
 pub mod sysopt;
 pub mod timer;
 pub mod tray;
 pub mod win_uwp;

-pub use self::core::*;
+pub use self::{core::*, event_driven_proxy::EventDrivenProxyManager, timer::Timer};
@@ -0,0 +1,342 @@
+#[cfg(target_os = "windows")]
+use crate::process::AsyncHandler;
+use crate::{logging, utils::logging::Type};
+use anyhow::{bail, Context, Result};
+use hmac::{Hmac, Mac};
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+const IPC_SOCKET_NAME: &str = if cfg!(windows) {
+    r"\\.\pipe\clash-verge-service"
+} else {
+    "/tmp/clash-verge-service.sock"
+};
+
+// 定义命令类型
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum IpcCommand {
+    GetClash,
+    GetVersion,
+    StartClash,
+    StopClash,
+}
+
+// IPC消息格式
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct IpcRequest {
+    pub id: String,
+    pub timestamp: u64,
+    pub command: IpcCommand,
+    pub payload: serde_json::Value,
+    pub signature: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct IpcResponse {
+    pub id: String,
+    pub success: bool,
+    pub data: Option<serde_json::Value>,
+    pub error: Option<String>,
+    pub signature: String,
+}
+
+// 密钥派生函数
+fn derive_secret_key() -> Vec<u8> {
+    // to do
+    // 从系统安全存储中获取或从程序安装时生成的密钥文件中读取
+    let unique_app_id = "clash-verge-app-secret-fuck-me-until-daylight";
+    let mut hasher = Sha256::new();
+    hasher.update(unique_app_id.as_bytes());
+    hasher.finalize().to_vec()
+}
+
+// 创建带签名的请求
+pub fn create_signed_request(
+    command: IpcCommand,
+    payload: serde_json::Value,
+) -> Result<IpcRequest> {
+    let id = nanoid::nanoid!(32);
+    let timestamp = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_secs();
+
+    let unsigned_request = IpcRequest {
+        id: id.clone(),
+        timestamp,
+        command: command.clone(),
+        payload: payload.clone(),
+        signature: String::new(),
+    };
+
+    let unsigned_json = serde_json::to_string(&unsigned_request)?;
+    let signature = sign_message(&unsigned_json)?;
+
+    Ok(IpcRequest {
+        id,
+        timestamp,
+        command,
+        payload,
+        signature,
+    })
+}
+
+// 签名消息
+fn sign_message(message: &str) -> Result<String> {
+    type HmacSha256 = Hmac<Sha256>;
+
+    let secret_key = derive_secret_key();
+    let mut mac = HmacSha256::new_from_slice(&secret_key).context("HMAC初始化失败")?;
+
+    mac.update(message.as_bytes());
+    let result = mac.finalize();
+    let signature = hex::encode(result.into_bytes());
+
+    Ok(signature)
+}
+
+// 验证响应签名
+pub fn verify_response_signature(response: &IpcResponse) -> Result<bool> {
+    let verification_response = IpcResponse {
+        id: response.id.clone(),
+        success: response.success,
+        data: response.data.clone(),
+        error: response.error.clone(),
+        signature: String::new(),
+    };
+
+    let message = serde_json::to_string(&verification_response)?;
+    let expected_signature = sign_message(&message)?;
+
+    Ok(expected_signature == response.signature)
+}
+
+// IPC连接管理-win
+#[cfg(target_os = "windows")]
+pub async fn send_ipc_request(
+    command: IpcCommand,
+    payload: serde_json::Value,
+) -> Result<IpcResponse> {
+    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},
+    };
+
+    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);
+        }
+    };
+
+    let request_json = serde_json::to_string(&request)?;
+
+    let result = AsyncHandler::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,
+                "连接到服务命名管道失败: {}",
+                error
+            );
+            return Err(anyhow::anyhow!("无法连接到服务命名管道: {}", error));
+        }
+
+        let mut pipe = unsafe { File::from_raw_handle(handle as RawHandle) };
+        logging!(info, Type::Service, true, "服务连接成功 (Windows)");
+
+        let request_bytes = request_json.as_bytes();
+        let len_bytes = (request_bytes.len() as u32).to_be_bytes();
+
+        if let Err(e) = pipe.write_all(&len_bytes) {
+            logging!(error, Type::Service, true, "写入请求长度失败: {}", e);
+            return Err(anyhow::anyhow!("写入请求长度失败: {}", e));
+        }
+
+        if let Err(e) = pipe.write_all(request_bytes) {
+            logging!(error, Type::Service, true, "写入请求内容失败: {}", e);
+            return Err(anyhow::anyhow!("写入请求内容失败: {}", e));
+        }
+
+        if let Err(e) = pipe.flush() {
+            logging!(error, Type::Service, true, "刷新管道失败: {}", e);
+            return Err(anyhow::anyhow!("刷新管道失败: {}", e));
+        }
+
+        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 response_len = u32::from_be_bytes(response_len_bytes) as usize;
+
+        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));
+        }
+
+        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)
+    })
+    .await??;
+
+    Ok(result)
+}
+
+// IPC连接管理-unix
+#[cfg(target_family = "unix")]
+pub async fn send_ipc_request(
+    command: IpcCommand,
+    payload: serde_json::Value,
+) -> Result<IpcResponse> {
+    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) {
+        Ok(s) => {
+            logging!(info, Type::Service, true, "服务连接成功 (Unix)");
+            s
+        }
+        Err(e) => {
+            logging!(error, Type::Service, true, "连接到Unix套接字失败: {}", e);
+            return Err(anyhow::anyhow!("无法连接到服务Unix套接字: {}", e));
+        }
+    };
+
+    let request_bytes = request_json.as_bytes();
+    let len_bytes = (request_bytes.len() as u32).to_be_bytes();
+
+    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];
+    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];
+    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)
+}
@@ -1,25 +1,21 @@
+#[cfg(target_os = "windows")]
+use crate::utils::autostart as startup_shortcut;
 use crate::{
    config::{Config, IVerge},
-    core::handle::Handle,
-    logging_error,
+    core::{handle::Handle, EventDrivenProxyManager},
+    logging, logging_error, singleton_lazy,
    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>>,
-    /// helps to auto launch the app
-    auto_launch: Arc<Mutex<bool>>,
-    /// record whether the guard async is running or not
-    guard_state: Arc<Mutex<bool>>,
 }

 #[cfg(target_os = "windows")]
@@ -32,10 +28,13 @@ 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>";

 fn get_bypass() -> String {
-    let use_default = Config::verge().latest().use_default_bypass.unwrap_or(true);
+    let use_default = Config::verge()
+        .latest_ref()
+        .use_default_bypass
+        .unwrap_or(true);
    let res = {
        let verge = Config::verge();
-        let verge = verge.latest();
+        let verge = verge.latest_ref();
        verge.system_proxy_bypass.clone()
    };
    let custom_bypass = match res {
@@ -46,25 +45,31 @@ 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 Sysopt {
-    pub fn global() -> &'static Sysopt {
-        static SYSOPT: OnceCell<Sysopt> = OnceCell::new();
-        SYSOPT.get_or_init(|| Sysopt {
+impl Default for Sysopt {
+    fn default() -> Self {
+        Sysopt {
            update_sysproxy: Arc::new(TokioMutex::new(false)),
            reset_sysproxy: Arc::new(TokioMutex::new(false)),
-            auto_launch: Arc::new(Mutex::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<()> {
-        self.guard_proxy();
+        // 使用事件驱动代理管理器
+        let proxy_manager = EventDrivenProxyManager::global();
+        proxy_manager.notify_app_started();
+
+        log::info!(target: "app", "已启用事件驱动代理守卫");
        Ok(())
    }

@@ -73,17 +78,21 @@ impl Sysopt {
        let _lock = self.update_sysproxy.lock().await;

        let port = Config::verge()
-            .latest()
+            .latest_ref()
            .verge_mixed_port
-            .unwrap_or(Config::clash().data().get_mixed_port());
+            .unwrap_or(Config::clash().latest_ref().get_mixed_port());
        let pac_port = IVerge::get_singleton_port();

-        let (sys_enable, pac_enable) = {
+        let (sys_enable, pac_enable, proxy_host) = {
            let verge = Config::verge();
-            let verge = verge.latest();
+            let verge = verge.latest_ref();
            (
                verge.enable_system_proxy.unwrap_or(false),
                verge.proxy_auto_config.unwrap_or(false),
+                verge
+                    .proxy_host
+                    .clone()
+                    .unwrap_or_else(|| String::from("127.0.0.1")),
            )
        };

@@ -91,18 +100,20 @@ impl Sysopt {
        {
            let mut sys = Sysproxy {
                enable: false,
-                host: String::from("127.0.0.1"),
+                host: proxy_host.clone(),
                port,
                bypass: get_bypass(),
            };
            let mut auto = Autoproxy {
                enable: false,
-                url: format!("http://127.0.0.1:{pac_port}/commands/pac"),
+                url: format!("http://{proxy_host}:{pac_port}/commands/pac"),
            };

            if !sys_enable {
                sys.set_system_proxy()?;
                auto.set_auto_proxy()?;
+                let proxy_manager = EventDrivenProxyManager::global();
+                proxy_manager.notify_config_changed();
                return Ok(());
            }

@@ -111,6 +122,8 @@ 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(());
            }

@@ -119,19 +132,26 @@ 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 {
-                return self.reset_sysproxy().await;
+                let result = self.reset_sysproxy().await;
+                let proxy_manager = EventDrivenProxyManager::global();
+                proxy_manager.notify_config_changed();
+                return result;
            }
            use crate::{core::handle::Handle, utils::dirs};
            use anyhow::bail;
            use tauri_plugin_shell::ShellExt;

-            let app_handle = Handle::global().app_handle().unwrap();
+            let app_handle = Handle::global()
+                .app_handle()
+                .ok_or_else(|| anyhow::anyhow!("App handle not available"))?;

            let binary_path = dirs::service_path()?;
            let sysproxy_exe = binary_path.with_file_name("sysproxy.exe");
@@ -141,30 +161,36 @@ impl Sysopt {

            let shell = app_handle.shell();
            let output = if pac_enable {
-                let address = format!("http://{}:{}/commands/pac", "127.0.0.1", pac_port);
-                let output = shell
-                    .command(sysproxy_exe.as_path().to_str().unwrap())
+                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)
                    .args(["pac", address.as_str()])
                    .output()
-                    .await
-                    .unwrap();
-                output
+                    .await?
            } else {
-                let address = format!("{}:{}", "127.0.0.1", port);
+                let address = format!("{proxy_host}:{port}");
                let bypass = get_bypass();
-                let output = shell
-                    .command(sysproxy_exe.as_path().to_str().unwrap())
+                let sysproxy_str = sysproxy_exe
+                    .as_path()
+                    .to_str()
+                    .ok_or_else(|| anyhow::anyhow!("Invalid sysproxy.exe path"))?;
+                shell
+                    .command(sysproxy_str)
                    .args(["global", address.as_str(), bypass.as_ref()])
                    .output()
-                    .await
-                    .unwrap();
-                output
+                    .await?
            };

            if !output.status.success() {
                bail!("sysproxy exe run failed");
            }
        }
+        let proxy_manager = EventDrivenProxyManager::global();
+        proxy_manager.notify_config_changed();

        Ok(())
    }
@@ -176,7 +202,16 @@ impl Sysopt {
        #[cfg(not(target_os = "windows"))]
        {
            let mut sysproxy: Sysproxy = Sysproxy::get_system_proxy()?;
-            let mut autoproxy = Autoproxy::get_auto_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(),
+                    }
+                }
+            };
            sysproxy.enable = false;
            autoproxy.enable = false;
            autoproxy.set_auto_proxy()?;
@@ -189,7 +224,9 @@ impl Sysopt {
            use anyhow::bail;
            use tauri_plugin_shell::ShellExt;

-            let app_handle = Handle::global().app_handle().unwrap();
+            let app_handle = Handle::global()
+                .app_handle()
+                .ok_or_else(|| anyhow::anyhow!("App handle not available"))?;

            let binary_path = dirs::service_path()?;
            let sysproxy_exe = binary_path.with_file_name("sysproxy.exe");
@@ -199,12 +236,15 @@ 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_exe.as_path().to_str().unwrap())
+                .command(sysproxy_str)
                .args(["set", "1"])
                .output()
-                .await
-                .unwrap();
+                .await?;

            if !output.status.success() {
                bail!("sysproxy exe run failed");
@@ -216,166 +256,84 @@ impl Sysopt {

    /// update the startup
    pub fn update_launch(&self) -> Result<()> {
-        let _lock = self.auto_launch.lock();
-        let enable = { Config::verge().latest().enable_auto_launch };
-        let enable = enable.unwrap_or(false);
-        let app_handle = Handle::global().app_handle().unwrap();
-        let autostart_manager = app_handle.autolaunch();
+        let enable_auto_launch = { Config::verge().latest_ref().enable_auto_launch };
+        let is_enable = enable_auto_launch.unwrap_or(false);
+        logging!(info, true, "Setting auto-launch state to: {:?}", is_enable);

-        log::info!(target: "app", "Setting auto launch to: {}", enable);
+        // 首先尝试使用快捷方式方法
+        #[cfg(target_os = "windows")]
+        {
+            if is_enable {
+                if let Err(e) = startup_shortcut::create_shortcut() {
+                    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(());
+            }
+        }

-        match enable {
-            true => {
-                let result = autostart_manager.enable();
-                if let Err(ref e) = result {
-                    log::error!(target: "app", "Failed to enable auto launch: {}", e);
-                } else {
-                    log::info!(target: "app", "Auto launch enabled successfully");
-                }
-                logging_error!(Type::System, true, result);
-            }
-            false => {
-                let result = autostart_manager.disable();
-                if let Err(ref e) = result {
-                    log::error!(target: "app", "Failed to disable auto launch: {}", e);
-                } else {
-                    log::info!(target: "app", "Auto launch disabled successfully");
-                }
-                logging_error!(Type::System, true, result);
-            }
-        };
+        #[cfg(not(target_os = "windows"))]
+        {
+            // 非Windows平台使用原来的方法
+            self.try_original_autostart_method(is_enable);
+        }

        Ok(())
    }

+    /// 尝试使用原来的自启动方法
+    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 autostart_manager = app_handle.autolaunch();
+
+        if is_enable {
+            logging_error!(Type::System, true, "{:?}", autostart_manager.enable());
+        } else {
+            logging_error!(Type::System, true, "{:?}", autostart_manager.disable());
+        }
+    }
+
    /// 获取当前自启动的实际状态
    pub fn get_launch_status(&self) -> Result<bool> {
-        let app_handle = Handle::global().app_handle().unwrap();
+        // 首先尝试检查快捷方式是否存在
+        #[cfg(target_os = "windows")]
+        {
+            match startup_shortcut::is_shortcut_enabled() {
+                Ok(enabled) => {
+                    log::info!(target: "app", "快捷方式自启动状态: {enabled}");
+                    return Ok(enabled);
+                }
+                Err(e) => {
+                    log::error!(target: "app", "检查快捷方式失败，尝试原来的方法: {e}");
+                }
+            }
+        }
+
+        // 回退到原来的方法
+        let app_handle = Handle::global()
+            .app_handle()
+            .ok_or_else(|| anyhow::anyhow!("App handle not available"))?;
        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();
-
-        tauri::async_runtime::spawn(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) = {
-                    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),
-                    )
-                };
-
-                // stop loop
-                if !enable || !guard {
-                    continue;
-                }
-
-                // update duration
-                wait_secs = guard_duration;
-
-                log::debug!(target: "app", "try to guard the system proxy");
-
-                let sysproxy = Sysproxy::get_system_proxy();
-                let autoproxy = Autoproxy::get_auto_proxy();
-                if sysproxy.is_err() || autoproxy.is_err() {
-                    log::error!(target: "app", "failed to get the system proxy");
-                    continue;
-                }
-
-                let sysproxy_enable = sysproxy.ok().map(|s| s.enable).unwrap_or(false);
-                let autoproxy_enable = autoproxy.ok().map(|s| s.enable).unwrap_or(false);
-
-                if sysproxy_enable || autoproxy_enable {
-                    continue;
-                }
-
-                let port = {
-                    Config::verge()
-                        .latest()
-                        .verge_mixed_port
-                        .unwrap_or(Config::clash().data().get_mixed_port())
-                };
-                let pac_port = IVerge::get_singleton_port();
-                #[cfg(not(target_os = "windows"))]
-                {
-                    if pac {
-                        let autoproxy = Autoproxy {
-                            enable: true,
-                            url: format!("http://127.0.0.1:{pac_port}/commands/pac"),
-                        };
-                        logging_error!(Type::System, true, autoproxy.set_auto_proxy());
-                    } else {
-                        let sysproxy = Sysproxy {
-                            enable: true,
-                            host: "127.0.0.1".into(),
-                            port,
-                            bypass: get_bypass(),
-                        };
-
-                        logging_error!(Type::System, true, 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 = dirs::service_path().unwrap();
-                    let sysproxy_exe = binary_path.with_file_name("sysproxy.exe");
-                    if !sysproxy_exe.exists() {
-                        break;
-                    }
-
-                    let shell = app_handle.shell();
-                    let output = if pac {
-                        let address = format!("http://{}:{}/commands/pac", "127.0.0.1", pac_port);
-
-                        shell
-                            .command(sysproxy_exe.as_path().to_str().unwrap())
-                            .args(["pac", address.as_str()])
-                            .output()
-                            .await
-                            .unwrap()
-                    } else {
-                        let address = format!("{}:{}", "127.0.0.1", port);
-                        let bypass = get_bypass();
-
-                        shell
-                            .command(sysproxy_exe.as_path().to_str().unwrap())
-                            .args(["global", address.as_str(), bypass.as_ref()])
-                            .output()
-                            .await
-                            .unwrap()
-                    };
-                    if !output.status.success() {
-                        break;
-                    }
-                };
-            }
-        });
-    }
 }
@@ -1,11 +1,14 @@
-use crate::{
-    config::Config, core::CoreManager, feat, logging, logging_error, utils::logging::Type,
-};
+use crate::{config::Config, feat, logging, logging_error, singleton, utils::logging::Type};
 use anyhow::{Context, Result};
 use delay_timer::prelude::{DelayTimer, DelayTimerBuilder, TaskBuilder};
-use once_cell::sync::OnceCell;
-use parking_lot::{Mutex, RwLock};
-use std::{collections::HashMap, sync::Arc};
+use parking_lot::RwLock;
+use std::{
+    collections::HashMap,
+    sync::{
+        atomic::{AtomicBool, AtomicU64, Ordering},
+        Arc,
+    },
+};

 type TaskID = u64;

@@ -24,23 +27,24 @@ pub struct Timer {
    /// save the current state - using RwLock for better read concurrency
    pub timer_map: Arc<RwLock<HashMap<String, TimerTask>>>,

-    /// increment id - kept as mutex since it's just a counter
-    pub timer_count: Arc<Mutex<TaskID>>,
+    /// increment id - atomic counter for better performance
+    pub timer_count: AtomicU64,

    /// Flag to mark if timer is initialized - atomic for better performance
-    pub initialized: Arc<std::sync::atomic::AtomicBool>,
+    pub initialized: AtomicBool,
 }

-impl Timer {
-    pub fn global() -> &'static Timer {
-        static TIMER: OnceCell<Timer> = OnceCell::new();
+// Use singleton macro
+singleton!(Timer, TIMER_INSTANCE);

-        TIMER.get_or_init(|| Timer {
+impl Timer {
+    fn new() -> Self {
+        Timer {
            delay_timer: Arc::new(RwLock::new(DelayTimerBuilder::default().build())),
            timer_map: Arc::new(RwLock::new(HashMap::new())),
-            timer_count: Arc::new(Mutex::new(1)),
-            initialized: Arc::new(std::sync::atomic::AtomicBool::new(false)),
-        })
+            timer_count: AtomicU64::new(1),
+            initialized: AtomicBool::new(false),
+        }
    }

    /// Initialize timer with better error handling and atomic operations
@@ -48,12 +52,7 @@ impl Timer {
        // Use compare_exchange for thread-safe initialization check
        if self
            .initialized
-            .compare_exchange(
-                false,
-                true,
-                std::sync::atomic::Ordering::SeqCst,
-                std::sync::atomic::Ordering::SeqCst,
-            )
+            .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
            .is_err()
        {
            logging!(debug, Type::Timer, "Timer already initialized, skipping...");
@@ -65,16 +64,34 @@ impl Timer {
        // Initialize timer tasks
        if let Err(e) = self.refresh() {
            // Reset initialization flag on error
-            self.initialized
-                .store(false, std::sync::atomic::Ordering::SeqCst);
+            self.initialized.store(false, Ordering::SeqCst);
            logging_error!(Type::Timer, false, "Failed to initialize timer: {}", e);
            return Err(e);
        }

+        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,
+                "注册了定时任务 - 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().latest().get_items() {
+        let profiles_to_update = if let Some(items) = Config::profiles().latest_ref().get_items() {
            items
                .iter()
                .filter_map(|item| {
@@ -83,6 +100,7 @@ impl Timer {
                    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
@@ -95,12 +113,18 @@ impl Timer {

        // Advance tasks outside of locks to minimize lock contention
        if !profiles_to_update.is_empty() {
+            logging!(
+                info,
+                Type::Timer,
+                "需要立即更新的配置数量: {}",
+                profiles_to_update.len()
+            );
            let timer_map = self.timer_map.read();
            let delay_timer = self.delay_timer.write();

            for uid in profiles_to_update {
                if let Some(task) = timer_map.get(&uid) {
-                    logging!(info, Type::Timer, "Advancing task for uid: {}", uid);
+                    logging!(info, Type::Timer, "立即执行任务: uid={}", uid);
                    if let Err(e) = delay_timer.advance_task(task.task_id) {
                        logging!(warn, Type::Timer, "Failed to advance task {}: {}", uid, e);
                    }
@@ -205,11 +229,18 @@ impl Timer {
    fn gen_map(&self) -> HashMap<String, u64> {
        let mut new_map = HashMap::new();

-        if let Some(items) = Config::profiles().latest().get_items() {
+        if let Some(items) = Config::profiles().latest_ref().get_items() {
            for item in items.iter() {
                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);
                        }
                    }
@@ -217,6 +248,12 @@ impl Timer {
            }
        }

+        logging!(
+            debug,
+            Type::Timer,
+            "生成的定时更新配置数量: {}",
+            new_map.len()
+        );
        new_map
    }

@@ -227,39 +264,64 @@ impl Timer {

        // Read lock for comparing current state
        let timer_map = self.timer_map.read();
+        logging!(
+            debug,
+            Type::Timer,
+            "当前 timer_map 大小: {}",
+            timer_map.len()
+        );

        // Find tasks to modify or delete
        for (uid, task) in timer_map.iter() {
            match new_map.get(uid) {
                Some(&interval) if interval != task.interval_minutes => {
                    // Task exists but interval changed
+                    logging!(
+                        debug,
+                        Type::Timer,
+                        "定时任务间隔变更: uid={}, 旧={}, 新={}",
+                        uid,
+                        task.interval_minutes,
+                        interval
+                    );
                    diff_map.insert(uid.clone(), DiffFlag::Mod(task.task_id, interval));
                }
                None => {
                    // Task no longer needed
+                    logging!(debug, Type::Timer, "定时任务已删除: uid={}", uid);
                    diff_map.insert(uid.clone(), DiffFlag::Del(task.task_id));
                }
                _ => {
                    // Task exists with same interval, no change needed
+                    logging!(debug, Type::Timer, "定时任务保持不变: uid={}", uid);
                }
            }
        }

        // Find new tasks to add
-        let mut next_id = *self.timer_count.lock();
+        let mut next_id = self.timer_count.load(Ordering::Relaxed);
+        let original_id = next_id;

        for (uid, &interval) in new_map.iter() {
            if !timer_map.contains_key(uid) {
+                logging!(
+                    debug,
+                    Type::Timer,
+                    "新增定时任务: uid={}, interval={}min",
+                    uid,
+                    interval
+                );
                diff_map.insert(uid.clone(), DiffFlag::Add(next_id, interval));
                next_id += 1;
            }
        }

        // Update counter only if we added new tasks
-        if next_id > *self.timer_count.lock() {
-            *self.timer_count.lock() = next_id;
+        if next_id > original_id {
+            self.timer_count.store(next_id, Ordering::Relaxed);
        }

+        logging!(debug, Type::Timer, "定时任务变更数量: {}", diff_map.len());
        diff_map
    }

@@ -300,42 +362,118 @@ impl Timer {
        Ok(())
    }

+    /// Get next update time for a profile
+    pub fn get_next_update_time(&self, uid: &str) -> Option<i64> {
+        logging!(info, Type::Timer, "获取下次更新时间，uid={}", uid);
+
+        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
+        let profiles_config = Config::profiles();
+        let profiles = profiles_config.latest_ref();
+        let items = match profiles.get_items() {
+            Some(i) => i,
+            None => {
+                logging!(warn, Type::Timer, "获取配置列表失败");
+                return None;
+            }
+        };
+
+        let profile = match items.iter().find(|item| item.uid.as_deref() == Some(uid)) {
+            Some(p) => p,
+            None => {
+                logging!(warn, Type::Timer, "找不到对应的配置，uid={}", uid);
+                return None;
+            }
+        };
+
+        let updated = profile.updated.unwrap_or(0) as i64;
+
+        // Calculate next update time
+        if updated > 0 && task.interval_minutes > 0 {
+            let next_time = updated + (task.interval_minutes as i64 * 60);
+            logging!(
+                info,
+                Type::Timer,
+                "计算得到下次更新时间: {}, uid={}",
+                next_time,
+                uid
+            );
+            Some(next_time)
+        } else {
+            logging!(
+                warn,
+                Type::Timer,
+                "更新时间或间隔无效，updated={}, interval={}",
+                updated,
+                task.interval_minutes
+            );
+            None
+        }
+    }
+
+    /// 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());
+            } else {
+                super::handle::Handle::notify_profile_update_completed(_uid.to_string());
+            }
+        }
+    }
+
    /// Async task with better error handling and logging
    async fn async_task(uid: String) {
        let task_start = std::time::Instant::now();
        logging!(info, Type::Timer, "Running timer task for profile: {}", uid);

-        // Update profile
-        let profile_result = feat::update_profile(uid.clone(), None).await;
+        match tokio::time::timeout(std::time::Duration::from_secs(40), async {
+            Self::emit_update_event(&uid, true);

-        match profile_result {
-            Ok(_) => {
-                // Update configuration
-                match CoreManager::global().update_config().await {
-                    Ok(_) => {
-                        let duration = task_start.elapsed().as_millis();
-                        logging!(
-                            info,
-                            Type::Timer,
-                            "Timer task completed successfully for uid: {} (took {}ms)",
-                            uid,
-                            duration
-                        );
-                    }
-                    Err(e) => {
-                        logging_error!(
-                            Type::Timer,
-                            "Failed to refresh config after profile update for uid {}: {}",
-                            uid,
-                            e
-                        );
-                    }
+            let is_current = Config::profiles().latest_ref().current.as_ref() == Some(&uid);
+            logging!(
+                info,
+                Type::Timer,
+                "配置 {} 是否为当前激活配置: {}",
+                uid,
+                is_current
+            );
+
+            feat::update_profile(uid.clone(), None, Some(is_current)).await
+        })
+        .await
+        {
+            Ok(result) => match result {
+                Ok(_) => {
+                    let duration = task_start.elapsed().as_millis();
+                    logging!(
+                        info,
+                        Type::Timer,
+                        "Timer task completed successfully for uid: {} (took {}ms)",
+                        uid,
+                        duration
+                    );
                }
-            }
-            Err(e) => {
-                logging_error!(Type::Timer, "Failed to update profile uid {}: {}", uid, e);
+                Err(e) => {
+                    logging_error!(Type::Timer, "Failed to update profile uid {}: {}", uid, e);
+                }
+            },
+            Err(_) => {
+                logging_error!(Type::Timer, false, "Timer task timed out for uid: {}", uid);
            }
        }
+
+        // Emit completed event
+        Self::emit_update_event(&uid, false);
    }
 }

@@ -2,59 +2,79 @@ use once_cell::sync::OnceCell;
 use tauri::tray::TrayIconBuilder;
 #[cfg(target_os = "macos")]
 pub mod speed_rate;
+use crate::ipc::Rate;
 use crate::{
    cmd,
    config::Config,
-    feat,
-    module::{lightweight::entry_lightweight_mode, mihomo::Rate},
-    resolve,
-    utils::{dirs::find_target_icons, i18n::t, logging::Type, resolve::VERSION},
+    feat, logging,
+    module::lightweight::is_in_lightweight_mode,
+    singleton_lazy,
+    utils::{dirs::find_target_icons, i18n::t, resolve::VERSION},
+    Type,
 };

 use anyhow::Result;
-#[cfg(target_os = "macos")]
-use futures::StreamExt;
-#[cfg(target_os = "macos")]
 use parking_lot::Mutex;
-#[cfg(target_os = "macos")]
-use parking_lot::RwLock;
-#[cfg(target_os = "macos")]
-pub use speed_rate::{SpeedRate, Traffic};
-use std::fs;
-#[cfg(target_os = "macos")]
-use std::sync::Arc;
+use std::{
+    fs,
+    sync::atomic::{AtomicBool, Ordering},
+    time::{Duration, Instant},
+};
 use tauri::{
    menu::{CheckMenuItem, IsMenuItem, MenuEvent, MenuItem, PredefinedMenuItem, Submenu},
    tray::{MouseButton, MouseButtonState, TrayIconEvent},
-    App, AppHandle, Wry,
+    AppHandle, Wry,
 };
-#[cfg(target_os = "macos")]
-use tokio::sync::broadcast;

 use super::handle;

 #[derive(Clone)]
 struct TrayState {}

+// 托盘点击防抖机制
+static TRAY_CLICK_DEBOUNCE: OnceCell<Mutex<Instant>> = OnceCell::new();
+const TRAY_CLICK_DEBOUNCE_MS: u64 = 300;
+
+fn get_tray_click_debounce() -> &'static Mutex<Instant> {
+    TRAY_CLICK_DEBOUNCE.get_or_init(|| Mutex::new(Instant::now() - Duration::from_secs(1)))
+}
+
+fn should_handle_tray_click() -> bool {
+    let debounce_lock = get_tray_click_debounce();
+    let mut last_click = debounce_lock.lock();
+    let now = Instant::now();
+
+    if now.duration_since(*last_click) >= Duration::from_millis(TRAY_CLICK_DEBOUNCE_MS) {
+        *last_click = now;
+        true
+    } else {
+        log::debug!(target: "app", "托盘点击被防抖机制忽略，距离上次点击 {:?}ms", 
+                  now.duration_since(*last_click).as_millis());
+        false
+    }
+}
+
 #[cfg(target_os = "macos")]
 pub struct Tray {
-    pub speed_rate: Arc<Mutex<Option<SpeedRate>>>,
-    shutdown_tx: Arc<RwLock<Option<broadcast::Sender<()>>>>,
-    is_subscribed: Arc<RwLock<bool>>,
-    pub rate_cache: Arc<Mutex<Option<Rate>>>,
+    last_menu_update: Mutex<Option<Instant>>,
+    menu_updating: AtomicBool,
 }

 #[cfg(not(target_os = "macos"))]
-pub struct Tray {}
+pub struct Tray {
+    last_menu_update: Mutex<Option<Instant>>,
+    menu_updating: AtomicBool,
+}

 impl TrayState {
    pub fn get_common_tray_icon() -> (bool, Vec<u8>) {
-        let verge = Config::verge().latest().clone();
+        let verge = Config::verge().latest_ref().clone();
        let is_common_tray_icon = verge.common_tray_icon.unwrap_or(false);
        if is_common_tray_icon {
-            if let Some(common_icon_path) = find_target_icons("common").unwrap() {
-                let icon_data = fs::read(common_icon_path).unwrap();
-                return (true, icon_data);
+            if let Ok(Some(common_icon_path)) = find_target_icons("common") {
+                if let Ok(icon_data) = fs::read(common_icon_path) {
+                    return (true, icon_data);
+                }
            }
        }
        #[cfg(target_os = "macos")]
@@ -83,12 +103,13 @@ impl TrayState {
    }

    pub fn get_sysproxy_tray_icon() -> (bool, Vec<u8>) {
-        let verge = Config::verge().latest().clone();
+        let verge = Config::verge().latest_ref().clone();
        let is_sysproxy_tray_icon = verge.sysproxy_tray_icon.unwrap_or(false);
        if is_sysproxy_tray_icon {
-            if let Some(sysproxy_icon_path) = find_target_icons("sysproxy").unwrap() {
-                let icon_data = fs::read(sysproxy_icon_path).unwrap();
-                return (true, icon_data);
+            if let Ok(Some(sysproxy_icon_path)) = find_target_icons("sysproxy") {
+                if let Ok(icon_data) = fs::read(sysproxy_icon_path) {
+                    return (true, icon_data);
+                }
            }
        }
        #[cfg(target_os = "macos")]
@@ -97,7 +118,7 @@ impl TrayState {
            if tray_icon_colorful == "monochrome" {
                (
                    false,
-                    include_bytes!("../../../icons/tray-icon-sys-mono.ico").to_vec(),
+                    include_bytes!("../../../icons/tray-icon-sys-mono-new.ico").to_vec(),
                )
            } else {
                (
@@ -117,12 +138,13 @@ impl TrayState {
    }

    pub fn get_tun_tray_icon() -> (bool, Vec<u8>) {
-        let verge = Config::verge().latest().clone();
+        let verge = Config::verge().latest_ref().clone();
        let is_tun_tray_icon = verge.tun_tray_icon.unwrap_or(false);
        if is_tun_tray_icon {
-            if let Some(tun_icon_path) = find_target_icons("tun").unwrap() {
-                let icon_data = fs::read(tun_icon_path).unwrap();
-                return (true, icon_data);
+            if let Ok(Some(tun_icon_path)) = find_target_icons("tun") {
+                if let Ok(icon_data) = fs::read(tun_icon_path) {
+                    return (true, icon_data);
+                }
            }
        }
        #[cfg(target_os = "macos")]
@@ -131,7 +153,7 @@ impl TrayState {
            if tray_icon_colorful == "monochrome" {
                (
                    false,
-                    include_bytes!("../../../icons/tray-icon-tun-mono.ico").to_vec(),
+                    include_bytes!("../../../icons/tray-icon-tun-mono-new.ico").to_vec(),
                )
            } else {
                (
@@ -150,76 +172,33 @@ impl TrayState {
    }
 }

+impl Default for Tray {
+    fn default() -> Self {
+        Tray {
+            last_menu_update: Mutex::new(None),
+            menu_updating: AtomicBool::new(false),
+        }
+    }
+}
+
+// Use simplified singleton_lazy macro
+singleton_lazy!(Tray, TRAY, Tray::default);
+
 impl Tray {
-    pub fn global() -> &'static Tray {
-        static TRAY: OnceCell<Tray> = OnceCell::new();
-
-        #[cfg(target_os = "macos")]
-        return TRAY.get_or_init(|| Tray {
-            speed_rate: Arc::new(Mutex::new(None)),
-            shutdown_tx: Arc::new(RwLock::new(None)),
-            is_subscribed: Arc::new(RwLock::new(false)),
-            rate_cache: Arc::new(Mutex::new(None)),
-        });
-
-        #[cfg(not(target_os = "macos"))]
-        return TRAY.get_or_init(|| Tray {});
-    }
-
    pub fn init(&self) -> Result<()> {
-        #[cfg(target_os = "macos")]
-        {
-            let mut speed_rate = self.speed_rate.lock();
-            *speed_rate = Some(SpeedRate::new());
-        }
-        Ok(())
-    }
-
-    pub fn create_systray(&self, app: &App) -> Result<()> {
-        let mut builder = TrayIconBuilder::with_id("main")
-            .icon(app.default_window_icon().unwrap().clone())
-            .icon_as_template(false);
-
-        #[cfg(any(target_os = "macos", target_os = "windows"))]
-        {
-            let tray_event = { Config::verge().latest().tray_event.clone() };
-            let tray_event: String = tray_event.unwrap_or("main_window".into());
-            if tray_event.as_str() != "tray_menu" {
-                builder = builder.show_menu_on_left_click(false);
-            }
-        }
-
-        let tray = builder.build(app)?;
-
-        tray.on_tray_icon_event(|_, event| {
-            let tray_event = { Config::verge().latest().tray_event.clone() };
-            let tray_event: String = tray_event.unwrap_or("main_window".into());
-            log::debug!(target: "app","tray event: {:?}", tray_event);
-
-            if let TrayIconEvent::Click {
-                button: MouseButton::Left,
-                button_state: MouseButtonState::Down,
-                ..
-            } = event
-            {
-                match tray_event.as_str() {
-                    "system_proxy" => feat::toggle_system_proxy(),
-                    "tun_mode" => feat::toggle_tun_mode(None),
-                    "main_window" => resolve::create_window(true),
-                    _ => {}
-                }
-            }
-        });
-        tray.on_menu_event(on_menu_event);
        Ok(())
    }

    /// 更新托盘点击行为
    pub fn update_click_behavior(&self) -> Result<()> {
-        let app_handle = handle::Handle::global().app_handle().unwrap();
-        let tray_event = { Config::verge().latest().tray_event.clone() };
+        let app_handle = handle::Handle::global()
+            .app_handle()
+            .ok_or_else(|| anyhow::anyhow!("Failed to get app handle for tray update"))?;
+        let tray_event = { Config::verge().latest_ref().tray_event.clone() };
        let tray_event: String = tray_event.unwrap_or("main_window".into());
-        let tray = app_handle.tray_by_id("main").unwrap();
+        let tray = app_handle
+            .tray_by_id("main")
+            .ok_or_else(|| anyhow::anyhow!("Failed to get main tray"))?;
        match tray_event.as_str() {
            "tray_menu" => tray.set_show_menu_on_left_click(true)?,
            _ => tray.set_show_menu_on_left_click(false)?,
@@ -229,13 +208,60 @@ impl Tray {

    /// 更新托盘菜单
    pub fn update_menu(&self) -> Result<()> {
-        let app_handle = handle::Handle::global().app_handle().unwrap();
-        let verge = Config::verge().latest().clone();
+        // 调整最小更新间隔，确保状态及时刷新
+        const MIN_UPDATE_INTERVAL: Duration = Duration::from_millis(100);
+
+        // 检查是否正在更新
+        if self.menu_updating.load(Ordering::Acquire) {
+            return Ok(());
+        }
+
+        // 检查更新频率，但允许重要事件跳过频率限制
+        let should_force_update = match std::thread::current().name() {
+            Some("main") => true,
+            _ => {
+                let last_update = self.last_menu_update.lock();
+                if let Some(last_time) = *last_update {
+                    last_time.elapsed() >= MIN_UPDATE_INTERVAL
+                } else {
+                    true
+                }
+            }
+        };
+
+        if !should_force_update {
+            return Ok(());
+        }
+
+        let app_handle = match handle::Handle::global().app_handle() {
+            Some(handle) => handle,
+            None => {
+                log::warn!(target: "app", "更新托盘菜单失败: app_handle不存在");
+                return Ok(());
+            }
+        };
+
+        // 设置更新状态
+        self.menu_updating.store(true, Ordering::Release);
+
+        let result = self.update_menu_internal(&app_handle);
+
+        {
+            let mut last_update = self.last_menu_update.lock();
+            *last_update = Some(Instant::now());
+        }
+        self.menu_updating.store(false, Ordering::Release);
+
+        result
+    }
+
+    fn update_menu_internal(&self, app_handle: &AppHandle) -> Result<()> {
+        let verge = Config::verge().latest_ref().clone();
        let system_proxy = verge.enable_system_proxy.as_ref().unwrap_or(&false);
        let tun_mode = verge.enable_tun_mode.as_ref().unwrap_or(&false);
        let mode = {
            Config::clash()
-                .latest()
+                .latest_ref()
                .0
                .get("mode")
                .map(|val| val.as_str().unwrap_or("rule"))
@@ -243,91 +269,136 @@ impl Tray {
                .to_owned()
        };
        let profile_uid_and_name = Config::profiles()
-            .data()
+            .data_mut()
            .all_profile_uid_and_name()
            .unwrap_or_default();
+        let is_lightweight_mode = is_in_lightweight_mode();

-        let tray = app_handle.tray_by_id("main").unwrap();
-        let _ = tray.set_menu(Some(create_tray_menu(
-            &app_handle,
-            Some(mode.as_str()),
-            *system_proxy,
-            *tun_mode,
-            profile_uid_and_name,
-        )?));
-        Ok(())
+        match app_handle.tray_by_id("main") {
+            Some(tray) => {
+                let _ = tray.set_menu(Some(create_tray_menu(
+                    app_handle,
+                    Some(mode.as_str()),
+                    *system_proxy,
+                    *tun_mode,
+                    profile_uid_and_name,
+                    is_lightweight_mode,
+                )?));
+                log::debug!(target: "app", "托盘菜单更新成功");
+                Ok(())
+            }
+            None => {
+                log::warn!(target: "app", "更新托盘菜单失败: 托盘不存在");
+                Ok(())
+            }
+        }
    }

    /// 更新托盘图标
-    pub fn update_icon(&self, rate: Option<Rate>) -> Result<()> {
-        let verge = Config::verge().latest().clone();
+    #[cfg(target_os = "macos")]
+    pub fn update_icon(&self, _rate: Option<Rate>) -> Result<()> {
+        let app_handle = match handle::Handle::global().app_handle() {
+            Some(handle) => handle,
+            None => {
+                log::warn!(target: "app", "更新托盘图标失败: app_handle不存在");
+                return Ok(());
+            }
+        };
+
+        let tray = match app_handle.tray_by_id("main") {
+            Some(tray) => tray,
+            None => {
+                log::warn!(target: "app", "更新托盘图标失败: 托盘不存在");
+                return Ok(());
+            }
+        };
+
+        let verge = Config::verge().latest_ref().clone();
        let system_mode = verge.enable_system_proxy.as_ref().unwrap_or(&false);
        let tun_mode = verge.enable_tun_mode.as_ref().unwrap_or(&false);

-        let app_handle = handle::Handle::global().app_handle().unwrap();
-        let tray = app_handle.tray_by_id("main").unwrap();
-
-        let (is_custom_icon, icon_bytes) = match (*system_mode, *tun_mode) {
+        let (_is_custom_icon, icon_bytes) = match (*system_mode, *tun_mode) {
            (true, true) => TrayState::get_tun_tray_icon(),
            (true, false) => TrayState::get_sysproxy_tray_icon(),
            (false, true) => TrayState::get_tun_tray_icon(),
            (false, false) => TrayState::get_common_tray_icon(),
        };
-        #[cfg(target_os = "macos")]
-        {
-            let enable_tray_speed = verge.enable_tray_speed.unwrap_or(true);
-            let enable_tray_icon = verge.enable_tray_icon.unwrap_or(true);
-            let colorful = verge.tray_icon.clone().unwrap_or("monochrome".to_string());
-            let is_colorful = colorful == "colorful";

-            if !enable_tray_speed {
-                let _ = tray.set_icon(Some(tauri::image::Image::from_bytes(&icon_bytes)?));
-                let _ = tray.set_icon_as_template(!is_colorful);
+        let colorful = verge.tray_icon.clone().unwrap_or("monochrome".to_string());
+        let is_colorful = colorful == "colorful";
+
+        let _ = tray.set_icon(Some(tauri::image::Image::from_bytes(&icon_bytes)?));
+        let _ = tray.set_icon_as_template(!is_colorful);
+        Ok(())
+    }
+
+    #[cfg(not(target_os = "macos"))]
+    pub fn update_icon(&self, _rate: Option<Rate>) -> Result<()> {
+        let app_handle = match handle::Handle::global().app_handle() {
+            Some(handle) => handle,
+            None => {
+                log::warn!(target: "app", "更新托盘图标失败: app_handle不存在");
                return Ok(());
            }
+        };

-            let rate = if let Some(rate) = rate {
-                Some(rate)
-            } else {
-                let guard = self.speed_rate.lock();
-                if let Some(rate) = guard.as_ref().unwrap().get_curent_rate() {
-                    Some(rate)
-                } else {
-                    Some(Rate::default())
-                }
-            };
-
-            let mut rate_guard = self.rate_cache.lock();
-            if *rate_guard != rate {
-                *rate_guard = rate;
-
-                let bytes = if enable_tray_icon {
-                    Some(icon_bytes)
-                } else {
-                    None
-                };
-
-                let rate = rate_guard.as_ref();
-                let rate_bytes = SpeedRate::add_speed_text(is_custom_icon, bytes, rate).unwrap();
-                let _ = tray.set_icon(Some(tauri::image::Image::from_bytes(&rate_bytes)?));
-                let _ = tray.set_icon_as_template(!is_custom_icon && !is_colorful);
+        let tray = match app_handle.tray_by_id("main") {
+            Some(tray) => tray,
+            None => {
+                log::warn!(target: "app", "更新托盘图标失败: 托盘不存在");
+                return Ok(());
            }
-            Ok(())
-        }
+        };

-        #[cfg(not(target_os = "macos"))]
-        {
-            let _ = tray.set_icon(Some(tauri::image::Image::from_bytes(&icon_bytes)?));
-            Ok(())
-        }
+        let verge = Config::verge().latest_ref().clone();
+        let system_mode = verge.enable_system_proxy.as_ref().unwrap_or(&false);
+        let tun_mode = verge.enable_tun_mode.as_ref().unwrap_or(&false);
+
+        let (_is_custom_icon, icon_bytes) = match (*system_mode, *tun_mode) {
+            (true, true) => TrayState::get_tun_tray_icon(),
+            (true, false) => TrayState::get_sysproxy_tray_icon(),
+            (false, true) => TrayState::get_tun_tray_icon(),
+            (false, false) => TrayState::get_common_tray_icon(),
+        };
+
+        let _ = tray.set_icon(Some(tauri::image::Image::from_bytes(&icon_bytes)?));
+        Ok(())
+    }
+
+    /// 更新托盘显示状态的函数
+    pub fn update_tray_display(&self) -> Result<()> {
+        let app_handle = handle::Handle::global()
+            .app_handle()
+            .ok_or_else(|| anyhow::anyhow!("Failed to get app handle for tray update"))?;
+        let _tray = app_handle
+            .tray_by_id("main")
+            .ok_or_else(|| anyhow::anyhow!("Failed to get main tray"))?;
+
+        // 更新菜单
+        self.update_menu()?;
+
+        Ok(())
    }

    /// 更新托盘提示
    pub fn update_tooltip(&self) -> Result<()> {
-        let app_handle = handle::Handle::global().app_handle().unwrap();
-        let version = VERSION.get().unwrap();
+        let app_handle = match handle::Handle::global().app_handle() {
+            Some(handle) => handle,
+            None => {
+                log::warn!(target: "app", "更新托盘提示失败: app_handle不存在");
+                return Ok(());
+            }
+        };

-        let verge = Config::verge().latest().clone();
+        let version = match VERSION.get() {
+            Some(v) => v,
+            None => {
+                log::warn!(target: "app", "更新托盘提示失败: 版本信息不存在");
+                return Ok(());
+            }
+        };
+
+        let verge = Config::verge().latest_ref().clone();
        let system_proxy = verge.enable_system_proxy.as_ref().unwrap_or(&false);
        let tun_mode = verge.enable_tun_mode.as_ref().unwrap_or(&false);

@@ -340,25 +411,30 @@ impl Tray {

        let mut current_profile_name = "None".to_string();
        let profiles = Config::profiles();
-        let profiles = profiles.latest();
+        let profiles = profiles.latest_ref();
        if let Some(current_profile_uid) = profiles.get_current() {
-            let current_profile = profiles.get_item(&current_profile_uid);
-            current_profile_name = match &current_profile.unwrap().name {
-                Some(profile_name) => profile_name.to_string(),
-                None => current_profile_name,
-            };
+            if let Ok(profile) = profiles.get_item(&current_profile_uid) {
+                current_profile_name = match &profile.name {
+                    Some(profile_name) => profile_name.to_string(),
+                    None => current_profile_name,
+                };
+            }
        };

-        let tray = app_handle.tray_by_id("main").unwrap();
-        let _ = tray.set_tooltip(Some(&format!(
-            "Clash Verge {version}\n{}: {}\n{}: {}\n{}: {}",
-            t("SysProxy"),
-            switch_map[system_proxy],
-            t("TUN"),
-            switch_map[tun_mode],
-            t("Profile"),
-            current_profile_name
-        )));
+        if let Some(tray) = app_handle.tray_by_id("main") {
+            let _ = tray.set_tooltip(Some(&format!(
+                "Clash Verge {version}\n{}: {}\n{}: {}\n{}: {}",
+                t("SysProxy"),
+                switch_map[system_proxy],
+                t("TUN"),
+                switch_map[tun_mode],
+                t("Profile"),
+                current_profile_name
+            )));
+        } else {
+            log::warn!(target: "app", "更新托盘提示失败: 托盘不存在");
+        }
+
        Ok(())
    }

@@ -366,75 +442,90 @@ impl Tray {
        self.update_menu()?;
        self.update_icon(None)?;
        self.update_tooltip()?;
-        Ok(())
-    }
-
-    /// 订阅流量数据
-    #[cfg(target_os = "macos")]
-    pub async fn subscribe_traffic(&self) -> Result<()> {
-        log::info!(target: "app", "subscribe traffic");
-
-        // 如果已经订阅，先取消订阅
-        if *self.is_subscribed.read() {
-            self.unsubscribe_traffic();
-        }
-
-        let (shutdown_tx, shutdown_rx) = broadcast::channel(1);
-        *self.shutdown_tx.write() = Some(shutdown_tx);
-        *self.is_subscribed.write() = true;
-
-        let speed_rate = Arc::clone(&self.speed_rate);
-        let is_subscribed = Arc::clone(&self.is_subscribed);
-
-        tauri::async_runtime::spawn(async move {
-            let mut shutdown = shutdown_rx;
-
-            'outer: loop {
-                match Traffic::get_traffic_stream().await {
-                    Ok(mut stream) => loop {
-                        tokio::select! {
-                            Some(traffic) = stream.next() => {
-                                if let Ok(traffic) = traffic {
-                                    let guard = speed_rate.lock();
-                                    let enable_tray_speed: bool = Config::verge().latest().enable_tray_speed.unwrap_or(true);
-                                    if !enable_tray_speed {
-                                        continue;
-                                    }
-                                    if let Some(sr) = guard.as_ref() {
-                                        if let Some(rate) = sr.update_and_check_changed(traffic.up, traffic.down) {
-                                            let _ = Tray::global().update_icon(Some(rate));
-                                        }
-                                    }
-                                }
-                            }
-                            _ = shutdown.recv() => break 'outer,
-                        }
-                    },
-                    Err(e) => {
-                        log::error!(target: "app", "Failed to get traffic stream: {}", e);
-                        // 如果获取流失败，等待一段时间后重试
-                        tokio::time::sleep(std::time::Duration::from_secs(1)).await;
-
-                        // 检查是否应该继续重试
-                        if !*is_subscribed.read() {
-                            break;
-                        }
-                    }
-                }
-            }
-        });
-
+        // 更新轻量模式显示状态
+        self.update_tray_display()?;
        Ok(())
    }

    /// 取消订阅 traffic 数据
    #[cfg(target_os = "macos")]
-    pub fn unsubscribe_traffic(&self) {
-        log::info!(target: "app", "unsubscribe traffic");
-        *self.is_subscribed.write() = false;
-        if let Some(tx) = self.shutdown_tx.write().take() {
-            drop(tx);
+    pub fn unsubscribe_traffic(&self) {}
+
+    pub fn create_tray_from_handle(&self, app_handle: &AppHandle) -> Result<()> {
+        log::info!(target: "app", "正在从AppHandle创建系统托盘");
+
+        // 获取图标
+        let icon_bytes = TrayState::get_common_tray_icon().1;
+        let icon = tauri::image::Image::from_bytes(&icon_bytes)?;
+
+        #[cfg(target_os = "linux")]
+        let builder = TrayIconBuilder::with_id("main")
+            .icon(icon)
+            .icon_as_template(false);
+
+        #[cfg(not(target_os = "linux"))]
+        let mut builder = TrayIconBuilder::with_id("main")
+            .icon(icon)
+            .icon_as_template(false);
+
+        #[cfg(any(target_os = "macos", target_os = "windows"))]
+        {
+            let tray_event = { Config::verge().latest_ref().tray_event.clone() };
+            let tray_event: String = tray_event.unwrap_or("main_window".into());
+            if tray_event.as_str() != "tray_menu" {
+                builder = builder.show_menu_on_left_click(false);
+            }
        }
+
+        let tray = builder.build(app_handle)?;
+
+        tray.on_tray_icon_event(|_, event| {
+            let tray_event = { Config::verge().latest_ref().tray_event.clone() };
+            let tray_event: String = tray_event.unwrap_or("main_window".into());
+            log::debug!(target: "app","tray event: {tray_event:?}");
+
+            if let TrayIconEvent::Click {
+                button: MouseButton::Left,
+                button_state: MouseButtonState::Down,
+                ..
+            } = event
+            {
+                // 添加防抖检查，防止快速连击
+                if !should_handle_tray_click() {
+                    return;
+                }
+
+                match tray_event.as_str() {
+                    "system_proxy" => feat::toggle_system_proxy(),
+                    "tun_mode" => feat::toggle_tun_mode(None),
+                    "main_window" => {
+                        use crate::utils::window_manager::WindowManager;
+                        log::info!(target: "app", "Tray点击事件: 显示主窗口");
+                        if crate::module::lightweight::is_in_lightweight_mode() {
+                            log::info!(target: "app", "当前在轻量模式，正在退出轻量模式");
+                            crate::module::lightweight::exit_lightweight_mode();
+                        }
+                        let result = WindowManager::show_main_window();
+                        log::info!(target: "app", "窗口显示结果: {result:?}");
+                    }
+                    _ => {}
+                }
+            }
+        });
+        tray.on_menu_event(on_menu_event);
+        log::info!(target: "app", "系统托盘创建成功");
+        Ok(())
+    }
+
+    // 托盘统一的状态更新函数
+    pub fn update_all_states(&self) -> Result<()> {
+        // 确保所有状态更新完成
+        self.update_menu()?;
+        self.update_icon(None)?;
+        self.update_tooltip()?;
+        self.update_tray_display()?;
+
+        Ok(())
    }
 }

@@ -444,11 +535,15 @@ fn create_tray_menu(
    system_proxy_enabled: bool,
    tun_mode_enabled: bool,
    profile_uid_and_name: Vec<(String, String)>,
+    is_lightweight_mode: bool,
 ) -> Result<tauri::menu::Menu<Wry>> {
    let mode = mode.unwrap_or("");
-    let version = VERSION.get().unwrap();
+
+    let unknown_version = String::from("unknown");
+    let version = VERSION.get().unwrap_or(&unknown_version);
+
    let hotkeys = Config::verge()
-        .latest()
+        .latest_ref()
        .hotkeys
        .as_ref()
        .map(|h| {
@@ -468,19 +563,18 @@ fn create_tray_menu(
        .iter()
        .map(|(profile_uid, profile_name)| {
            let is_current_profile = Config::profiles()
-                .data()
+                .data_mut()
                .is_current_profile_index(profile_uid.to_string());
            CheckMenuItem::with_id(
                app_handle,
-                format!("profiles_{}", profile_uid),
+                format!("profiles_{profile_uid}"),
                t(profile_name),
                true,
                is_current_profile,
                None::<&str>,
            )
-            .unwrap()
        })
-        .collect();
+        .collect::<Result<Vec<_>, _>>()?;
    let profile_menu_items: Vec<&dyn IsMenuItem<Wry>> = profile_menu_items
        .iter()
        .map(|item| item as &dyn IsMenuItem<Wry>)
@@ -492,8 +586,7 @@ fn create_tray_menu(
        t("Dashboard"),
        true,
        hotkeys.get("open_or_close_dashboard").map(|s| s.as_str()),
-    )
-    .unwrap();
+    )?;

    let rule_mode = &CheckMenuItem::with_id(
        app_handle,
@@ -502,8 +595,7 @@ fn create_tray_menu(
        true,
        mode == "rule",
        hotkeys.get("clash_mode_rule").map(|s| s.as_str()),
-    )
-    .unwrap();
+    )?;

    let global_mode = &CheckMenuItem::with_id(
        app_handle,
@@ -512,8 +604,7 @@ fn create_tray_menu(
        true,
        mode == "global",
        hotkeys.get("clash_mode_global").map(|s| s.as_str()),
-    )
-    .unwrap();
+    )?;

    let direct_mode = &CheckMenuItem::with_id(
        app_handle,
@@ -522,8 +613,7 @@ fn create_tray_menu(
        true,
        mode == "direct",
        hotkeys.get("clash_mode_direct").map(|s| s.as_str()),
-    )
-    .unwrap();
+    )?;

    let profiles = &Submenu::with_id_and_items(
        app_handle,
@@ -531,8 +621,7 @@ fn create_tray_menu(
        t("Profiles"),
        true,
        &profile_menu_items,
-    )
-    .unwrap();
+    )?;

    let system_proxy = &CheckMenuItem::with_id(
        app_handle,
@@ -541,8 +630,7 @@ fn create_tray_menu(
        true,
        system_proxy_enabled,
        hotkeys.get("toggle_system_proxy").map(|s| s.as_str()),
-    )
-    .unwrap();
+    )?;

    let tun_mode = &CheckMenuItem::with_id(
        app_handle,
@@ -551,20 +639,18 @@ fn create_tray_menu(
        true,
        tun_mode_enabled,
        hotkeys.get("toggle_tun_mode").map(|s| s.as_str()),
-    )
-    .unwrap();
+    )?;

-    let lighteweight_mode = &MenuItem::with_id(
+    let lighteweight_mode = &CheckMenuItem::with_id(
        app_handle,
        "entry_lightweight_mode",
        t("LightWeight Mode"),
        true,
+        is_lightweight_mode,
        hotkeys.get("entry_lightweight_mode").map(|s| s.as_str()),
-    )
-    .unwrap();
+    )?;

-    let copy_env =
-        &MenuItem::with_id(app_handle, "copy_env", t("Copy Env"), true, None::<&str>).unwrap();
+    let copy_env = &MenuItem::with_id(app_handle, "copy_env", t("Copy Env"), true, None::<&str>)?;

    let open_app_dir = &MenuItem::with_id(
        app_handle,
@@ -572,8 +658,7 @@ fn create_tray_menu(
        t("Conf Dir"),
        true,
        None::<&str>,
-    )
-    .unwrap();
+    )?;

    let open_core_dir = &MenuItem::with_id(
        app_handle,
@@ -581,8 +666,7 @@ fn create_tray_menu(
        t("Core Dir"),
        true,
        None::<&str>,
-    )
-    .unwrap();
+    )?;

    let open_logs_dir = &MenuItem::with_id(
        app_handle,
@@ -590,8 +674,7 @@ fn create_tray_menu(
        t("Logs Dir"),
        true,
        None::<&str>,
-    )
-    .unwrap();
+    )?;

    let open_dir = &Submenu::with_id_and_items(
        app_handle,
@@ -599,8 +682,7 @@ fn create_tray_menu(
        t("Open Dir"),
        true,
        &[open_app_dir, open_core_dir, open_logs_dir],
-    )
-    .unwrap();
+    )?;

    let restart_clash = &MenuItem::with_id(
        app_handle,
@@ -608,8 +690,7 @@ fn create_tray_menu(
        t("Restart Clash Core"),
        true,
        None::<&str>,
-    )
-    .unwrap();
+    )?;

    let restart_app = &MenuItem::with_id(
        app_handle,
@@ -617,8 +698,7 @@ fn create_tray_menu(
        t("Restart App"),
        true,
        None::<&str>,
-    )
-    .unwrap();
+    )?;

    let app_version = &MenuItem::with_id(
        app_handle,
@@ -626,8 +706,7 @@ fn create_tray_menu(
        format!("{} {version}", t("Verge Version")),
        true,
        None::<&str>,
-    )
-    .unwrap();
+    )?;

    let more = &Submenu::with_id_and_items(
        app_handle,
@@ -635,13 +714,11 @@ fn create_tray_menu(
        t("More"),
        true,
        &[restart_clash, restart_app, app_version],
-    )
-    .unwrap();
+    )?;

-    let quit =
-        &MenuItem::with_id(app_handle, "quit", t("Exit"), true, Some("CmdOrControl+Q")).unwrap();
+    let quit = &MenuItem::with_id(app_handle, "quit", t("Exit"), true, Some("CmdOrControl+Q"))?;

-    let separator = &PredefinedMenuItem::separator(app_handle).unwrap();
+    let separator = &PredefinedMenuItem::separator(app_handle)?;

    let menu = tauri::menu::MenuBuilder::new(app_handle)
        .items(&[
@@ -663,8 +740,7 @@ fn create_tray_menu(
            separator,
            quit,
        ])
-        .build()
-        .unwrap();
+        .build()?;
    Ok(menu)
 }

@@ -672,21 +748,68 @@ fn on_menu_event(_: &AppHandle, event: MenuEvent) {
    match event.id.as_ref() {
        mode @ ("rule_mode" | "global_mode" | "direct_mode") => {
            let mode = &mode[0..mode.len() - 5];
-            println!("change mode to: {}", mode);
+            logging!(
+                info,
+                Type::ProxyMode,
+                true,
+                "Switch Proxy Mode To: {}",
+                mode
+            );
            feat::change_clash_mode(mode.into());
        }
-        "open_window" => resolve::create_window(true),
-        "system_proxy" => feat::toggle_system_proxy(),
-        "tun_mode" => feat::toggle_tun_mode(None),
+        "open_window" => {
+            use crate::utils::window_manager::WindowManager;
+            log::info!(target: "app", "托盘菜单点击: 打开窗口");
+
+            if !should_handle_tray_click() {
+                return;
+            }
+
+            if crate::module::lightweight::is_in_lightweight_mode() {
+                log::info!(target: "app", "当前在轻量模式，正在退出");
+                crate::module::lightweight::exit_lightweight_mode();
+            }
+            let result = WindowManager::show_main_window();
+            log::info!(target: "app", "窗口显示结果: {result:?}");
+        }
+        "system_proxy" => {
+            feat::toggle_system_proxy();
+        }
+        "tun_mode" => {
+            feat::toggle_tun_mode(None);
+        }
        "copy_env" => feat::copy_clash_env(),
-        "open_app_dir" => crate::logging_error!(Type::Cmd, true, cmd::open_app_dir()),
-        "open_core_dir" => crate::logging_error!(Type::Cmd, true, cmd::open_core_dir()),
-        "open_logs_dir" => crate::logging_error!(Type::Cmd, true, cmd::open_logs_dir()),
+        "open_app_dir" => {
+            let _ = cmd::open_app_dir();
+        }
+        "open_core_dir" => {
+            let _ = cmd::open_core_dir();
+        }
+        "open_logs_dir" => {
+            let _ = cmd::open_logs_dir();
+        }
        "restart_clash" => feat::restart_clash_core(),
        "restart_app" => feat::restart_app(),
-        "entry_lightweight_mode" => entry_lightweight_mode(),
+        "entry_lightweight_mode" => {
+            if !should_handle_tray_click() {
+                return;
+            }
+
+            let was_lightweight = crate::module::lightweight::is_in_lightweight_mode();
+            if was_lightweight {
+                crate::module::lightweight::exit_lightweight_mode();
+            } else {
+                crate::module::lightweight::entry_lightweight_mode();
+            }
+
+            if was_lightweight {
+                use crate::utils::window_manager::WindowManager;
+                let result = WindowManager::show_main_window();
+                log::info!(target: "app", "退出轻量模式后显示主窗口: {result:?}");
+            }
+        }
        "quit" => {
-            feat::quit(Some(0));
+            feat::quit();
        }
        id if id.starts_with("profiles_") => {
            let profile_index = &id["profiles_".len()..];
@@ -694,4 +817,8 @@ fn on_menu_event(_: &AppHandle, event: MenuEvent) {
        }
        _ => {}
    }
+
+    if let Err(e) = Tray::global().update_all_states() {
+        log::warn!(target: "app", "更新托盘状态失败: {e}");
+    }
 }
@@ -1,285 +1 @@
-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, Message};
-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::stream::{self, StreamExt};
-        use std::time::Duration;
-
-        let stream = Box::pin(
-            stream::unfold((), |_| async {
-                loop {
-                    let (url, token) = MihomoManager::get_traffic_ws_url();
-                    let mut request = url.into_client_request().unwrap();
-                    request
-                        .headers_mut()
-                        .insert(http::header::AUTHORIZATION, token);
-
-                    match tokio_tungstenite::connect_async(request).await {
-                        Ok((ws_stream, _)) => {
-                            log::info!(target: "app", "traffic ws connection established");
-                            return Some((
-                                ws_stream.map(|msg| {
-                                    msg.map_err(anyhow::Error::from).and_then(|msg: Message| {
-                                        let data = msg.into_text()?;
-                                        let json: serde_json::Value = serde_json::from_str(&data)?;
-                                        Ok(Traffic {
-                                            up: json["up"].as_u64().unwrap_or(0),
-                                            down: json["down"].as_u64().unwrap_or(0),
-                                        })
-                                    })
-                                }),
-                                (),
-                            ));
-                        }
-                        Err(e) => {
-                            log::error!(target: "app", "traffic ws connection failed: {e}");
-                            tokio::time::sleep(Duration::from_secs(5)).await;
-                            continue;
-                        }
-                    }
-                }
-            })
-            .flatten(),
-        );
-
-        Ok(stream)
-    }
-}
@@ -6,7 +6,7 @@ use deelevate::{PrivilegeLevel, Token};
 use runas::Command as RunasCommand;
 use std::process::Command as StdCommand;

-pub async fn invoke_uwptools() -> Result<()> {
+pub fn invoke_uwptools() -> Result<()> {
    let resource_dir = dirs::app_resources_dir()?;
    let tool_path = resource_dir.join("enableLoopback.exe");

@@ -18,7 +18,10 @@ pub fn use_merge(merge: Mapping, config: Mapping) -> Mapping {

    deep_merge(&mut config, &Value::from(merge));

-    let config = config.as_mapping().unwrap().clone();
+    let config = config.as_mapping().cloned().unwrap_or_else(|| {
+        log::error!("Failed to convert merged config to mapping, using empty mapping");
+        Mapping::new()
+    });

    config
 }
@@ -14,15 +14,15 @@ type ResultLog = Vec<(String, String)>;

 /// Enhance mode
 /// 返回最终订阅、该订阅包含的键、和script执行的结果
-pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
+pub fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
    // config.yaml 的订阅
-    let clash_config = { Config::clash().latest().0.clone() };
+    let clash_config = { Config::clash().latest_ref().0.clone() };

    let (clash_core, enable_tun, enable_builtin, socks_enabled, http_enabled, enable_dns_settings) = {
        let verge = Config::verge();
-        let verge = verge.latest();
+        let verge = verge.latest_ref();
        (
-            verge.clash_core.clone(),
+            Some(verge.get_valid_clash_core()),
            verge.enable_tun_mode.unwrap_or(false),
            verge.enable_builtin_enhanced.unwrap_or(true),
            verge.verge_socks_enabled.unwrap_or(false),
@@ -33,13 +33,13 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
    #[cfg(not(target_os = "windows"))]
    let redir_enabled = {
        let verge = Config::verge();
-        let verge = verge.latest();
+        let verge = verge.latest_ref();
        verge.verge_redir_enabled.unwrap_or(false)
    };
    #[cfg(target_os = "linux")]
    let tproxy_enabled = {
        let verge = Config::verge();
-        let verge = verge.latest();
+        let verge = verge.latest_ref();
        verge.verge_tproxy_enabled.unwrap_or(false)
    };

@@ -56,7 +56,7 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
        profile_name,
    ) = {
        let profiles = Config::profiles();
-        let profiles = profiles.latest();
+        let profiles = profiles.latest_ref();

        let current = profiles.current_mapping().unwrap_or_default();
        let merge = profiles
@@ -214,6 +214,12 @@ 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 {
@@ -228,7 +234,22 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
                    continue;
                }
            }
-            config.insert(key, value);
+            // 处理 external-controller 键的开关逻辑
+            if key.as_str() == Some("external-controller") {
+                let enable_external_controller = Config::verge()
+                    .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);
+            }
        }
    }

@@ -253,7 +274,7 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
            });
    }

-    config = use_tun(config, enable_tun).await;
+    config = use_tun(config, enable_tun);
    config = use_sort(config);

    // 应用独立的DNS配置（如果启用）
@@ -261,16 +282,29 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
        use crate::utils::dirs;
        use std::fs;

-        // 尝试读取dns_config.yaml
        if let Ok(app_dir) = dirs::app_home_dir() {
            let dns_path = app_dir.join("dns_config.yaml");

            if dns_path.exists() {
                if let Ok(dns_yaml) = fs::read_to_string(&dns_path) {
                    if let Ok(dns_config) = serde_yaml::from_str::<serde_yaml::Mapping>(&dns_yaml) {
-                        // 将DNS配置合并到最终配置中
-                        config.insert("dns".into(), dns_config.into());
-                        log::info!(target: "app", "apply dns_config.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)");
+                            }
+                        } else {
+                            config.insert("dns".into(), dns_config.into());
+                            log::info!(target: "app", "apply dns_config.yaml");
+                        }
                    }
                }
            }
@@ -7,24 +7,43 @@ pub fn use_script(
    config: Mapping,
    name: String,
 ) -> Result<(Mapping, Vec<(String, String)>)> {
-    use boa_engine::{native_function::NativeFunction, Context, JsValue, Source};
-    use std::sync::{Arc, Mutex};
+    use boa_engine::{native_function::NativeFunction, Context, JsString, JsValue, Source};
+    use std::{cell::RefCell, rc::Rc};
    let mut context = Context::default();

-    let outputs = Arc::new(Mutex::new(vec![]));
+    let outputs = Rc::new(RefCell::new(vec![]));

-    let copy_outputs = outputs.clone();
+    let copy_outputs = Rc::clone(&outputs);
    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().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();
+                    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();
                    out.push((level, data));
                    Ok(JsValue::undefined())
                },
@@ -33,38 +52,45 @@ pub fn use_script(
    }
    let _ = context.eval(Source::from_bytes(
        r#"var console = Object.freeze({
-        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))},
+        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))},
      });"#,
    ));

    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},'{name}')||'')
+        JSON.stringify(main({config_str},'{safe_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).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();
+        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();
        match res {
            Ok(config) => Ok((use_lowercase(config), out.to_vec())),
            Err(err) => {
@@ -77,7 +103,30 @@ 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) {
@@ -90,7 +139,7 @@ fn test_script() {
    }
  "#;

-    let config = r#"
+    let config = r"
    rules:
      - 111
      - 222
@@ -98,12 +147,37 @@ fn test_script() {
      enable: false
    dns:
      enable: false
-  "#;
+  ";

-    let config = serde_yaml::from_str(config).unwrap();
-    let (config, results) = use_script(script.into(), config, "".to_string()).unwrap();
+    let config = serde_yaml::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 _ = serde_yaml::to_string(&config).unwrap();
+    let _ = serde_yaml::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);
+}

-    dbg!(results);
+// 测试特殊字符转义功能
+#[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"));
 }
@@ -89,6 +89,8 @@ mod tests {
    use serde_yaml::Value;

    #[test]
+    #[allow(clippy::unwrap_used)]
+    #[allow(clippy::expect_used)]
    fn test_delete_proxy_and_references() {
        let config_str = r#"
 proxies:
@@ -107,7 +109,8 @@ proxy-groups:
  proxies:
    - "proxy1"
 "#;
-        let mut config: Mapping = serde_yaml::from_str(config_str).unwrap();
+        let mut config: Mapping =
+            serde_yaml::from_str(config_str).expect("Failed to parse test config YAML");

        let seq = SeqMap {
            prepend: Sequence::new(),
@@ -118,38 +121,51 @@ proxy-groups:
        config = use_seq(seq, config, "proxies");

        // Check if proxy1 is removed from proxies
-        let proxies = config.get("proxies").unwrap().as_sequence().unwrap();
+        let proxies = config
+            .get("proxies")
+            .expect("proxies field should exist")
+            .as_sequence()
+            .expect("proxies should be a sequence");
        assert_eq!(proxies.len(), 1);
        assert_eq!(
            proxies[0]
                .as_mapping()
-                .unwrap()
+                .expect("proxy should be a mapping")
                .get("name")
-                .unwrap()
+                .expect("proxy should have name")
                .as_str()
-                .unwrap(),
+                .expect("name should be string"),
            "proxy2"
        );

        // Check if proxy1 is removed from all groups
-        let groups = config.get("proxy-groups").unwrap().as_sequence().unwrap();
+        let groups = config
+            .get("proxy-groups")
+            .expect("proxy-groups field should exist")
+            .as_sequence()
+            .expect("proxy-groups should be a sequence");
        let group1_proxies = groups[0]
            .as_mapping()
-            .unwrap()
+            .expect("group should be a mapping")
            .get("proxies")
-            .unwrap()
+            .expect("group should have proxies")
            .as_sequence()
-            .unwrap();
+            .expect("group proxies should be a sequence");
        let group2_proxies = groups[1]
            .as_mapping()
-            .unwrap()
+            .expect("group should be a mapping")
            .get("proxies")
-            .unwrap()
+            .expect("group should have proxies")
            .as_sequence()
-            .unwrap();
+            .expect("group proxies should be a sequence");

        assert_eq!(group1_proxies.len(), 1);
-        assert_eq!(group1_proxies[0].as_str().unwrap(), "proxy2");
+        assert_eq!(
+            group1_proxies[0]
+                .as_str()
+                .expect("proxy name should be string"),
+            "proxy2"
+        );
        assert_eq!(group2_proxies.len(), 0);
    }
 }
@@ -1,5 +1,8 @@
 use serde_yaml::{Mapping, Value};

+#[cfg(target_os = "macos")]
+use crate::process::AsyncHandler;
+
 macro_rules! revise {
    ($map: expr, $key: expr, $val: expr) => {
        let ret_key = Value::String($key.into());
@@ -18,7 +21,7 @@ macro_rules! append {
    };
 }

-pub async fn use_tun(mut config: Mapping, enable: bool) -> Mapping {
+pub 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| {
@@ -59,8 +62,10 @@ pub async fn use_tun(mut config: Mapping, enable: bool) -> Mapping {

            #[cfg(target_os = "macos")]
            {
-                crate::utils::resolve::restore_public_dns().await;
-                crate::utils::resolve::set_public_dns("223.6.6.6".to_string()).await;
+                AsyncHandler::spawn(move || async move {
+                    crate::utils::resolve::restore_public_dns().await;
+                    crate::utils::resolve::set_public_dns("223.6.6.6".to_string()).await;
+                });
            }
        }

@@ -69,7 +74,9 @@ pub async fn use_tun(mut config: Mapping, enable: bool) -> Mapping {
    } else {
        // TUN未启用时，仅恢复系统DNS，不修改配置文件中的DNS设置
        #[cfg(target_os = "macos")]
-        crate::utils::resolve::restore_public_dns().await;
+        AsyncHandler::spawn(move || async move {
+            crate::utils::resolve::restore_public_dns().await;
+        });
    }

    // 更新TUN配置
@@ -1 +0,0 @@
-pub mod service;
@@ -1 +0,0 @@
-
@@ -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,7 +44,7 @@ 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
        })
 }
@@ -52,17 +52,19 @@ pub async fn delete_webdav_backup(filename: String) -> Result<()> {
 /// Restore WebDAV backup
 pub async fn restore_webdav_backup(filename: String) -> Result<()> {
    let verge = Config::verge();
-    let verge_data = verge.data().clone();
+    let verge_data = verge.latest_ref().clone();
    let webdav_url = verge_data.webdav_url.clone();
    let webdav_username = verge_data.webdav_username.clone();
    let webdav_password = verge_data.webdav_password.clone();

-    let backup_storage_path = app_home_dir().unwrap().join(&filename);
+    let backup_storage_path = app_home_dir()
+        .map_err(|e| anyhow::anyhow!("Failed to get app home dir: {e}"))?
+        .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
        })?;

@@ -1,8 +1,9 @@
 use crate::{
    config::Config,
    core::{handle, tray, CoreManager},
+    ipc::IpcManager,
    logging_error,
-    module::mihomo::MihomoManager,
+    process::AsyncHandler,
    utils::{logging::Type, resolve},
 };
 use serde_yaml::{Mapping, Value};
@@ -10,7 +11,7 @@ use tauri::Manager;

 /// Restart the Clash core
 pub fn restart_clash_core() {
-    tauri::async_runtime::spawn(async {
+    AsyncHandler::spawn(move || async move {
        match CoreManager::global().restart_core().await {
            Ok(_) => {
                handle::Handle::refresh_clash();
@@ -26,31 +27,40 @@ pub fn restart_clash_core() {

 /// Restart the application
 pub fn restart_app() {
-    tauri::async_runtime::spawn_blocking(|| {
-        tauri::async_runtime::block_on(async {
-            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());
-        });
+    AsyncHandler::spawn(move || async move {
+        // logging_error!(Type::Core, true, CoreManager::global().stop_core().await);
+        resolve::resolve_reset_async().await;
+
+        handle::Handle::global()
+            .app_handle()
+            .map(|app_handle| {
+                tauri::process::restart(&app_handle.env());
+            })
+            .unwrap_or_else(|| {
+                logging_error!(
+                    Type::System,
+                    false,
+                    "{}",
+                    "Failed to get app handle for restart"
+                );
+            });
    });
 }

 fn after_change_clash_mode() {
-    tauri::async_runtime::spawn(async {
-        match MihomoManager::global().get_connections().await {
+    AsyncHandler::spawn(move || async {
+        match IpcManager::global().get_connections().await {
            Ok(connections) => {
                if let Some(connections_array) = connections["connections"].as_array() {
                    for connection in connections_array {
                        if let Some(id) = connection["id"].as_str() {
-                            let _ = MihomoManager::global().delete_connection(id).await;
+                            let _ = IpcManager::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}");
            }
        }
    });
@@ -64,67 +74,60 @@ pub fn change_clash_mode(mode: String) {
    let json_value = serde_json::json!({
        "mode": mode
    });
-    tauri::async_runtime::spawn(async move {
+    AsyncHandler::spawn(move || async move {
        log::debug!(target: "app", "change clash mode to {mode}");
-        match MihomoManager::global().patch_configs(json_value).await {
+        match IpcManager::global().patch_configs(json_value).await {
            Ok(_) => {
                // 更新订阅
-                Config::clash().data().patch_config(mapping);
+                Config::clash().data_mut().patch_config(mapping);

-                if Config::clash().data().save_config().is_ok() {
+                if Config::clash().data_mut().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()
-                    .data()
+                    .data_mut()
                    .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
 pub async fn test_delay(url: String) -> anyhow::Result<u32> {
-    use tokio::time::{Duration, Instant};
-    let mut builder = reqwest::ClientBuilder::new().use_rustls_tls().no_proxy();
+    use crate::utils::network::{NetworkManager, ProxyType};
+    use tokio::time::Instant;

-    let port = Config::verge()
-        .latest()
-        .verge_mixed_port
-        .unwrap_or(Config::clash().data().get_mixed_port());
-    let tun_mode = Config::verge().latest().enable_tun_mode.unwrap_or(false);
+    let tun_mode = Config::verge()
+        .latest_ref()
+        .enable_tun_mode
+        .unwrap_or(false);

-    let proxy_scheme = format!("http://127.0.0.1:{port}");
+    // 如果是TUN模式，不使用代理，否则使用自身代理
+    let proxy_type = if !tun_mode {
+        ProxyType::Localhost
+    } else {
+        ProxyType::None
+    };

-    if !tun_mode {
-        if let Ok(proxy) = reqwest::Proxy::http(&proxy_scheme) {
-            builder = builder.proxy(proxy);
-        }
-        if let Ok(proxy) = reqwest::Proxy::https(&proxy_scheme) {
-            builder = builder.proxy(proxy);
-        }
-        if let Ok(proxy) = reqwest::Proxy::all(&proxy_scheme) {
-            builder = builder.proxy(proxy);
-        }
-    }
+    let user_agent = Some("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 Edg/120.0.0.0".to_string());

-    let request = builder
-        .timeout(Duration::from_millis(10000))
-        .build()?
-        .get(url).header("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 Edg/120.0.0.0");
    let start = Instant::now();

-    let response = request.send().await;
+    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 {
@@ -132,8 +135,8 @@ pub async fn test_delay(url: String) -> anyhow::Result<u32> {
            }
        }
        Err(err) => {
-            log::trace!(target: "app", "test_delay error: {:#?}", err);
-            Err(err.into())
+            log::trace!(target: "app", "test_delay error: {err:#?}");
+            Err(err)
        }
    }
 }
@@ -10,19 +10,19 @@ use serde_yaml::Mapping;

 /// Patch Clash configuration
 pub async fn patch_clash(patch: Mapping) -> Result<()> {
-    Config::clash().draft().patch_config(patch.clone());
+    Config::clash().draft_mut().patch_config(patch.clone());

    let res = {
        // 激活订阅
        if patch.get("secret").is_some() || patch.get("external-controller").is_some() {
-            Config::generate().await?;
+            Config::generate()?;
            CoreManager::global().restart_core().await?;
        } else {
            if patch.get("mode").is_some() {
                logging_error!(Type::Tray, true, tray::Tray::global().update_menu());
                logging_error!(Type::Tray, true, tray::Tray::global().update_icon(None));
            }
-            Config::runtime().latest().patch_config(patch);
+            Config::runtime().draft_mut().patch_config(patch);
            CoreManager::global().update_config().await?;
        }
        handle::Handle::refresh_clash();
@@ -31,7 +31,7 @@ pub async fn patch_clash(patch: Mapping) -> Result<()> {
    match res {
        Ok(()) => {
            Config::clash().apply();
-            Config::clash().data().save_config()?;
+            Config::clash().data_mut().save_config()?;
            Ok(())
        }
        Err(err) => {
@@ -60,7 +60,7 @@ enum UpdateFlags {

 /// Patch Verge configuration
 pub async fn patch_verge(patch: IVerge, not_save_file: bool) -> Result<()> {
-    Config::verge().draft().patch_config(patch.clone());
+    Config::verge().draft_mut().patch_config(patch.clone());

    let tun_mode = patch.enable_tun_mode;
    let auto_launch = patch.enable_auto_launch;
@@ -95,6 +95,7 @@ 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;
@@ -165,9 +166,14 @@ 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?;
+            Config::generate()?;
            CoreManager::global().restart_core().await?;
        }
        if (update_flags & (UpdateFlags::ClashConfig as i32)) != 0 {
@@ -175,7 +181,7 @@ 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().draft().enable_global_hotkey = enable_global_hotkey;
+            Config::verge().draft_mut().enable_global_hotkey = enable_global_hotkey;
            handle::Handle::refresh_verge();
        }
        if (update_flags & (UpdateFlags::Launch as i32)) != 0 {
@@ -185,7 +191,9 @@ pub async fn patch_verge(patch: IVerge, not_save_file: bool) -> Result<()> {
            sysopt::Sysopt::global().update_sysproxy().await?;
        }
        if (update_flags & (UpdateFlags::Hotkey as i32)) != 0 {
-            hotkey::Hotkey::global().update(patch.hotkeys.unwrap())?;
+            if let Some(hotkeys) = patch.hotkeys {
+                hotkey::Hotkey::global().update(hotkeys)?;
+            }
        }
        if (update_flags & (UpdateFlags::SystrayMenu as i32)) != 0 {
            tray::Tray::global().update_menu()?;
@@ -200,7 +208,7 @@ pub async fn patch_verge(patch: IVerge, not_save_file: bool) -> Result<()> {
            tray::Tray::global().update_click_behavior()?;
        }
        if (update_flags & (UpdateFlags::LighteWeight as i32)) != 0 {
-            if enable_auto_light_weight.unwrap() {
+            if enable_auto_light_weight.unwrap_or(false) {
                lightweight::enable_auto_light_weight_mode();
            } else {
                lightweight::disable_auto_light_weight_mode();
@@ -213,7 +221,7 @@ pub async fn patch_verge(patch: IVerge, not_save_file: bool) -> Result<()> {
        Ok(()) => {
            Config::verge().apply();
            if !not_save_file {
-                Config::verge().data().save_file()?;
+                Config::verge().data_mut().save_file()?;
            }

            Ok(())
@@ -2,13 +2,23 @@ use crate::{
    cmd,
    config::{Config, PrfItem, PrfOption},
    core::{handle, CoreManager, *},
+    logging,
+    process::AsyncHandler,
+    utils::logging::Type,
 };
 use anyhow::{bail, Result};

 /// Toggle proxy profile
 pub fn toggle_proxy_profile(profile_index: String) {
-    tauri::async_runtime::spawn(async move {
-        let app_handle = handle::Handle::global().app_handle().unwrap();
+    AsyncHandler::spawn(|| async move {
+        let Some(app_handle) = handle::Handle::global().app_handle() else {
+            logging!(
+                error,
+                Type::Config,
+                "Failed to get app handle for profile toggle"
+            );
+            return;
+        };
        match cmd::patch_profiles_config_by_profile_index(app_handle, profile_index).await {
            Ok(_) => {
                let _ = tray::Tray::global().update_menu();
@@ -22,59 +32,135 @@ pub fn toggle_proxy_profile(profile_index: String) {

 /// Update a profile
 /// If updating current profile, activate it
-pub async fn update_profile(uid: String, option: Option<PrfOption>) -> Result<()> {
-    println!("[订阅更新] 开始更新订阅 {}", uid);
+/// auto_refresh: 是否自动更新配置和刷新前端
+pub async fn update_profile(
+    uid: String,
+    option: Option<PrfOption>,
+    auto_refresh: Option<bool>,
+) -> Result<()> {
+    logging!(info, Type::Config, true, "[订阅更新] 开始更新订阅 {}", uid);
+    let auto_refresh = auto_refresh.unwrap_or(true); // 默认为true，保持兼容性

    let url_opt = {
        let profiles = Config::profiles();
-        let profiles = profiles.latest();
+        let profiles = profiles.latest_ref();
        let item = profiles.get_item(&uid)?;
        let is_remote = item.itype.as_ref().is_some_and(|s| s == "remote");

        if !is_remote {
-            println!("[订阅更新] {} 不是远程订阅，跳过更新", uid);
+            log::info!(target: "app", "[订阅更新] {uid} 不是远程订阅，跳过更新");
            None // 非远程订阅直接更新
        } else if item.url.is_none() {
-            println!("[订阅更新] {} 缺少URL，无法更新", uid);
+            log::warn!(target: "app", "[订阅更新] {uid} 缺少URL，无法更新");
            bail!("failed to get the profile item url");
        } else {
-            println!(
+            log::info!(target: "app",
                "[订阅更新] {} 是远程订阅，URL: {}",
                uid,
-                item.url.clone().unwrap()
+                item.url.clone().ok_or_else(|| anyhow::anyhow!("Profile URL is None"))?
            );
-            Some((item.url.clone().unwrap(), item.option.clone()))
+            Some((
+                item.url
+                    .clone()
+                    .ok_or_else(|| anyhow::anyhow!("Profile URL is None"))?,
+                item.option.clone(),
+            ))
        }
    };

    let should_update = match url_opt {
        Some((url, opt)) => {
-            println!("[订阅更新] 开始下载新的订阅内容");
-            let merged_opt = PrfOption::merge(opt, option);
-            let item = PrfItem::from_url(&url, None, None, merged_opt).await?;
+            log::info!(target: "app", "[订阅更新] 开始下载新的订阅内容");
+            let merged_opt = PrfOption::merge(opt.clone(), option.clone());

-            println!("[订阅更新] 更新订阅配置");
-            let profiles = Config::profiles();
-            let mut profiles = profiles.latest();
-            profiles.update_item(uid.clone(), item)?;
+            // 尝试使用正常设置更新
+            match PrfItem::from_url(&url, None, None, merged_opt.clone()).await {
+                Ok(item) => {
+                    log::info!(target: "app", "[订阅更新] 更新订阅配置成功");
+                    let profiles = Config::profiles();
+                    let mut profiles = profiles.draft_mut();
+                    profiles.update_item(uid.clone(), item)?;

-            let is_current = Some(uid.clone()) == profiles.get_current();
-            println!("[订阅更新] 是否为当前使用的订阅: {}", is_current);
-            is_current
+                    let is_current = Some(uid.clone()) == profiles.get_current();
+                    log::info!(target: "app", "[订阅更新] 是否为当前使用的订阅: {is_current}");
+                    is_current && auto_refresh
+                }
+                Err(err) => {
+                    // 首次更新失败，尝试使用Clash代理
+                    log::warn!(target: "app", "[订阅更新] 正常更新失败: {err}，尝试使用Clash代理更新");
+
+                    // 发送通知
+                    handle::Handle::notice_message("update_retry_with_clash", uid.clone());
+
+                    // 保存原始代理设置
+                    let original_with_proxy = merged_opt.as_ref().and_then(|o| o.with_proxy);
+                    let original_self_proxy = merged_opt.as_ref().and_then(|o| o.self_proxy);
+
+                    // 创建使用Clash代理的选项
+                    let mut fallback_opt = merged_opt.unwrap_or_default();
+                    fallback_opt.with_proxy = Some(false);
+                    fallback_opt.self_proxy = Some(true);
+
+                    // 使用Clash代理重试
+                    match PrfItem::from_url(&url, None, None, Some(fallback_opt)).await {
+                        Ok(mut item) => {
+                            log::info!(target: "app", "[订阅更新] 使用Clash代理更新成功");
+
+                            // 恢复原始代理设置到item
+                            if let Some(option) = item.option.as_mut() {
+                                option.with_proxy = original_with_proxy;
+                                option.self_proxy = original_self_proxy;
+                            }
+
+                            // 更新到配置
+                            let profiles = Config::profiles();
+                            let mut profiles = profiles.draft_mut();
+                            profiles.update_item(uid.clone(), item.clone())?;
+
+                            // 获取配置名称用于通知
+                            let profile_name = item.name.clone().unwrap_or_else(|| uid.clone());
+
+                            // 发送通知告知用户自动更新使用了回退机制
+                            handle::Handle::notice_message("update_with_clash_proxy", profile_name);
+
+                            let is_current = Some(uid.clone()) == profiles.get_current();
+                            log::info!(target: "app", "[订阅更新] 是否为当前使用的订阅: {is_current}");
+                            is_current && auto_refresh
+                        }
+                        Err(retry_err) => {
+                            log::error!(target: "app", "[订阅更新] 使用Clash代理更新仍然失败: {retry_err}");
+                            handle::Handle::notice_message(
+                                "update_failed_even_with_clash",
+                                format!("{retry_err}"),
+                            );
+                            return Err(retry_err);
+                        }
+                    }
+                }
+            }
        }
-        None => true,
+        None => auto_refresh,
    };

    if should_update {
-        println!("[订阅更新] 更新内核配置");
+        logging!(info, Type::Config, true, "[订阅更新] 更新内核配置");
        match CoreManager::global().update_config().await {
            Ok(_) => {
-                println!("[订阅更新] 更新成功");
+                logging!(info, Type::Config, true, "[订阅更新] 更新成功");
                handle::Handle::refresh_clash();
+                if let Err(err) = cmd::proxy::force_refresh_proxies().await {
+                    logging!(
+                        error,
+                        Type::Config,
+                        true,
+                        "[订阅更新] 代理组刷新失败: {}",
+                        err
+                    );
+                }
            }
            Err(err) => {
-                println!("[订阅更新] 更新失败: {}", err);
-                handle::Handle::notice_message("set_config::error", format!("{err}"));
+                logging!(error, Type::Config, true, "[订阅更新] 更新失败: {}", err);
+                handle::Handle::notice_message("update_failed", format!("{err}"));
                log::error!(target: "app", "{err}");
            }
        }
@@ -1,16 +1,31 @@
 use crate::{
    config::{Config, IVerge},
    core::handle,
+    ipc::IpcManager,
+    logging,
+    process::AsyncHandler,
+    utils::logging::Type,
 };
 use std::env;
 use tauri_plugin_clipboard_manager::ClipboardExt;

 /// Toggle system proxy on/off
 pub fn toggle_system_proxy() {
-    let enable = Config::verge().draft().enable_system_proxy;
+    let enable = Config::verge().draft_mut().enable_system_proxy;
    let enable = enable.unwrap_or(false);
+    let auto_close_connection = Config::verge()
+        .data_mut()
+        .auto_close_connection
+        .unwrap_or(false);
+
+    AsyncHandler::spawn(move || async move {
+        // 如果当前系统代理即将关闭，且自动关闭连接设置为true，则关闭所有连接
+        if enable && auto_close_connection {
+            if let Err(err) = IpcManager::global().close_all_connections().await {
+                log::error!(target: "app", "Failed to close all connections: {err}");
+            }
+        }

-    tauri::async_runtime::spawn(async move {
        match super::patch_verge(
            IVerge {
                enable_system_proxy: Some(!enable),
@@ -28,23 +43,10 @@ pub fn toggle_system_proxy() {

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

-    tauri::async_runtime::spawn(async move {
+    AsyncHandler::spawn(async move || {
        match super::patch_verge(
            IVerge {
                enable_tun_mode: Some(!enable),
@@ -62,17 +64,34 @@ pub fn toggle_tun_mode(not_save_file: Option<bool>) {

 /// Copy proxy environment variables to clipboard
 pub fn copy_clash_env() {
-    // 从环境变量获取IP地址，默认127.0.0.1
-    let clash_verge_rev_ip =
-        env::var("CLASH_VERGE_REV_IP").unwrap_or_else(|_| "127.0.0.1".to_string());
+    // 从环境变量获取IP地址，如果没有则从配置中获取 proxy_host，默认为 127.0.0.1
+    let clash_verge_rev_ip = env::var("CLASH_VERGE_REV_IP").unwrap_or_else(|_| {
+        Config::verge()
+            .latest_ref()
+            .proxy_host
+            .clone()
+            .unwrap_or_else(|| "127.0.0.1".to_string())
+    });

-    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 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()
+            .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 cliboard = app_handle.clipboard();
-    let env_type = { Config::verge().latest().env_type.clone() };
+    let env_type = { Config::verge().latest_ref().env_type.clone() };
    let env_type = match env_type {
        Some(env_type) => env_type,
        None => {
@@ -3,117 +3,261 @@ use crate::AppHandleManager;
 use crate::{
    config::Config,
    core::{handle, sysopt, CoreManager},
-    module::mihomo::MihomoManager,
-    utils::resolve,
+    ipc::IpcManager,
+    logging,
+    utils::logging::Type,
 };

 /// Open or close the dashboard window
 #[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);
-    }
+    open_or_close_dashboard_internal(false)
 }

-/// 优化的应用退出函数
-pub fn quit(code: Option<i32>) {
-    log::debug!(target: "app", "启动退出流程");
+/// Open or close the dashboard window (hotkey call, dispatched to main thread)
+#[allow(dead_code)]
+pub fn open_or_close_dashboard_hotkey() {
+    open_or_close_dashboard_internal(true)
+}
+
+/// Internal implementation for opening/closing dashboard
+fn open_or_close_dashboard_internal(bypass_debounce: bool) {
+    use crate::process::AsyncHandler;
+    use crate::utils::window_manager::WindowManager;
+
+    log::info!(target: "app", "Attempting to open/close dashboard (绕过防抖: {bypass_debounce})");
+
+    // 热键调用调度到主线程执行，避免 WebView 创建死锁
+    if bypass_debounce {
+        log::info!(target: "app", "热键调用，调度到主线程执行窗口操作");
+
+        AsyncHandler::spawn(move || async move {
+            log::info!(target: "app", "主线程中执行热键窗口操作");
+
+            if crate::module::lightweight::is_in_lightweight_mode() {
+                log::info!(target: "app", "Currently in lightweight mode, exiting lightweight mode");
+                crate::module::lightweight::exit_lightweight_mode();
+                log::info!(target: "app", "Creating new window after exiting lightweight mode");
+                let result = WindowManager::show_main_window();
+                log::info!(target: "app", "Window operation result: {result:?}");
+                return;
+            }
+
+            let result = WindowManager::toggle_main_window();
+            log::info!(target: "app", "Window toggle result: {result:?}");
+        });
+        return;
+    }
+    if crate::module::lightweight::is_in_lightweight_mode() {
+        log::info!(target: "app", "Currently in lightweight mode, exiting lightweight mode");
+        crate::module::lightweight::exit_lightweight_mode();
+        log::info!(target: "app", "Creating new window after exiting lightweight mode");
+        let result = WindowManager::show_main_window();
+        log::info!(target: "app", "Window operation result: {result:?}");
+        return;
+    }
+
+    let result = WindowManager::toggle_main_window();
+    log::info!(target: "app", "Window toggle result: {result:?}");
+}
+
+/// 异步优化的应用退出函数
+pub fn quit() {
+    use crate::process::AsyncHandler;
+    logging!(debug, Type::System, true, "启动退出流程");

    // 获取应用句柄并设置退出标志
-    let app_handle = handle::Handle::global().app_handle().unwrap();
+    let Some(app_handle) = handle::Handle::global().app_handle() else {
+        logging!(
+            error,
+            Type::System,
+            "Failed to get app handle for quit operation"
+        );
+        return;
+    };
    handle::Handle::global().set_is_exiting();

    // 优先关闭窗口，提供立即反馈
    if let Some(window) = handle::Handle::global().get_window() {
        let _ = window.hide();
+        log::info!(target: "app", "窗口已隐藏");
    }

-    // 在单独线程中处理资源清理，避免阻塞主线程
-    std::thread::spawn(move || {
-        // 使用tokio运行时执行异步清理任务
-        tauri::async_runtime::block_on(async {
-            // 使用超时机制处理清理操作
-            use tokio::time::{timeout, Duration};
+    // 使用异步任务处理资源清理，避免阻塞
+    AsyncHandler::spawn(move || async move {
+        logging!(info, Type::System, true, "开始异步清理资源");
+        let cleanup_result = clean_async().await;

-            // 1. 直接关闭TUN模式 (优先处理，通常最容易卡住)
-            if Config::verge().data().enable_tun_mode.unwrap_or(false) {
-                let disable = serde_json::json!({
-                    "tun": {
-                        "enable": false
-                    }
-                });
-
-                // 设置1秒超时
-                let _ = timeout(
-                    Duration::from_secs(1),
-                    MihomoManager::global().patch_configs(disable),
-                )
-                .await;
-            }
-
-            // 2. 并行处理系统代理和核心进程清理
-            let proxy_future = timeout(
-                Duration::from_secs(1),
-                sysopt::Sysopt::global().reset_sysproxy(),
-            );
-
-            let core_future = timeout(Duration::from_secs(1), CoreManager::global().stop_core());
-
-            // 同时等待两个任务完成
-            let _ = futures::join!(proxy_future, core_future);
-
-            // 3. 处理macOS特定清理
-            #[cfg(target_os = "macos")]
-            {
-                let _ = timeout(Duration::from_millis(500), resolve::restore_public_dns()).await;
-            }
-        });
-
-        // 无论清理结果如何，确保应用退出
-        app_handle.exit(code.unwrap_or(0));
+        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::{timeout, Duration};
+
+    logging!(info, Type::System, true, "开始执行异步清理操作...");
+
+    // 1. 处理TUN模式
+    let tun_success = if Config::verge().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::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
+}
+
+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,
+                "清理操作超时，返回成功状态避免阻塞"
+            );
+            true
+        }
+    }
+}
+
 #[cfg(target_os = "macos")]
 pub fn hide() {
+    use crate::module::lightweight::add_light_weight_timer;
+
+    let enable_auto_light_weight_mode = Config::verge()
+        .data_mut()
+        .enable_auto_light_weight_mode
+        .unwrap_or(false);
+
+    if enable_auto_light_weight_mode {
+        add_light_weight_timer();
+    }
+
    if let Some(window) = handle::Handle::global().get_window() {
        if window.is_visible().unwrap_or(false) {
-            AppHandleManager::global().set_activation_policy_accessory();
            let _ = window.hide();
        }
    }
+    AppHandleManager::global().set_activation_policy_accessory();
 }
@@ -0,0 +1,386 @@
+use std::time::Duration;
+
+use kode_bridge::{
+    errors::{AnyError, AnyResult},
+    pool::PoolConfig,
+    ClientConfig, IpcHttpClient, LegacyResponse,
+};
+use percent_encoding::{utf8_percent_encode, AsciiSet, CONTROLS};
+
+// 定义用于URL路径的编码集合，只编码真正必要的字符
+const URL_PATH_ENCODE_SET: &AsciiSet = &CONTROLS
+    .add(b' ') // 空格
+    .add(b'/') // 斜杠
+    .add(b'?') // 问号
+    .add(b'#') // 井号
+    .add(b'&') // 和号
+    .add(b'%'); // 百分号
+
+use crate::{logging, singleton_with_logging, utils::dirs::ipc_path};
+
+// 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 {
+    ipc_path: String,
+    config: ClientConfig,
+}
+
+impl IpcManager {
+    fn new() -> Self {
+        let ipc_path_buf = ipc_path().unwrap_or_else(|e| {
+            logging!(
+                error,
+                crate::utils::logging::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();
+        Self {
+            ipc_path: ipc_path.to_string(),
+            config: ClientConfig {
+                default_timeout: Duration::from_secs(5),
+                enable_pooling: true,
+                max_retries: 3,
+                max_concurrent_requests: 32,
+                max_requests_per_second: Some(5.0),
+                pool_config: PoolConfig {
+                    max_size: 32,
+                    min_idle: 2,
+                    max_idle_time_ms: 10_000,
+                    max_retries: 3,
+                    max_concurrent_requests: 32,
+                    max_requests_per_second: Some(5.0),
+                    ..Default::default()
+                },
+                ..Default::default()
+            },
+        }
+    }
+}
+
+// Use singleton macro with logging
+singleton_with_logging!(IpcManager, INSTANCE, "IpcManager");
+
+impl IpcManager {
+    pub async fn request(
+        &self,
+        method: &str,
+        path: &str,
+        body: Option<&serde_json::Value>,
+    ) -> AnyResult<LegacyResponse> {
+        let client = IpcHttpClient::with_config(&self.ipc_path, self.config.clone())?;
+        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}");
+
+        let response = self.send_request("GET", &url, None).await;
+        response
+    }
+
+    // 版本和配置相关
+    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}");
+
+        let response = self.send_request("GET", &url, None).await;
+        response
+    }
+
+    // 调试相关
+    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 模块，使用流式处理
+}
@@ -0,0 +1,330 @@
+use serde::{Deserialize, Serialize};
+use std::{collections::VecDeque, sync::Arc, time::Instant};
+use tauri::async_runtime::JoinHandle;
+use tokio::{sync::RwLock, time::Duration};
+
+use crate::{
+    ipc::monitor::MonitorData,
+    logging,
+    process::AsyncHandler,
+    singleton_with_logging,
+    utils::{dirs::ipc_path, logging::Type},
+};
+
+const MAX_LOGS: usize = 1000; // Maximum number of logs to keep in memory
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct LogData {
+    #[serde(rename = "type")]
+    pub log_type: String,
+    pub payload: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct LogItem {
+    pub log_type: String,
+    pub payload: String,
+    pub time: String,
+}
+
+impl LogItem {
+    fn new(log_type: String, payload: String) -> Self {
+        use std::time::{SystemTime, UNIX_EPOCH};
+
+        let now = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap_or_else(|_| std::time::Duration::from_secs(0))
+            .as_secs();
+
+        // Simple time formatting (HH:MM:SS)
+        let hours = (now / 3600) % 24;
+        let minutes = (now / 60) % 60;
+        let seconds = now % 60;
+        let time_str = format!("{hours:02}:{minutes:02}:{seconds:02}");
+
+        Self {
+            log_type,
+            payload,
+            time: time_str,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct CurrentLogs {
+    pub logs: VecDeque<LogItem>,
+    // pub level: String,
+    pub last_updated: Instant,
+}
+
+impl Default for CurrentLogs {
+    fn default() -> Self {
+        Self {
+            logs: VecDeque::with_capacity(MAX_LOGS),
+            // level: "info".to_string(),
+            last_updated: Instant::now(),
+        }
+    }
+}
+
+impl MonitorData for CurrentLogs {
+    fn mark_fresh(&mut self) {
+        self.last_updated = Instant::now();
+    }
+
+    fn is_fresh_within(&self, duration: Duration) -> bool {
+        self.last_updated.elapsed() < duration
+    }
+}
+
+// Logs monitor with streaming support
+pub struct LogsMonitor {
+    current: Arc<RwLock<CurrentLogs>>,
+    task_handle: Arc<RwLock<Option<JoinHandle<()>>>>,
+    current_monitoring_level: Arc<RwLock<Option<String>>>,
+}
+
+// Use singleton_with_logging macro
+singleton_with_logging!(LogsMonitor, INSTANCE, "LogsMonitor");
+
+impl LogsMonitor {
+    fn new() -> Self {
+        let current = Arc::new(RwLock::new(CurrentLogs::default()));
+
+        Self {
+            current,
+            task_handle: Arc::new(RwLock::new(None)),
+            current_monitoring_level: Arc::new(RwLock::new(None)),
+        }
+    }
+
+    pub async fn start_monitoring(&self, level: Option<String>) {
+        let filter_level = level.clone().unwrap_or_else(|| "info".to_string());
+
+        // Check if we're already monitoring the same level
+        // let level_changed = {
+        //     let current_level = self.current_monitoring_level.read().await;
+        //     if let Some(existing_level) = current_level.as_ref() {
+        //         if existing_level == &filter_level {
+        //             logging!(
+        //                 info,
+        //                 Type::Ipc,
+        //                 true,
+        //                 "LogsMonitor: Already monitoring level '{}', skipping duplicate request",
+        //                 filter_level
+        //             );
+        //             return;
+        //         }
+        //         true // Level changed
+        //     } else {
+        //         true // First time or was stopped
+        //     }
+        // };
+
+        // Stop existing monitoring task if level changed or first time
+        {
+            let mut handle = self.task_handle.write().await;
+            if let Some(task) = handle.take() {
+                task.abort();
+                logging!(
+                    info,
+                    Type::Ipc,
+                    true,
+                    "LogsMonitor: Stopped previous monitoring task (level changed)"
+                );
+            }
+        }
+
+        // We want to keep the logs cache even if the level changes,
+        // so we don't clear it here. The cache will be cleared only when the level changes
+        // and a new task is started. This allows us to keep logs from previous levels
+        // even if the level changes during monitoring.
+        // Clear logs cache when level changes to ensure fresh data
+        // if level_changed {
+        //     let mut current = self.current.write().await;
+        //     current.logs.clear();
+        //     current.level = filter_level.clone();
+        //     current.mark_fresh();
+        //     logging!(
+        //         info,
+        //         Type::Ipc,
+        //         true,
+        //         "LogsMonitor: Cleared logs cache due to level change to '{}'",
+        //         filter_level
+        //     );
+        // }
+
+        // Update current monitoring level
+        {
+            let mut current_level = self.current_monitoring_level.write().await;
+            *current_level = Some(filter_level.clone());
+        }
+
+        let monitor_current = Arc::clone(&self.current);
+
+        let task = AsyncHandler::spawn(move || async move {
+            loop {
+                // Get fresh IPC path and client for each connection attempt
+                let (_ipc_path_buf, client) = match Self::create_ipc_client() {
+                    Ok((path, client)) => (path, client),
+                    Err(e) => {
+                        logging!(error, Type::Ipc, true, "Failed to create IPC client: {}", e);
+                        tokio::time::sleep(Duration::from_secs(2)).await;
+                        continue;
+                    }
+                };
+
+                let url = if filter_level == "all" {
+                    "/logs".to_string()
+                } else {
+                    format!("/logs?level={filter_level}")
+                };
+
+                logging!(
+                    info,
+                    Type::Ipc,
+                    true,
+                    "LogsMonitor: Starting stream for {}",
+                    url
+                );
+
+                let _ = client
+                    .get(&url)
+                    .timeout(Duration::from_secs(30))
+                    .process_lines(|line| {
+                        Self::process_log_line(line, Arc::clone(&monitor_current))
+                    })
+                    .await;
+
+                // Wait before retrying
+                tokio::time::sleep(Duration::from_secs(2)).await;
+            }
+        });
+
+        // Store the task handle
+        {
+            let mut handle = self.task_handle.write().await;
+            *handle = Some(task);
+        }
+
+        logging!(
+            info,
+            Type::Ipc,
+            true,
+            "LogsMonitor: Started new monitoring task for level: {:?}",
+            level
+        );
+    }
+
+    pub async fn stop_monitoring(&self) {
+        // Stop monitoring task but keep logs
+        {
+            let mut handle = self.task_handle.write().await;
+            if let Some(task) = handle.take() {
+                task.abort();
+                logging!(
+                    info,
+                    Type::Ipc,
+                    true,
+                    "LogsMonitor: Stopped monitoring task"
+                );
+            }
+        }
+
+        // Reset monitoring level
+        {
+            let mut monitoring_level = self.current_monitoring_level.write().await;
+            *monitoring_level = None;
+        }
+    }
+
+    fn create_ipc_client() -> Result<
+        (std::path::PathBuf, kode_bridge::IpcStreamClient),
+        Box<dyn std::error::Error + Send + Sync>,
+    > {
+        use kode_bridge::IpcStreamClient;
+
+        let ipc_path_buf = ipc_path()?;
+        let ipc_path = ipc_path_buf.to_str().ok_or("Invalid IPC path")?;
+        let client = IpcStreamClient::new(ipc_path)?;
+        Ok((ipc_path_buf, client))
+    }
+
+    fn process_log_line(
+        line: &str,
+        current: Arc<RwLock<CurrentLogs>>,
+    ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+        if let Ok(log_data) = serde_json::from_str::<LogData>(line.trim()) {
+            // Server-side filtering via query parameters handles the level filtering
+            // We only need to accept all logs since filtering is done at the endpoint level
+            let log_item = LogItem::new(log_data.log_type, log_data.payload);
+
+            AsyncHandler::spawn(move || async move {
+                let mut logs = current.write().await;
+
+                // Add new log
+                logs.logs.push_back(log_item);
+
+                // Keep only the last 1000 logs
+                if logs.logs.len() > 1000 {
+                    logs.logs.pop_front();
+                }
+
+                logs.mark_fresh();
+            });
+        }
+        Ok(())
+    }
+
+    pub async fn current(&self) -> CurrentLogs {
+        self.current.read().await.clone()
+    }
+
+    pub async fn clear_logs(&self) {
+        let mut current = self.current.write().await;
+        current.logs.clear();
+        current.mark_fresh();
+        logging!(
+            info,
+            Type::Ipc,
+            true,
+            "LogsMonitor: Cleared frontend logs (monitoring continues)"
+        );
+    }
+
+    pub async fn get_logs_as_json(&self) -> serde_json::Value {
+        let current = self.current().await;
+
+        // Simply return all cached logs since filtering is handled by start_monitoring
+        // and the cache is cleared when level changes
+        let logs: Vec<serde_json::Value> = current
+            .logs
+            .iter()
+            .map(|log| {
+                serde_json::json!({
+                    "type": log.log_type,
+                    "payload": log.payload,
+                    "time": log.time
+                })
+            })
+            .collect();
+
+        serde_json::Value::Array(logs)
+    }
+}
+
+pub async fn start_logs_monitoring(level: Option<String>) {
+    LogsMonitor::global().start_monitoring(level).await;
+}
+
+pub async fn stop_logs_monitoring() {
+    LogsMonitor::global().stop_monitoring().await;
+}
+
+pub async fn clear_logs() {
+    LogsMonitor::global().clear_logs().await;
+}
+
+pub async fn get_logs_json() -> serde_json::Value {
+    LogsMonitor::global().get_logs_as_json().await
+}
@@ -0,0 +1,119 @@
+use serde::{Deserialize, Serialize};
+use std::{sync::Arc, time::Instant};
+use tokio::{sync::RwLock, time::Duration};
+
+use crate::{
+    ipc::monitor::{IpcStreamMonitor, MonitorData, StreamingParser},
+    process::AsyncHandler,
+    singleton_lazy_with_logging,
+    utils::format::fmt_bytes,
+};
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct MemoryData {
+    pub inuse: u64,
+    pub oslimit: u64,
+}
+
+#[derive(Debug, Clone)]
+pub struct CurrentMemory {
+    pub inuse: u64,
+    pub oslimit: u64,
+    pub last_updated: Instant,
+}
+
+impl Default for CurrentMemory {
+    fn default() -> Self {
+        Self {
+            inuse: 0,
+            oslimit: 0,
+            last_updated: Instant::now(),
+        }
+    }
+}
+
+impl MonitorData for CurrentMemory {
+    fn mark_fresh(&mut self) {
+        self.last_updated = Instant::now();
+    }
+
+    fn is_fresh_within(&self, duration: Duration) -> bool {
+        self.last_updated.elapsed() < duration
+    }
+}
+
+impl StreamingParser for CurrentMemory {
+    fn parse_and_update(
+        line: &str,
+        current: Arc<RwLock<Self>>,
+    ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+        if let Ok(memory) = serde_json::from_str::<MemoryData>(line.trim()) {
+            AsyncHandler::spawn(move || async move {
+                let mut current_guard = current.write().await;
+                current_guard.inuse = memory.inuse;
+                current_guard.oslimit = memory.oslimit;
+                current_guard.mark_fresh();
+            });
+        }
+        Ok(())
+    }
+}
+
+// Minimal memory monitor using the new architecture
+pub struct MemoryMonitor {
+    monitor: IpcStreamMonitor<CurrentMemory>,
+}
+
+impl Default for MemoryMonitor {
+    fn default() -> Self {
+        MemoryMonitor {
+            monitor: IpcStreamMonitor::new(
+                "/memory".to_string(),
+                Duration::from_secs(10),
+                Duration::from_secs(2),
+                Duration::from_secs(10),
+            ),
+        }
+    }
+}
+
+// Use simplified singleton_lazy_with_logging macro
+singleton_lazy_with_logging!(
+    MemoryMonitor,
+    INSTANCE,
+    "MemoryMonitor",
+    MemoryMonitor::default
+);
+
+impl MemoryMonitor {
+    pub async fn current(&self) -> CurrentMemory {
+        self.monitor.current().await
+    }
+
+    pub async fn is_fresh(&self) -> bool {
+        self.monitor.is_fresh().await
+    }
+}
+
+pub async fn get_current_memory() -> CurrentMemory {
+    MemoryMonitor::global().current().await
+}
+
+pub async fn get_formatted_memory() -> (String, String, f64, bool) {
+    let monitor = MemoryMonitor::global();
+    let memory = monitor.current().await;
+    let is_fresh = monitor.is_fresh().await;
+
+    let usage_percent = if memory.oslimit > 0 {
+        (memory.inuse as f64 / memory.oslimit as f64) * 100.0
+    } else {
+        0.0
+    };
+
+    (
+        fmt_bytes(memory.inuse),
+        fmt_bytes(memory.oslimit),
+        usage_percent,
+        is_fresh,
+    )
+}
@@ -0,0 +1,15 @@
+pub mod general;
+pub mod logs;
+pub mod memory;
+pub mod monitor;
+pub mod traffic;
+
+pub use general::IpcManager;
+pub use logs::{clear_logs, get_logs_json, start_logs_monitoring, stop_logs_monitoring};
+pub use memory::{get_current_memory, get_formatted_memory};
+pub use traffic::{get_current_traffic, get_formatted_traffic};
+
+pub struct Rate {
+    // pub up: usize,
+    // pub down: usize,
+}
@@ -0,0 +1,120 @@
+use kode_bridge::IpcStreamClient;
+use std::sync::Arc;
+use tokio::{sync::RwLock, time::Duration};
+
+use crate::{
+    logging,
+    process::AsyncHandler,
+    utils::{dirs::ipc_path, logging::Type},
+};
+
+/// Generic base structure for IPC monitoring data with freshness tracking
+pub trait MonitorData: Clone + Send + Sync + 'static {
+    /// Update the last_updated timestamp to now
+    fn mark_fresh(&mut self);
+
+    /// Check if data is fresh based on the given duration
+    fn is_fresh_within(&self, duration: Duration) -> bool;
+}
+
+/// Trait for parsing streaming data and updating monitor state
+pub trait StreamingParser: MonitorData {
+    /// Parse a line of streaming data and update the current state
+    fn parse_and_update(
+        line: &str,
+        current: Arc<RwLock<Self>>,
+    ) -> Result<(), Box<dyn std::error::Error + Send + Sync>>;
+}
+
+/// Generic IPC stream monitor that handles the common streaming pattern
+pub struct IpcStreamMonitor<T>
+where
+    T: MonitorData + StreamingParser + Default,
+{
+    current: Arc<RwLock<T>>,
+    #[allow(dead_code)]
+    endpoint: String,
+    #[allow(dead_code)]
+    timeout: Duration,
+    #[allow(dead_code)]
+    retry_interval: Duration,
+    freshness_duration: Duration,
+}
+
+impl<T> IpcStreamMonitor<T>
+where
+    T: MonitorData + StreamingParser + Default,
+{
+    pub fn new(
+        endpoint: String,
+        timeout: Duration,
+        retry_interval: Duration,
+        freshness_duration: Duration,
+    ) -> Self {
+        let current = Arc::new(RwLock::new(T::default()));
+        let monitor_current = Arc::clone(&current);
+        let endpoint_clone = endpoint.clone();
+
+        // Start the monitoring task
+        AsyncHandler::spawn(move || async move {
+            Self::streaming_task(monitor_current, endpoint_clone, timeout, retry_interval).await;
+        });
+
+        Self {
+            current,
+            endpoint,
+            timeout,
+            retry_interval,
+            freshness_duration,
+        }
+    }
+
+    pub async fn current(&self) -> T {
+        self.current.read().await.clone()
+    }
+
+    pub async fn is_fresh(&self) -> bool {
+        self.current
+            .read()
+            .await
+            .is_fresh_within(self.freshness_duration)
+    }
+
+    /// The core streaming task that can be specialized per monitor type
+    async fn streaming_task(
+        current: Arc<RwLock<T>>,
+        endpoint: String,
+        timeout: Duration,
+        retry_interval: Duration,
+    ) {
+        loop {
+            let ipc_path_buf = match ipc_path() {
+                Ok(path) => path,
+                Err(e) => {
+                    logging!(error, Type::Ipc, true, "Failed to get IPC path: {}", e);
+                    tokio::time::sleep(retry_interval).await;
+                    continue;
+                }
+            };
+
+            let ipc_path = ipc_path_buf.to_str().unwrap_or_default();
+
+            let client = match IpcStreamClient::new(ipc_path) {
+                Ok(client) => client,
+                Err(e) => {
+                    logging!(error, Type::Ipc, true, "Failed to create IPC client: {}", e);
+                    tokio::time::sleep(retry_interval).await;
+                    continue;
+                }
+            };
+
+            let _ = client
+                .get(&endpoint)
+                .timeout(timeout)
+                .process_lines(|line| T::parse_and_update(line, Arc::clone(&current)))
+                .await;
+
+            tokio::time::sleep(retry_interval).await;
+        }
+    }
+}
--- a/Show More
+++ b/Show More