chore: update version to 2.2.1-alpha and add alpha update logs

refactor: simplify version change detection in alpha workflow

chore: alpha delete old release then release new one

fix: update alpha workflow to handle missing ALPHA_LOGS and improve release notes generation

fix: update job dependencies in alpha workflow to include delete_otld_release

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -12,16 +12,14 @@ body:
         1. 请 **确保** 您已经查阅了 [Clash Verge Rev 官方文档](https://clash-verge-rev.github.io/guide/term.html)  以及 [常见问题](https://clash-verge-rev.github.io/faq/windows.html)
         2. 请 **确保** [已有的问题](https://github.com/clash-verge-rev/clash-verge-rev/issues?q=is%3Aissue) 中没有人提交过相似issue，否则请在已有的issue下进行讨论
         3. 请 **务必** 给issue填写一个简洁明了的标题，以便他人快速检索
-        4. 请 **务必** 查看 [Alpha](https://github.com/clash-verge-rev/clash-verge-rev/releases/tag/alpha) 版本更新日志
-        5. 请 **务必** 尝试 [Alpha](https://github.com/clash-verge-rev/clash-verge-rev/releases/tag/alpha) 版本，确定问题是否仍然存在
-        6. 请 **务必** 按照模板规范详细描述问题以及尝试更新 Alpha 版本，否则issue将会被直接关闭
+        4. 请 **务必** 先下载 [Alpha](https://github.com/clash-verge-rev/clash-verge-rev/releases/tag/alpha) 版本测试，确保问题依然存在
+        5. 请 **务必** 按照模板规范详细描述问题，否则issue将会被关闭
         ## Before submitting the issue, please make sure of the following checklist:
         1. Please make sure you have read the [Clash Verge Rev official documentation](https://clash-verge-rev.github.io/guide/term.html) and [FAQ](https://clash-verge-rev.github.io/faq/windows.html)
         2. Please make sure there is no similar issue in the [existing issues](https://github.com/clash-verge-rev/clash-verge-rev/issues?q=is%3Aissue), otherwise please discuss under the existing issue
         3. Please be sure to fill in a concise and clear title for the issue so that others can quickly search
-        4. Please be sure to check out [Alpha](https://github.com/clash-verge-rev/clash-verge-rev/releases/tag/alpha) version update log
-        5. Please be sure to try the [Alpha](https://github.com/clash-verge-rev/clash-verge-rev/releases/tag/alpha) version to ensure that the problem still exists
-        6. Please describe the problem in detail according to the template specification and try to update the Alpha version, otherwise the issue will be closed
+        4. Please be sure to download the [Alpha](https://github.com/clash-verge-rev/clash-verge-rev/releases/tag/alpha) version for testing to ensure that the problem still exists
+        5. Please describe the problem in detail according to the template specification, otherwise the issue will be closed
 
   - type: textarea
     id: description
@@ -59,7 +57,7 @@ body:
       required: true
   - type: textarea
     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")
+      label: 日志 / Log
+      description: 请提供完整或相关部分的Debug日志（请在“软件左侧菜单”->“设置”->“日志等级”调整到debug，Verge错误请把“杂项设置”->“app日志等级”调整到debug/trace，并重启Verge生效。日志文件在“软件左侧菜单”->“设置”->“日志目录”下） / Please provide a complete or relevant part of the Debug log (please adjust the "Log level" to debug in "Software left menu" -> "Settings" -> "Log level". If there is a Verge error, please adjust "Miscellaneous settings" -> "app log level" to trace, and restart Verge to take effect. The log file is under "Software left menu" -> "Settings" -> "Log directory")
     validations:
       required: true

.github/ISSUE_TEMPLATE/i18n_request.yml

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

.github/workflows/alpha.yml

@@ -1,262 +1,77 @@
 name: Alpha Build
 
 on:
-  # 因为 alpha 不再负责频繁构建，且需要相对于 autobuild 更稳定使用环境
-  # 所以不再使用 workflow_dispatch 触发
-  # 应当通过 git tag 来触发构建
-  # TODO 手动控制版本号
   workflow_dispatch:
-    # inputs:
-    #   tag_name:
-    #     description: "Alpha tag name (e.g. v1.2.3-alpha.1)"
-    #     required: true
-    #     type: string
-
-  # push:
-  #   # 应当限制在 dev 分支上触发发布。
-  #   branches:
-  #     - dev
-  #   # 应当限制 v*.*.*-alpha* 的 tag 来触发发布。
-  #   tags:
-  #     - "v*.*.*-alpha*"
+  schedule:
+    # UTC+8 00:00 (UTC 16:00 previous day) and UTC+8 12:00 (UTC 04:00)
+    - cron: "0 16,4 * * *"
 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_alpha_tag:
-    name: Check Alpha Tag package.json Version Consistency
+  check_commit:
     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 tag and package.json version
-        id: check_tag
+      - name: Check if version changed
+        id: check
         run: |
-          TAG_REF="${GITHUB_REF##*/}"
-          echo "Current tag: $TAG_REF"
-          if [[ ! "$TAG_REF" =~ -alpha ]]; then
-            echo "Current tag is not an alpha tag."
-            exit 1
+          # For manual workflow_dispatch, always run
+          if [ "${{ github.event_name }}" == "workflow_dispatch" ]; then
+            echo "should_run=true" >> $GITHUB_OUTPUT
+            exit 0
           fi
-          PKG_VERSION=$(jq -r .version package.json)
-          echo "package.json version: $PKG_VERSION"
-          if [[ "$PKG_VERSION" != *alpha* ]]; then
-            echo "package.json version is not an alpha version."
-            exit 1
-          fi
-          if [[ "$TAG_REF" != "v$PKG_VERSION" ]]; then
-            echo "Tag ($TAG_REF) does not match package.json version (v$PKG_VERSION)."
-            exit 1
-          fi
-          echo "Alpha tag and package.json version are consistent."
 
-  delete_old_assets:
-    name: Delete Old Alpha Release Assets and Tags
-    needs: check_alpha_tag
+          # 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
+          else
+            echo "Version unchanged: $CURRENT_VERSION"
+            echo "should_run=false" >> $GITHUB_OUTPUT
+          fi
+          
+  delete_old_release:
+    needs: check_commit
+    if: ${{ needs.check_commit.outputs.should_run == 'true' }}
     runs-on: ubuntu-latest
     steps:
-      - name: Delete Old Alpha Tags Except Latest
-        uses: actions/github-script@v7
+      - name: Delete Old Alpha Release
+        uses: dev-drprasad/delete-tag-and-release@v1.1
         with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          script: |
-            const tagPattern = /-alpha.*/; // 匹配带有 -alpha 的 tag
-            const owner = context.repo.owner;
-            const repo = context.repo.repo;
+          tag_name: alpha
+          delete_release: true
+          repo: ${{ github.repository }}
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-            try {
-              // 获取所有 tag
-              const { data: tags } = await github.rest.repos.listTags({
-                owner,
-                repo,
-                per_page: 100 // 调整 per_page 以获取更多 tag
-              });
-
-              // 过滤出包含 -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);
-              });
-
-              console.log(`Found ${alphaTags.length} alpha tags`);
-
-              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
-                  });
-
-                  // 删除 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) {
-              console.error('Error:', error);
-              throw error;
-            }
-
-  update_tag:
-    name: Update tag
-    runs-on: ubuntu-latest
-    needs: delete_old_assets
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Fetch 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
-        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
-
-          ## 我应该下载哪个版本？
-
-          ### MacOS
-          - MacOS intel芯片: x64.dmg
-          - MacOS apple M芯片: aarch64.dmg
-
-          ### Linux
-          - Linux 64位: amd64.deb/amd64.rpm
-          - Linux arm64 architecture: arm64.deb/aarch64.rpm
-          - Linux armv7架构: armhf.deb/armhfp.rpm
-
-          ### Windows (不再支持Win7)
-          #### 正常版本(推荐)
-          - 64位: x64-setup.exe
-          - arm64架构: arm64-setup.exe
-          #### 便携版问题很多不再提供
-          #### 内置Webview2版(体积较大，仅在企业版系统或无法安装webview2时使用)
-          - 64位: x64_fixed_webview2-setup.exe
-          - arm64架构: arm64_fixed_webview2-setup.exe
-
-          ### FAQ
-          - [常见问题](https://clash-verge-rev.github.io/faq/windows.html)
-
-          ### 稳定机场VPN推荐
-          - [狗狗加速](https://verge.dginv.click/#/register?code=oaxsAGo6)
-
-          Created at ${{ env.BUILDTIME }}.
-          EOF
-
-      - name: Upload Release
-        uses: softprops/action-gh-release@v2
-        with:
-          tag_name: ${{ 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-x86-windows-macos-linux:
-    name: Alpha x86 Windows, MacOS and Linux
-    needs: update_tag
+  alpha:
+    needs: delete_old_release
     strategy:
       fail-fast: false
       matrix:
@@ -271,6 +86,7 @@ jobs:
             target: x86_64-apple-darwin
           - os: ubuntu-22.04
             target: x86_64-unknown-linux-gnu
+
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout Repository
@@ -286,13 +102,14 @@ jobs:
         uses: Swatinem/rust-cache@v2
         with:
           workspaces: src-tauri
-          save-if: false
+          cache-all-crates: true
+          cache-on-failure: true
 
       - name: Install dependencies (ubuntu only)
         if: matrix.os == 'ubuntu-22.04'
         run: |
           sudo apt-get update
-          sudo apt-get install -y libxslt1.1 libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librsvg2-dev patchelf
+          sudo apt-get install -y libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librsvg2-dev patchelf
 
       - name: Install Node
         uses: actions/setup-node@v4
@@ -307,10 +124,7 @@ jobs:
       - name: Pnpm install and check
         run: |
           pnpm i
-          pnpm run prebuild ${{ matrix.target }}
-
-      # - name: Release ${{ env.TAG_CHANNEL }} Version
-      #   run: pnpm release-version ${{ env.TAG_NAME }}
+          pnpm check ${{ matrix.target }}
 
       - name: Tauri build
         uses: tauri-apps/tauri-action@v0
@@ -326,17 +140,16 @@ jobs:
           APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
           APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
         with:
-          tagName: ${{ env.TAG_NAME }}
-          releaseName: "Clash Verge Rev ${{ env.TAG_CHANNEL }}"
+          tagName: alpha
+          releaseName: "Clash Verge Rev Alpha"
           releaseBody: "More new features are now supported."
           releaseDraft: false
           prerelease: true
           tauriScript: pnpm
           args: --target ${{ matrix.target }}
 
-  alpha-arm-linux:
-    name: Alpha ARM Linux
-    needs: update_tag
+  alpha-for-linux-arm:
+    needs: delete_old_release
     strategy:
       fail-fast: false
       matrix:
@@ -362,7 +175,7 @@ jobs:
         uses: Swatinem/rust-cache@v2
         with:
           workspaces: src-tauri
-          save-if: false
+          cache-all-crates: true
 
       - name: Install Node
         uses: actions/setup-node@v4
@@ -377,13 +190,10 @@ jobs:
       - name: Pnpm install and check
         run: |
           pnpm i
-          pnpm run prebuild ${{ matrix.target }}
+          pnpm check ${{ matrix.target }}
 
-      # - name: Release ${{ env.TAG_CHANNEL }} Version
-      #   run: pnpm release-version ${{ env.TAG_NAME }}
-
-      - name: Setup for linux
-        run: |
+      - name: "Setup for linux"
+        run: |-
           sudo ls -lR /etc/apt/
 
           cat > /tmp/sources.list << EOF
@@ -402,29 +212,23 @@ jobs:
           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 update
 
-          sudo apt-get install -y \
-            linux-libc-dev:${{ matrix.arch }} \
-            libc6-dev:${{ matrix.arch }}
-
-          sudo apt-get install -y \
-            libxslt1.1:${{ matrix.arch }} \
+          sudo apt install -y \
             libwebkit2gtk-4.1-dev:${{ matrix.arch }} \
             libayatana-appindicator3-dev:${{ matrix.arch }} \
             libssl-dev:${{ matrix.arch }} \
             patchelf:${{ matrix.arch }} \
             librsvg2-dev:${{ matrix.arch }}
 
-      - name: Install aarch64 tools
+      - 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 \
@@ -457,17 +261,17 @@ jobs:
       - name: Upload Release
         uses: softprops/action-gh-release@v2
         with:
-          tag_name: ${{ env.TAG_NAME }}
-          name: "Clash Verge Rev ${{ env.TAG_CHANNEL }}"
+          tag_name: alpha
+          name: "Clash Verge Rev Alpha"
+          body: "More new features are now supported."
           prerelease: true
           token: ${{ secrets.GITHUB_TOKEN }}
           files: |
             src-tauri/target/${{ matrix.target }}/release/bundle/deb/*.deb
             src-tauri/target/${{ matrix.target }}/release/bundle/rpm/*.rpm
 
-  alpha-x86-arm-windows_webview2:
-    name: Alpha x86 and ARM Windows with WebView2
-    needs: update_tag
+  alpha-for-fixed-webview2:
+    needs: delete_old_release
     strategy:
       fail-fast: false
       matrix:
@@ -490,7 +294,8 @@ jobs:
         uses: Swatinem/rust-cache@v2
         with:
           workspaces: src-tauri
-          save-if: false
+          cache-all-crates: true
+          cache-on-failure: true
 
       - name: Install Node
         uses: actions/setup-node@v4
@@ -505,10 +310,7 @@ jobs:
       - name: Pnpm install and check
         run: |
           pnpm i
-          pnpm run prebuild ${{ matrix.target }}
-
-      # - name: Release ${{ env.TAG_CHANNEL }} Version
-      #   run: pnpm release-version ${{ env.TAG_NAME }}
+          pnpm check ${{ matrix.target }}
 
       - name: Download WebView2 Runtime
         run: |
@@ -552,13 +354,101 @@ jobs:
       - name: Upload Release
         uses: softprops/action-gh-release@v2
         with:
-          tag_name: ${{ env.TAG_NAME }}
-          name: "Clash Verge Rev ${{ env.TAG_CHANNEL }}"
+          tag_name: alpha
+          name: "Clash Verge Rev Alpha"
+          body: "More new features are now supported."
           prerelease: true
           token: ${{ secrets.GITHUB_TOKEN }}
           files: src-tauri/target/${{ matrix.target }}/release/bundle/nsis/*setup*
 
       - name: Portable Bundle
-        run: pnpm portable-fixed-webview2 ${{ matrix.target }} --${{ env.TAG_NAME }}
+        run: pnpm portable-fixed-webview2 ${{ matrix.target }} --alpha
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  update_tag:
+    name: Update tag
+    runs-on: ubuntu-latest
+    needs: [delete_old_release, alpha, alpha-for-linux-arm, alpha-for-fixed-webview2]
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Fetch Alpha update logs
+        id: fetch_alpha_logs
+        run: |
+          # Check if UPDATELOG.md exists
+          if [ -f "UPDATELOG.md" ]; then
+            # Extract the section starting with ## and containing -alpha until the next ## or end of file
+            ALPHA_LOGS=$(awk '/^## .*-alpha/{flag=1; print; next} /^## /{flag=0} flag' UPDATELOG.md)
+            
+            if [ -n "$ALPHA_LOGS" ]; then
+              echo "Found alpha update logs"
+              echo "ALPHA_LOGS<<EOF" >> $GITHUB_ENV
+              echo "$ALPHA_LOGS" >> $GITHUB_ENV
+              echo "EOF" >> $GITHUB_ENV
+            else
+              echo "No alpha sections found in UPDATELOG.md"
+            fi
+          else
+            echo "UPDATELOG.md file not found"
+          fi
+        shell: bash
+
+      - name: Set Env
+        run: |
+          echo "BUILDTIME=$(TZ=Asia/Shanghai date)" >> $GITHUB_ENV
+        shell: bash
+
+      - run: |
+          # 检查 ALPHA_LOGS 是否存在，如果不存在则使用默认消息
+          if [ -z "$ALPHA_LOGS" ]; then
+            echo "No alpha logs found, using default message"
+            ALPHA_LOGS="More new features are now supported. Check for detailed changelog soon."
+          else
+            echo "Using found alpha logs"
+          fi
+      
+          # 生成 release.txt 文件
+          cat > release.txt << EOF
+          $ALPHA_LOGS
+      
+          ## 我应该下载哪个版本？
+      
+          ### MacOS
+          - MacOS intel芯片: x64.dmg
+          - MacOS apple M芯片: aarch64.dmg
+      
+          ### Linux
+          - Linux 64位: amd64.deb/amd64.rpm
+          - Linux arm64 architecture: arm64.deb/aarch64.rpm
+          - Linux armv7架构: armhf.deb/armhfp.rpm
+      
+          ### Windows (不再支持Win7)
+          #### 正常版本(推荐)
+          - 64位: x64-setup.exe
+          - arm64架构: arm64-setup.exe
+          #### 便携版问题很多不再提供
+          #### 内置Webview2版(体积较大，仅在企业版系统或无法安装webview2时使用)
+          - 64位: x64_fixed_webview2-setup.exe
+          - arm64架构: arm64_fixed_webview2-setup.exe
+      
+          ### FAQ
+
+          - [常见问题](https://clash-verge-rev.github.io/faq/windows.html)
+
+          ### 稳定机场VPN推荐
+          - [狗狗加速](https://verge.dginv.click/#/register?code=oaxsAGo6)
+      
+          Created at ${{ env.BUILDTIME }}.
+          EOF
+
+      - name: Upload Release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: alpha
+          name: "Clash Verge Rev Alpha"
+          body_path: release.txt
+          prerelease: true
+          token: ${{ secrets.GITHUB_TOKEN }}
+          generate_release_notes: true

.github/workflows/autobuild.yml

@@ -1,466 +0,0 @@
-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
-    runs-on: ubuntu-latest
-    outputs:
-      should_run: ${{ steps.check.outputs.should_run }}
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 2
-
-      - name: Check if version changed or src changed
-        id: check
-        run: |
-          if [ "${{ github.event_name }}" == "workflow_dispatch" ]; then
-            echo "should_run=true" >> $GITHUB_OUTPUT
-            exit 0
-          fi
-
-          CURRENT_VERSION=$(cat package.json | jq -r '.version')
-          echo "Current version: $CURRENT_VERSION"
-
-          git checkout HEAD~1 package.json
-          PREVIOUS_VERSION=$(cat package.json | jq -r '.version')
-          echo "Previous version: $PREVIOUS_VERSION"
-
-          git checkout HEAD package.json
-
-          if [ "$CURRENT_VERSION" != "$PREVIOUS_VERSION" ]; then
-            echo "Version changed from $PREVIOUS_VERSION to $CURRENT_VERSION"
-            echo "should_run=true" >> $GITHUB_OUTPUT
-            exit 0
-          fi
-
-          CURRENT_SRC_HASH=$(git rev-parse HEAD:src)
-          PREVIOUS_SRC_HASH=$(git rev-parse HEAD~1:src 2>/dev/null || echo "")
-          CURRENT_TAURI_HASH=$(git rev-parse HEAD:src-tauri 2>/dev/null || echo "")
-          PREVIOUS_TAURI_HASH=$(git rev-parse HEAD~1:src-tauri 2>/dev/null || echo "")
-
-          echo "Current src hash: $CURRENT_SRC_HASH"
-          echo "Previous src hash: $PREVIOUS_SRC_HASH"
-          echo "Current tauri hash: $CURRENT_TAURI_HASH"
-          echo "Previous tauri hash: $PREVIOUS_TAURI_HASH"
-
-          if [ "$CURRENT_SRC_HASH" != "$PREVIOUS_SRC_HASH" ] || [ "$CURRENT_TAURI_HASH" != "$PREVIOUS_TAURI_HASH" ]; then
-            echo "Source directories changed"
-            echo "should_run=true" >> $GITHUB_OUTPUT
-          else
-            echo "Version and source directories unchanged"
-            echo "should_run=false" >> $GITHUB_OUTPUT
-          fi
-
-  update_tag:
-    name: Update tag
-    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
-
-      - name: Set Env
-        run: |
-          echo "BUILDTIME=$(TZ=Asia/Shanghai date)" >> $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
-
-          ## 我应该下载哪个版本？
-
-          ### MacOS
-          - MacOS intel芯片: x64.dmg
-          - MacOS apple M芯片: aarch64.dmg
-
-          ### Linux
-          - Linux 64位: amd64.deb/amd64.rpm
-          - Linux arm64 architecture: arm64.deb/aarch64.rpm
-          - Linux armv7架构: armhf.deb/armhfp.rpm
-
-          ### Windows (不再支持Win7)
-          #### 正常版本(推荐)
-          - 64位: x64-setup.exe
-          - arm64架构: arm64-setup.exe
-          #### 便携版问题很多不再提供
-          #### 内置Webview2版(体积较大，仅在企业版系统或无法安装webview2时使用)
-          - 64位: x64_fixed_webview2-setup.exe
-          - arm64架构: arm64_fixed_webview2-setup.exe
-
-          ### FAQ
-          - [常见问题](https://clash-verge-rev.github.io/faq/windows.html)
-
-          ### 稳定机场VPN推荐
-          - [狗狗加速](https://verge.dginv.click/#/register?code=oaxsAGo6)
-
-          Created at ${{ env.BUILDTIME }}.
-          EOF
-
-      - name: Upload Release
-        uses: softprops/action-gh-release@v2
-        with:
-          tag_name: ${{ env.TAG_NAME }}
-          name: "Clash Verge Rev ${{ env.TAG_CHANNEL }}"
-          body_path: release.txt
-          prerelease: true
-          token: ${{ secrets.GITHUB_TOKEN }}
-          generate_release_notes: true
-
-  autobuild-x86-windows-macos-linux:
-    name: Autobuild x86 Windows, MacOS and Linux
-    needs: update_tag
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - os: windows-latest
-            target: x86_64-pc-windows-msvc
-          - os: windows-latest
-            target: aarch64-pc-windows-msvc
-          - os: macos-latest
-            target: aarch64-apple-darwin
-          - os: macos-latest
-            target: x86_64-apple-darwin
-          - os: ubuntu-22.04
-            target: x86_64-unknown-linux-gnu
-    runs-on: ${{ matrix.os }}
-    steps:
-      - name: Checkout Repository
-        uses: actions/checkout@v4
-
-      - name: Install Rust Stable
-        uses: dtolnay/rust-toolchain@stable
-
-      - name: Add Rust Target
-        run: rustup target add ${{ matrix.target }}
-
-      - name: Rust Cache
-        uses: Swatinem/rust-cache@v2
-        with:
-          workspaces: src-tauri
-          cache-all-crates: true
-          save-if: ${{ github.ref == 'refs/heads/dev' }}
-
-      - 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 ${{ env.TAG_NAME }}
-
-      - name: Tauri build
-        uses: tauri-apps/tauri-action@v0
-        env:
-          NODE_OPTIONS: "--max_old_space_size=4096"
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
-          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
-          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
-          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
-          APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_SIGNING_IDENTITY }}
-          APPLE_ID: ${{ secrets.APPLE_ID }}
-          APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
-          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
-        with:
-          tagName: ${{ 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 }}
-
-  autobuild-arm-linux:
-    name: Autobuild ARM Linux
-    needs: update_tag
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - os: ubuntu-22.04
-            target: aarch64-unknown-linux-gnu
-            arch: arm64
-          - os: ubuntu-22.04
-            target: armv7-unknown-linux-gnueabihf
-            arch: armhf
-    runs-on: ${{ matrix.os }}
-    steps:
-      - name: Checkout Repository
-        uses: actions/checkout@v4
-
-      - name: Install Rust Stable
-        uses: dtolnay/rust-toolchain@stable
-
-      - name: Add Rust Target
-        run: rustup target add ${{ matrix.target }}
-
-      - name: Rust Cache
-        uses: Swatinem/rust-cache@v2
-        with:
-          workspaces: src-tauri
-          cache-all-crates: true
-          save-if: ${{ github.ref == 'refs/heads/dev' }}
-
-      - 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 ${{ env.TAG_NAME }}
-
-      - 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: 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: update_tag
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - os: windows-latest
-            target: x86_64-pc-windows-msvc
-            arch: x64
-          - os: windows-latest
-            target: aarch64-pc-windows-msvc
-            arch: arm64
-    runs-on: ${{ matrix.os }}
-    steps:
-      - name: Checkout Repository
-        uses: actions/checkout@v4
-
-      - name: Add Rust Target
-        run: rustup target add ${{ matrix.target }}
-
-      - name: Rust Cache
-        uses: Swatinem/rust-cache@v2
-        with:
-          workspaces: src-tauri
-          cache-all-crates: true
-          save-if: ${{ github.ref == 'refs/heads/dev' }}
-
-      - 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 ${{ env.TAG_NAME }}
-
-      - name: Download WebView2 Runtime
-        run: |
-          invoke-webrequest -uri https://github.com/westinyang/WebView2RuntimeArchive/releases/download/109.0.1518.78/Microsoft.WebView2.FixedVersionRuntime.109.0.1518.78.${{ matrix.arch }}.cab -outfile Microsoft.WebView2.FixedVersionRuntime.109.0.1518.78.${{ matrix.arch }}.cab
-          Expand .\Microsoft.WebView2.FixedVersionRuntime.109.0.1518.78.${{ matrix.arch }}.cab -F:* ./src-tauri
-          Remove-Item .\src-tauri\tauri.windows.conf.json
-          Rename-Item .\src-tauri\webview2.${{ matrix.arch }}.json tauri.windows.conf.json
-
-      - name: Tauri build
-        id: build
-        uses: tauri-apps/tauri-action@v0
-        env:
-          NODE_OPTIONS: "--max_old_space_size=4096"
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
-          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
-        with:
-          tauriScript: pnpm
-          args: --target ${{ matrix.target }}
-
-      - name: Rename
-        run: |
-          $files = Get-ChildItem ".\src-tauri\target\${{ matrix.target }}\release\bundle\nsis\*-setup.exe"
-          foreach ($file in $files) {
-            $newName = $file.Name -replace "-setup\.exe$", "_fixed_webview2-setup.exe"
-            Rename-Item $file.FullName $newName
-          }
-
-          $files = Get-ChildItem ".\src-tauri\target\${{ matrix.target }}\release\bundle\nsis\*.nsis.zip"
-          foreach ($file in $files) {
-            $newName = $file.Name -replace "-setup\.nsis\.zip$", "_fixed_webview2-setup.nsis.zip"
-            Rename-Item $file.FullName $newName
-          }
-
-          $files = Get-ChildItem ".\src-tauri\target\${{ matrix.target }}\release\bundle\nsis\*-setup.exe.sig"
-          foreach ($file in $files) {
-            $newName = $file.Name -replace "-setup\.exe\.sig$", "_fixed_webview2-setup.exe.sig"
-            Rename-Item $file.FullName $newName
-          }
-
-      - name: Upload Release
-        uses: softprops/action-gh-release@v2
-        with:
-          tag_name: ${{ 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 }}

.github/workflows/clippy.yml

@@ -1,63 +0,0 @@
-name: Clippy Lint
-
-on:
-  pull_request:
-
-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
-
-      - 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

.github/workflows/cross_check.yaml

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

.github/workflows/dev.yml

@@ -42,7 +42,8 @@ jobs:
         uses: Swatinem/rust-cache@v2
         with:
           workspaces: src-tauri
-          save-if: false
+          cache-all-crates: true
+          cache-on-failure: true
 
       - name: Install Node
         uses: actions/setup-node@v4
@@ -57,7 +58,7 @@ jobs:
       - name: Pnpm install and check
         run: |
           pnpm i
-          pnpm run prebuild ${{ matrix.target }}
+          pnpm check ${{ matrix.target }}
 
       - name: Tauri build
         uses: tauri-apps/tauri-action@v0

.github/workflows/fmt.yml

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

.github/workflows/release.yml

@@ -1,16 +1,7 @@
 name: Release Build
 
 on:
-  # ! 为了避免重复发布版本，应当通过独特 git tag 触发。
-  # ! 不再使用 workflow_dispatch 触发。
-  # workflow_dispatch:
-  push:
-    # 应当限制在 main 分支上触发发布。
-    branches:
-      - main
-    # 应当限制 v*.*.* 的 tag 触发发布。
-    tags:
-      - "v*.*.*"
+  workflow_dispatch:
 permissions: write-all
 env:
   CARGO_INCREMENTAL: 0
@@ -21,28 +12,7 @@ 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
-
-      - name: Check tag and package.json version
-        run: |
-          TAG_REF="${GITHUB_REF##*/}"
-          echo "Current tag: $TAG_REF"
-          PKG_VERSION=$(jq -r .version package.json)
-          echo "package.json version: $PKG_VERSION"
-          if [[ "$TAG_REF" != "v$PKG_VERSION" ]]; then
-            echo "Tag ($TAG_REF) does not match package.json version (v$PKG_VERSION)."
-            exit 1
-          fi
-          echo "Tag and package.json version are consistent."
-
   release:
-    name: Release Build
-    needs: check_tag_version
     strategy:
       fail-fast: false
       matrix:
@@ -73,13 +43,14 @@ jobs:
         uses: Swatinem/rust-cache@v2
         with:
           workspaces: src-tauri
-          save-if: false
+          cache-all-crates: true
+          cache-on-failure: true
 
       - name: Install dependencies (ubuntu only)
         if: matrix.os == 'ubuntu-22.04'
         run: |
           sudo apt-get update
-          sudo apt-get install -y libxslt1.1 libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librsvg2-dev patchelf
+          sudo apt-get install -y libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librsvg2-dev patchelf
 
       - name: Install Node
         uses: actions/setup-node@v4
@@ -94,7 +65,7 @@ jobs:
       - name: Pnpm install and check
         run: |
           pnpm i
-          pnpm run prebuild ${{ matrix.target }}
+          pnpm check ${{ matrix.target }}
 
       - name: Tauri build
         uses: tauri-apps/tauri-action@v0
@@ -117,7 +88,6 @@ jobs:
           args: --target ${{ matrix.target }}
 
   release-for-linux-arm:
-    name: Release Build for Linux ARM
     strategy:
       fail-fast: false
       matrix:
@@ -143,7 +113,7 @@ jobs:
         uses: Swatinem/rust-cache@v2
         with:
           workspaces: src-tauri
-          save-if: false
+          cache-all-crates: true
 
       - name: Install Node
         uses: actions/setup-node@v4
@@ -158,7 +128,7 @@ jobs:
       - name: Pnpm install and check
         run: |
           pnpm i
-          pnpm run prebuild ${{ matrix.target }}
+          pnpm check ${{ matrix.target }}
 
       - name: "Setup for linux"
         run: |-
@@ -183,7 +153,6 @@ jobs:
           sudo apt update
 
           sudo apt install -y \
-            libxslt1.1:${{ matrix.arch }} \
             libwebkit2gtk-4.1-dev:${{ matrix.arch }} \
             libayatana-appindicator3-dev:${{ matrix.arch }} \
             libssl-dev:${{ matrix.arch }} \
@@ -239,7 +208,6 @@ jobs:
             src-tauri/target/${{ matrix.target }}/release/bundle/rpm/*.rpm
 
   release-for-fixed-webview2:
-    name: Release Build for Fixed WebView2
     strategy:
       fail-fast: false
       matrix:
@@ -262,7 +230,8 @@ jobs:
         uses: Swatinem/rust-cache@v2
         with:
           workspaces: src-tauri
-          save-if: false
+          cache-all-crates: true
+          cache-on-failure: true
 
       - name: Install Node
         uses: actions/setup-node@v4
@@ -277,7 +246,7 @@ jobs:
       - name: Pnpm install and check
         run: |
           pnpm i
-          pnpm run prebuild ${{ matrix.target }}
+          pnpm check ${{ matrix.target }}
 
       - name: Download WebView2 Runtime
         run: |
@@ -333,7 +302,6 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
   release-update:
-    name: Release Update
     runs-on: ubuntu-latest
     needs: [release, release-for-linux-arm]
     steps:
@@ -384,7 +352,6 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
   submit-to-winget:
-    name: Submit to Winget
     runs-on: ubuntu-latest
     needs: [release-update]
     steps:

.gitignore

@@ -9,4 +9,3 @@ scripts/_env.sh
 .vscode
 .tool-versions
 .idea
-.old

.husky/pre-commit

@@ -2,23 +2,13 @@
 
 #pnpm pretty-quick --staged
 
-if git diff --cached --name-only | grep -q '^src/'; then
-    pnpm format:check
-    if [ $? -ne 0 ]; then
-        echo "Code format check failed in src/. Please fix formatting issues."
-        exit 1
-    fi
-fi
+# 运行 clippy fmt
+#cargo fmt --manifest-path ./src-tauri/Cargo.toml
 
-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
+# if [ $? -ne 0 ]; then
+#     echo "rustfmt failed to format the code. Please fix the issues and try again."
+#     exit 1
+# fi
 
 #git add .
 

.husky/pre-push

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

.prettierignore

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

.prettierrc

@@ -1,6 +0,0 @@
-{
-  "singleQuote": true,
-  "semi": false,
-  "trailingComma": "none",
-  "experimentalOperatorPosition": "start"
-}

CONTRIBUTING.md

@@ -34,27 +34,19 @@ 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 prebuild
+  pnpm run check
   # Use '--force' to force update to the latest version
-  # pnpm run prebuild --force
+  # pnpm run check --force
   ```
 - Manually download it from the [Mihomo release](https://github.com/MetaCubeX/mihomo/releases). After downloading, rename the binary according to the [Tauri configuration](https://tauri.app/v1/api/config#bundleconfig.externalbin).
 
@@ -104,29 +96,6 @@ 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.

README.md

@@ -18,18 +18,10 @@ 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).
 
-#### 我应当怎样选择发行版
-
-| 版本      | 特征                                     | 链接                                                                                   |
-| :-------- | :--------------------------------------- | :------------------------------------------------------------------------------------- |
-| Stable    | 正式版，高可靠性，适合日常使用。         | [Release](https://github.com/clash-verge-rev/clash-verge-rev/releases)                 |
-| Alpha     | 早期测试版，功能未完善，可能存在缺陷。   | [Alpha](https://github.com/clash-verge-rev/clash-verge-rev/releases/tag/alpha)         |
-| AutoBuild | 滚动更新版，持续集成更新，适合开发测试。 | [AutoBuild](https://github.com/clash-verge-rev/clash-verge-rev/releases/tag/autobuild) |
-
-#### 安装说明和常见问题，请到 [文档页](https://clash-verge-rev.github.io/) 查看
+### 安装说明和常见问题，请到[文档页](https://clash-verge-rev.github.io/)查看：[Doc](https://clash-verge-rev.github.io/)
 
 ---
 
@@ -37,7 +29,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)
@@ -49,19 +41,6 @@ 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 框架

UPDATELOG.md

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

crowdin.yml

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

package.json

@@ -1,28 +1,24 @@
 {
   "name": "clash-verge",
-  "version": "2.3.1",
+  "version": "2.2.1-alpha",
   "license": "GPL-3.0-only",
   "scripts": {
-    "dev": "cross-env RUST_BACKTRACE=1 tauri dev -f verge-dev",
-    "dev:diff": "cross-env RUST_BACKTRACE=1 tauri dev -f verge-dev",
+    "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",
     "build": "cross-env NODE_OPTIONS='--max-old-space-size=4096' tauri build",
     "build:fast": "cross-env NODE_OPTIONS='--max-old-space-size=4096' tauri build -- --profile fast-release",
     "tauri": "tauri",
     "web:dev": "vite",
     "web:build": "tsc --noEmit && vite build",
     "web:serve": "vite preview",
-    "prebuild": "node scripts/prebuild.mjs",
+    "check": "node scripts/check.mjs",
     "updater": "node scripts/updater.mjs",
     "updater-fixed-webview2": "node scripts/updater-fixed-webview2.mjs",
     "portable": "node scripts/portable.mjs",
     "portable-fixed-webview2": "node scripts/portable-fixed-webview2.mjs",
-    "fix-alpha-version": "node scripts/fix-alpha_version.mjs",
-    "release-version": "node scripts/release-version.mjs",
-    "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 ."
+    "fix-alpha-version": "node scripts/alpha_version.mjs",
+    "prepare": "husky",
+    "clean": "cd ./src-tauri && cargo clean && cd -"
   },
   "dependencies": {
     "@dnd-kit/core": "^6.3.1",
@@ -31,77 +27,76 @@
     "@emotion/react": "^11.14.0",
     "@emotion/styled": "^11.14.0",
     "@juggle/resize-observer": "^3.4.0",
-    "@mui/icons-material": "^7.1.1",
-    "@mui/lab": "7.0.0-beta.13",
-    "@mui/material": "^7.1.1",
-    "@mui/x-data-grid": "^8.5.2",
-    "@tauri-apps/api": "2.5.0",
-    "@tauri-apps/plugin-clipboard-manager": "^2.2.3",
-    "@tauri-apps/plugin-dialog": "^2.2.2",
-    "@tauri-apps/plugin-fs": "^2.3.0",
-    "@tauri-apps/plugin-global-shortcut": "^2.2.1",
-    "@tauri-apps/plugin-notification": "^2.2.3",
-    "@tauri-apps/plugin-process": "^2.2.2",
-    "@tauri-apps/plugin-shell": "2.2.2",
-    "@tauri-apps/plugin-updater": "2.8.1",
-    "@tauri-apps/plugin-window-state": "^2.2.3",
+    "@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",
     "@types/json-schema": "^7.0.15",
-    "ahooks": "^3.8.5",
-    "axios": "^1.10.0",
-    "chart.js": "^4.5.0",
+    "ahooks": "^3.8.4",
+    "axios": "^1.8.3",
     "cli-color": "^2.0.4",
     "d3-shape": "^3.2.0",
     "dayjs": "1.11.13",
-    "foxact": "^0.2.49",
-    "glob": "^11.0.3",
-    "i18next": "^25.2.1",
+    "foxact": "^0.2.44",
+    "glob": "^11.0.1",
+    "i18next": "^24.2.3",
     "js-base64": "^3.7.7",
     "js-yaml": "^4.1.0",
     "lodash-es": "^4.17.21",
     "monaco-editor": "^0.52.2",
-    "monaco-yaml": "^5.4.0",
+    "monaco-yaml": "^5.3.1",
     "nanoid": "^5.1.5",
-    "peggy": "^5.0.3",
-    "react": "19.1.0",
-    "react-chartjs-2": "^5.3.0",
-    "react-dom": "19.1.0",
-    "react-error-boundary": "6.0.0",
-    "react-hook-form": "^7.58.1",
-    "react-i18next": "15.5.3",
-    "react-markdown": "10.1.0",
-    "react-monaco-editor": "0.58.0",
-    "react-router-dom": "7.6.2",
-    "react-virtuoso": "^4.13.0",
+    "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",
     "sockette": "^2.0.6",
     "swr": "^2.3.3",
     "tar": "^7.4.3",
     "types-pac": "^1.0.3",
-    "zustand": "^5.0.5"
+    "zustand": "^5.0.3"
   },
   "devDependencies": {
-    "@actions/github": "^6.0.1",
-    "@tauri-apps/cli": "2.5.0",
+    "@actions/github": "^6.0.0",
+    "@tauri-apps/cli": "2.2.7",
     "@types/js-cookie": "^3.0.6",
     "@types/js-yaml": "^4.0.9",
     "@types/lodash-es": "^4.17.12",
-    "@types/react": "19.1.8",
-    "@types/react-dom": "19.1.6",
-    "@vitejs/plugin-legacy": "^6.1.1",
-    "@vitejs/plugin-react": "4.5.2",
+    "@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",
     "adm-zip": "^0.5.16",
-    "commander": "^14.0.0",
     "cross-env": "^7.0.3",
     "https-proxy-agent": "^7.0.6",
     "husky": "^9.1.7",
-    "meta-json-schema": "^1.19.10",
+    "meta-json-schema": "^1.19.3",
     "node-fetch": "^3.3.2",
     "prettier": "^3.5.3",
-    "pretty-quick": "^4.2.2",
-    "sass": "^1.89.2",
-    "terser": "^5.43.0",
-    "typescript": "^5.8.3",
-    "vite": "^6.3.5",
+    "pretty-quick": "^4.1.1",
+    "sass": "^1.86.0",
+    "terser": "^5.39.0",
+    "typescript": "^5.8.2",
+    "vite": "^6.2.2",
     "vite-plugin-monaco-editor": "^1.1.0",
     "vite-plugin-svgr": "^4.3.0"
   },

renovate.json

@@ -1,42 +0,0 @@
-{
-  "extends": ["config:recommended"],
-  "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"]
-}

scripts/alpha_version.mjs

@@ -38,17 +38,6 @@ 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;
     // 写入版本号

scripts/check-unused-i18n.js

@@ -1,102 +0,0 @@
-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();

scripts/publish-version.mjs

@@ -1,66 +0,0 @@
-// 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();

scripts/release-version.mjs

@@ -1,253 +0,0 @@
-/**
- * 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", or "autobuild"
- *     - "alpha", "beta", "rc": Appends the tag to the current base version (e.g., 1.2.3-beta)
- *     - "autobuild": Appends a timestamped autobuild tag (e.g., 1.2.3+autobuild.2406101530)
- *
- * Examples:
- *   pnpm release-version 1.2.3
- *   pnpm release-version v1.2.3-beta
- *   pnpm release-version beta
- *   pnpm release-version autobuild
- *
- * 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";
-  }
-}
-
-/**
- * 生成短时间戳（格式：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 baseVersion = getBaseVersion(versionWithoutV);
-
-    const updatedLines = lines.map((line) => {
-      if (line.trim().startsWith("version =")) {
-        return line.replace(
-          /version\s*=\s*"[^"]+"/,
-          `version = "${baseVersion}"`,
-        );
-      }
-      return line;
-    });
-
-    await fs.writeFile(cargoTomlPath, updatedLines.join("\n"), "utf8");
-    console.log(`[INFO]: Cargo.toml version updated to: ${baseVersion}`);
-  } 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;
-    const baseVersion = getBaseVersion(versionWithoutV);
-
-    console.log(
-      "[INFO]: Current tauri.conf.json version is: ",
-      tauriConfig.version,
-    );
-    tauriConfig.version = baseVersion;
-    await fs.writeFile(
-      tauriConfigPath,
-      JSON.stringify(tauriConfig, null, 2),
-      "utf8",
-    );
-    console.log(`[INFO]: tauri.conf.json version updated to: ${baseVersion}`);
-  } catch (error) {
-    console.error("Error updating tauri.conf.json version:", error);
-    throw error;
-  }
-}
-
-/**
- * 获取当前版本号
- */
-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"];
-
-    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 {
-        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);

scripts/updatelog.mjs

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

scripts/updater.mjs

@@ -1,6 +1,6 @@
 import fetch from "node-fetch";
 import { getOctokit, context } from "@actions/github";
-import { resolveUpdateLog, resolveUpdateLogDefault } from "./updatelog.mjs";
+import { resolveUpdateLog } from "./updatelog.mjs";
 
 // Add stable update JSON filenames
 const UPDATE_TAG_NAME = "updater";
@@ -8,8 +8,8 @@ const UPDATE_JSON_FILE = "update.json";
 const UPDATE_JSON_PROXY = "update-proxy.json";
 // Add alpha update JSON filenames
 const ALPHA_TAG_NAME = "updater-alpha";
-const ALPHA_UPDATE_JSON_FILE = "update.json";
-const ALPHA_UPDATE_JSON_PROXY = "update-proxy.json";
+const ALPHA_UPDATE_JSON_FILE = "update-alpha.json";
+const ALPHA_UPDATE_JSON_PROXY = "update-alpha-proxy.json";
 
 /// generate update.json
 /// upload to update tag's release asset
@@ -78,7 +78,6 @@ async function resolveUpdater() {
 async function processRelease(github, options, tag, isAlpha) {
   if (!tag) return;
 
-  try {
   const { data: release } = await github.rest.repos.getReleaseByTag({
     ...options,
     tag: tag.name,
@@ -86,8 +85,8 @@ async function processRelease(github, options, tag, isAlpha) {
 
   const updateData = {
     name: tag.name,
-      notes: await resolveUpdateLog(tag.name).catch(() =>
-        resolveUpdateLogDefault().catch(() => "No changelog available"),
+    notes: await resolveUpdateLog(tag.name).catch(
+      () => "No changelog available",
     ),
     pub_date: new Date().toISOString(),
     platforms: {
@@ -298,16 +297,6 @@ async function processRelease(github, options, tag, isAlpha) {
       error.message,
     );
   }
-  } catch (error) {
-    if (error.status === 404) {
-      console.log(`Release not found for tag: ${tag.name}, skipping...`);
-    } else {
-      console.error(
-        `Failed to get release for tag: ${tag.name}`,
-        error.message,
-      );
-    }
-  }
 }
 
 // get the signature file content

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "clash-verge"
-version = "2.3.1"
+version = "2.2.1-alpha"
 description = "clash verge"
 authors = ["zzzgydi", "wonfen", "MystiPanda"]
 license = "GPL-3.0-only"
@@ -13,95 +13,82 @@ build = "build.rs"
 identifier = "io.github.clash-verge-rev.clash-verge-rev"
 
 [build-dependencies]
-tauri-build = { version = "2.2.0", features = [] }
+tauri-build = { version = "2.0.6", features = [] }
 
 [dependencies]
-warp = "0.3.7"
-anyhow = "1.0.98"
+warp = "0.3"
+anyhow = "1.0.97"
 dirs = "6.0"
-open = "5.3.2"
-log = "0.4.27"
-dunce = "1.0.5"
-log4rs = "1.3.0"
+open = "5.1"
+log = "0.4"
+dunce = "1.0"
+log4rs = "1"
 nanoid = "0.4"
-chrono = "0.4.41"
-sysinfo = "0.35.2"
+chrono = "0.4.40"
+sysinfo = "0.33.1"
 boa_engine = "0.20.0"
-serde_json = "1.0.140"
-serde_yaml = "0.9.34-deprecated"
-once_cell = "1.21.3"
-lazy_static = "1.5.0"
+serde_json = "1.0"
+serde_yaml = "0.9"
+once_cell = "1.20.3"
 port_scanner = "0.1.5"
 delay_timer = "0.11.6"
-parking_lot = "0.12.4"
+parking_lot = "0.12"
 percent-encoding = "2.3.1"
-tokio = { version = "1.45.1", features = [
-  "rt-multi-thread",
-  "macros",
-  "time",
-  "sync",
-] }
-serde = { version = "1.0.219", features = ["derive"] }
-reqwest = { version = "0.12.20", features = ["json", "rustls-tls", "cookies"] }
-regex = "1.11.1"
-sysproxy = { git = "https://github.com/clash-verge-rev/sysproxy-rs" }
-image = "0.25.6"
+window-shadows = { version = "0.2.2" }
+tokio = { version = "1.43", features = ["full"] }
+serde = { version = "1.0", features = ["derive"] }
+reqwest = { version = "0.12", features = ["json", "rustls-tls", "cookies"] }
+regex = "1.10.5"
+sysproxy = { git = "https://github.com/clash-verge-rev/sysproxy-rs", rev = "3d748b5" }
+image = "0.25.5"
 imageproc = "0.25.0"
-tauri = { version = "2.5.1", features = [
+rusttype = "0.9"
+tauri = { version = "2.3.1", features = [
     "protocol-asset",
     "devtools",
     "tray-icon",
     "image-ico",
     "image-png",
 ] }
-network-interface = { version = "2.0.1", features = ["serde"] }
-tauri-plugin-shell = "2.2.2"
-tauri-plugin-dialog = "2.2.2"
-tauri-plugin-fs = "2.3.0"
-tauri-plugin-process = "2.2.2"
-tauri-plugin-clipboard-manager = "2.2.3"
-tauri-plugin-deep-link = "2.3.0"
-tauri-plugin-devtools = "2.0.0"
-tauri-plugin-window-state = "2.2.3"
-zip = "4.1.0"
-reqwest_dav = "0.2.1"
+network-interface = { version = "2.0.0", features = ["serde"] }
+tauri-plugin-shell = "2.2.0"
+tauri-plugin-dialog = "2.2.0"
+tauri-plugin-fs = "2.2.0"
+tauri-plugin-notification = "2.2.1"
+tauri-plugin-process = "2.2.0"
+tauri-plugin-clipboard-manager = "2.2.1"
+tauri-plugin-deep-link = "2.2.0"
+tauri-plugin-devtools = "2.0.0-rc"
+url = "2.5.4"
+zip = "2.2.3"
+reqwest_dav = "0.1.14"
 aes-gcm = { version = "0.10.3", features = ["std"] }
 base64 = "0.22.1"
-getrandom = "0.3.3"
-tokio-tungstenite = "0.27.0"
-futures = "0.3.31"
-sys-locale = "0.3.2"
-async-trait = "0.1.88"
+getrandom = "0.3.1"
+tokio-tungstenite = "0.26.2"
+futures = "0.3"
+sys-locale = "0.3.1"
+async-trait = "0.1.87"
 mihomo_api = { path = "src_crates/crate_mihomo_api" }
 ab_glyph = "0.2.29"
-tungstenite = "0.27.0"
-libc = "0.2.173"
-gethostname = "1.0.2"
-hmac = "0.12.1"
-sha2 = "0.10.9"
-hex = "0.4.3"
+tungstenite = "0.26.2"
+
 
 [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",
-] }
+url = "2.5.4"
 
 [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.4.0"
-tauri-plugin-global-shortcut = "2.2.1"
-tauri-plugin-updater = "2.8.1"
+tauri-plugin-autostart = "2.2.0"
+tauri-plugin-global-shortcut = "2.2.0"
+tauri-plugin-updater = "2.5.1"
+tauri-plugin-window-state = "2.2.1"
+#openssl
 
 [features]
 default = ["custom-protocol"]
@@ -117,10 +104,6 @@ strip = true
 
 [profile.dev]
 incremental = true
-codegen-units = 256 # 增加编译单元，提升编译速度
-opt-level = 0       # 禁用优化，进一步提升编译速度
-debug = true        # 保留调试信息
-strip = false       # 不剥离符号，保留调试信息
 
 [profile.fast-release]
 inherits = "release"  # 继承 release 的配置
@@ -131,17 +114,23 @@ 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.20.0"
+env_logger = "0.11.0"
+mockito = "1.7.0"
+tempfile = "3.17.1"
 
 [workspace]
-members = ["src_crates/crate_mihomo_api"]
-
-# [patch.crates-io]
-# bitflags = { git = "https://github.com/bitflags/bitflags", rev = "2.9.0" }
-# zerocopy = { git = "https://github.com/google/zerocopy", rev = "v0.8.24" }
-# tungstenite = { git = "https://github.com/snapview/tungstenite-rs", rev = "v0.26.2" }
+members = [
+    "src_crates/crate_mihomo_api",]

src-tauri/capabilities/desktop-windows.json

@@ -1,9 +0,0 @@
-{
-  "identifier": "desktop-windows-capability",
-  "description": "permissions for desktop windows applications",
-  "windows": ["main"],
-  "permissions": [
-    "core:webview:allow-create-webview",
-    "core:webview:allow-create-webview-window"
-  ]
-}

src-tauri/capabilities/desktop.json

@@ -14,9 +14,8 @@
     "updater:allow-download-and-install",
     "process:allow-restart",
     "deep-link:default",
-    "autostart:allow-enable",
-    "autostart:allow-disable",
-    "autostart:allow-is-enabled",
-    "core:window:allow-set-theme"
+    "window-state:default",
+    "window-state:default",
+    "autostart:default"
   ]
 }

src-tauri/capabilities/migrated.json

@@ -68,6 +68,7 @@
     "shell:allow-spawn",
     "shell:allow-stdin-write",
     "dialog:allow-open",
+    "notification:default",
     "global-shortcut:allow-is-registered",
     "global-shortcut:allow-register",
     "global-shortcut:allow-register-all",
@@ -78,6 +79,7 @@
     "clipboard-manager:allow-read-text",
     "clipboard-manager:allow-write-text",
     "shell:default",
-    "dialog:default"
+    "dialog:default",
+    "notification:default"
   ]
 }

src-tauri/packages/windows/installer.nsi

@@ -916,10 +916,6 @@ FunctionEnd
 !macroend
 
 Section Uninstall
-  ;删除 window-state.json 文件
-  SetShellVarContext current
-  Delete "$APPDATA\io.github.clash-verge-rev.clash-verge-rev\window-state.json"
-
   !insertmacro CheckIfAppIsRunning
   !insertmacro CheckAllVergeProcesses
   !insertmacro RemoveVergeService
@@ -979,23 +975,16 @@ Section Uninstall
   RMDir "$INSTDIR"
 
   !insertmacro DeleteAppUserModelId
-  !insertmacro UnpinShortcut "$SMPROGRAMS\$AppStartMenuFolder\${PRODUCTNAME}.lnk"
-  !insertmacro UnpinShortcut "$DESKTOP\${PRODUCTNAME}.lnk"
-  ; 兼容旧名称快捷方式
-  !insertmacro UnpinShortcut "$SMPROGRAMS\$AppStartMenuFolder\clash-verge.lnk"
-  !insertmacro UnpinShortcut "$DESKTOP\clash-verge.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\${PRODUCTNAME}.lnk"
-  ; 兼容旧名称快捷方式
-  Delete "$SMPROGRAMS\$AppStartMenuFolder\clash-verge.lnk"
+  Delete "$SMPROGRAMS\$AppStartMenuFolder\${MAINBINARYNAME}.lnk"
   RMDir "$SMPROGRAMS\$AppStartMenuFolder"
 
   ; Remove desktop shortcuts
-  Delete "$DESKTOP\${PRODUCTNAME}.lnk"
-  ; 兼容旧名称快捷方式
-  Delete "$DESKTOP\clash-verge.lnk"
+  Delete "$DESKTOP\${MAINBINARYNAME}.lnk"
 
   ; Remove registry information for add/remove programs
   !if "${INSTALLMODE}" == "both"
@@ -1015,10 +1004,6 @@ Section Uninstall
     RmDir /r "$LOCALAPPDATA\${BUNDLEID}"
   ${EndIf}
 
-  ;删除 window-state.json 文件
-  SetShellVarContext current
-  Delete "$APPDATA\io.github.clash-verge-rev.clash-verge-rev\window-state.json"
-
   ${GetOptions} $CMDLINE "/P" $R0
   IfErrors +2 0
     SetAutoClose true
@@ -1061,12 +1046,12 @@ FunctionEnd
 !macroend
 
 Function CreateDesktopShortcut
-  CreateShortcut "$DESKTOP\${PRODUCTNAME}.lnk" "$INSTDIR\${MAINBINARYNAME}.exe"
-  !insertmacro SetLnkAppUserModelId "$DESKTOP\${PRODUCTNAME}.lnk"
+  CreateShortcut "$DESKTOP\${MAINBINARYNAME}.lnk" "$INSTDIR\${MAINBINARYNAME}.exe"
+  !insertmacro SetLnkAppUserModelId "$DESKTOP\${MAINBINARYNAME}.lnk"
 FunctionEnd
 
 Function CreateStartMenuShortcut
   CreateDirectory "$SMPROGRAMS\$AppStartMenuFolder"
-  CreateShortcut "$SMPROGRAMS\$AppStartMenuFolder\${PRODUCTNAME}.lnk" "$INSTDIR\${MAINBINARYNAME}.exe"
-  !insertmacro SetLnkAppUserModelId "$SMPROGRAMS\$AppStartMenuFolder\${PRODUCTNAME}.lnk"
+  CreateShortcut "$SMPROGRAMS\$AppStartMenuFolder\${MAINBINARYNAME}.lnk" "$INSTDIR\${MAINBINARYNAME}.exe"
+  !insertmacro SetLnkAppUserModelId "$SMPROGRAMS\$AppStartMenuFolder\${MAINBINARYNAME}.lnk"
 FunctionEnd

src-tauri/rustfmt.toml

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

src-tauri/src/cmd/app.rs

@@ -1,9 +1,5 @@
 use super::CmdResult;
-use crate::{
-    feat, logging,
-    utils::{dirs, logging::Type},
-    wrap_err,
-};
+use crate::{feat, utils::dirs, wrap_err};
 use tauri::Manager;
 
 /// 打开应用程序所在目录
@@ -49,7 +45,7 @@ pub fn open_devtools(app_handle: tauri::AppHandle) {
 /// 退出应用
 #[tauri::command]
 pub fn exit_app() {
-    feat::quit();
+    feat::quit(Some(0));
 }
 
 /// 重启应用
@@ -87,18 +83,23 @@ 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)
@@ -107,13 +108,16 @@ 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) {
@@ -130,6 +134,7 @@ pub async fn download_icon_cache(url: String, name: String) -> CmdResult<String>
             wrap_err!(std::io::copy(&mut content.as_ref(), &mut file))?;
         }
 
+        // 再次检查目标文件是否已存在，避免重命名覆盖其他线程已完成的文件
         if !icon_path.exists() {
             match std::fs::rename(&temp_path, &icon_path) {
                 Ok(_) => {}
@@ -189,14 +194,7 @@ pub fn copy_icon_file(path: String, icon_info: IconInfo) -> CmdResult<String> {
             )
             .unwrap_or_default();
         }
-        logging!(
-            info,
-            Type::Cmd,
-            true,
-            "Copying icon file path: {:?} -> file dist: {:?}",
-            path,
-            dest_path
-        );
+
         match fs::copy(file_path, &dest_path) {
             Ok(_) => Ok(dest_path.to_string_lossy().to_string()),
             Err(err) => Err(err.to_string()),
@@ -205,42 +203,3 @@ 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(())
-}

src-tauri/src/cmd/clash.rs

@@ -1,7 +1,5 @@
 use super::CmdResult;
-use crate::{
-    config::*, core::*, feat, module::mihomo::MihomoManager, process::AsyncHandler, wrap_err,
-};
+use crate::{config::*, core::*, feat, module::mihomo::MihomoManager, wrap_err};
 use serde_yaml::Mapping;
 
 /// 复制Clash环境变量
@@ -40,22 +38,11 @@ pub async fn change_clash_core(clash_core: String) -> CmdResult<Option<String>>
         .await
     {
         Ok(_) => {
-            // 切换内核后重启内核
-            match CoreManager::global().restart_core().await {
-                Ok(_) => {
-                    log::info!(target: "app", "core changed and restarted to {clash_core}");
+            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)
         }
-                Err(err) => {
-                    let error_msg = format!("Core changed but failed to restart: {}", err);
-                    log::error!(target: "app", "{}", error_msg);
-                    handle::Handle::notice_message("config_core::change_error", &error_msg);
-                    Ok(Some(error_msg))
-                }
-            }
-        }
         Err(err) => {
             let error_msg = err.to_string();
             log::error!(target: "app", "failed to change core: {error_msg}");
@@ -65,18 +52,6 @@ pub async fn change_clash_core(clash_core: String) -> CmdResult<Option<String>>
     }
 }
 
-/// 启动核心
-#[tauri::command]
-pub async fn start_core() -> CmdResult {
-    wrap_err!(CoreManager::global().start_core().await)
-}
-
-/// 关闭核心
-#[tauri::command]
-pub async fn stop_core() -> CmdResult {
-    wrap_err!(CoreManager::global().stop_core().await)
-}
-
 /// 重启核心
 #[tauri::command]
 pub async fn restart_core() -> CmdResult {
@@ -129,9 +104,10 @@ pub fn apply_dns_config(apply: bool) -> CmdResult {
         core::{handle, CoreManager},
         utils::dirs,
     };
+    use tauri::async_runtime;
 
     // 使用spawn来处理异步操作
-    AsyncHandler::spawn(move || async move {
+    async_runtime::spawn(async move {
         if apply {
             // 读取DNS配置文件
             let dns_path = match dirs::app_home_dir() {
@@ -245,25 +221,3 @@ 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()),
-    }
-}

src-tauri/src/cmd/lighteweight.rs

@@ -7,9 +7,3 @@ 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(())
-}

src-tauri/src/cmd/media_unlock_checker.rs

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

src-tauri/src/cmd/mod.rs

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

src-tauri/src/cmd/network.rs

@@ -3,16 +3,11 @@ use crate::wrap_err;
 use network_interface::NetworkInterface;
 use serde_yaml::Mapping;
 use sysproxy::{Autoproxy, Sysproxy};
-use tokio::task::spawn_blocking;
 
 /// get the system proxy
 #[tauri::command]
-pub async fn get_sys_proxy() -> CmdResult<Mapping> {
-    let current = spawn_blocking(Sysproxy::get_system_proxy)
-        .await
-        .map_err(|e| format!("Failed to spawn blocking task for sysproxy: {}", e))?
-        .map_err(|e| format!("Failed to get system proxy: {}", e))?;
-
+pub fn get_sys_proxy() -> CmdResult<Mapping> {
+    let current = wrap_err!(Sysproxy::get_system_proxy())?;
     let mut map = Mapping::new();
     map.insert("enable".into(), current.enable.into());
     map.insert(
@@ -26,11 +21,8 @@ pub async fn get_sys_proxy() -> CmdResult<Mapping> {
 
 /// get the system proxy
 #[tauri::command]
-pub async fn get_auto_proxy() -> CmdResult<Mapping> {
-    let current = spawn_blocking(Autoproxy::get_auto_proxy)
-        .await
-        .map_err(|e| format!("Failed to spawn blocking task for autoproxy: {}", e))?
-        .map_err(|e| format!("Failed to get auto proxy: {}", e))?;
+pub fn get_auto_proxy() -> CmdResult<Mapping> {
+    let current = wrap_err!(Autoproxy::get_auto_proxy())?;
 
     let mut map = Mapping::new();
     map.insert("enable".into(), current.enable.into());
@@ -39,25 +31,6 @@ pub async fn get_auto_proxy() -> CmdResult<Mapping> {
     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> {

src-tauri/src/cmd/profile.rs

@@ -1,111 +1,41 @@
 use super::CmdResult;
 use crate::{
-    config::{Config, IProfiles, PrfItem, PrfOption},
-    core::{handle, timer::Timer, tray::Tray, CoreManager},
-    feat, logging, ret_err,
-    utils::{dirs, help, logging::Type},
+    config::*,
+    core::*,
+    feat, log_err, ret_err,
+    utils::{dirs, help},
     wrap_err,
 };
-use std::time::Duration;
-use tokio::sync::Mutex;
 
-// 添加全局互斥锁防止并发配置更新
-static PROFILE_UPDATE_MUTEX: Mutex<()> = Mutex::const_new(());
-
-/// 获取配置文件避免锁竞争
+/// 获取配置文件列表
 #[tauri::command]
-pub async fn get_profiles() -> CmdResult<IProfiles> {
-    // 策略1: 尝试快速获取latest数据
-    let latest_result = tokio::time::timeout(
-        Duration::from_millis(500),
-        tokio::task::spawn_blocking(move || {
-            let profiles = Config::profiles();
-            let latest = profiles.latest();
-            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),
-        tokio::task::spawn_blocking(move || {
-            let profiles = Config::profiles();
-            let data = profiles.data();
-            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 tokio::task::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![]),
-            })
-        }
-    }
+pub fn get_profiles() -> CmdResult<IProfiles> {
+    let _ = tray::Tray::global().update_menu();
+    Ok(Config::profiles().data().clone())
 }
 
 /// 增强配置文件
 #[tauri::command]
 pub async fn enhance_profiles() -> CmdResult {
-    wrap_err!(feat::enhance_profiles().await)?;
+    match CoreManager::global().update_config().await {
+        Ok((true, _)) => {
+            println!("[enhance_profiles] 配置更新成功");
+            log_err!(tray::Tray::global().update_tooltip());
             handle::Handle::refresh_clash();
             Ok(())
         }
+        Ok((false, error_msg)) => {
+            println!("[enhance_profiles] 配置验证失败: {}", error_msg);
+            handle::Handle::notice_message("config_validate::error", &error_msg);
+            Ok(())
+        }
+        Err(e) => {
+            println!("[enhance_profiles] 更新过程发生错误: {}", e);
+            handle::Handle::notice_message("config_validate::process_terminated", e.to_string());
+            Ok(())
+        }
+    }
+}
 
 /// 导入配置文件
 #[tauri::command]
@@ -130,17 +60,13 @@ pub async fn create_profile(item: PrfItem, file_data: Option<String>) -> CmdResu
 /// 更新配置文件
 #[tauri::command]
 pub async fn update_profile(index: String, option: Option<PrfOption>) -> CmdResult {
-    wrap_err!(feat::update_profile(index, option, Some(true)).await)
+    wrap_err!(feat::update_profile(index, option).await)
 }
 
 /// 删除配置文件
 #[tauri::command]
 pub async fn delete_profile(index: String) -> CmdResult {
     let should_update = wrap_err!({ Config::profiles().data().delete_item(index) })?;
-
-    // 删除后自动清理冗余文件
-    let _ = Config::profiles().latest().auto_cleanup();
-
     if should_update {
         wrap_err!(CoreManager::global().update_config().await)?;
         handle::Handle::refresh_clash();
@@ -151,187 +77,33 @@ pub async fn delete_profile(index: String) -> CmdResult {
 /// 修改profiles的配置
 #[tauri::command]
 pub async fn patch_profiles_config(profiles: IProfiles) -> CmdResult<bool> {
-    // 获取互斥锁，防止并发执行
-    let _guard = PROFILE_UPDATE_MUTEX.lock().await;
-
-    logging!(info, Type::Cmd, true, "开始修改配置文件");
+    println!("[cmd配置patch] 开始修改配置文件");
 
     // 保存当前配置，以便在验证失败时恢复
     let current_profile = Config::profiles().latest().current.clone();
-    logging!(info, Type::Cmd, true, "当前配置: {:?}", current_profile);
-
-    // 如果要切换配置，先检查目标配置文件是否有语法错误
-    if let Some(new_profile) = profiles.current.as_ref() {
-        if current_profile.as_ref() != Some(new_profile) {
-            logging!(info, Type::Cmd, true, "正在切换到新配置: {}", new_profile);
-
-            // 获取目标配置文件路径
-            let config_file_result = {
-                let profiles_config = Config::profiles();
-                let profiles_data = profiles_config.latest();
-                match profiles_data.get_item(new_profile) {
-                    Ok(item) => {
-                        if let Some(file) = &item.file {
-                            let path = dirs::app_profiles_dir().map(|dir| dir.join(file));
-                            path.ok()
-                        } else {
-                            None
-                        }
-                    }
-                    Err(e) => {
-                        logging!(error, Type::Cmd, true, "获取目标配置信息失败: {}", e);
-                        None
-                    }
-                }
-            };
-
-            // 如果获取到文件路径，检查YAML语法
-            if let Some(file_path) = config_file_result {
-                if !file_path.exists() {
-                    logging!(
-                        error,
-                        Type::Cmd,
-                        true,
-                        "目标配置文件不存在: {}",
-                        file_path.display()
-                    );
-                    handle::Handle::notice_message(
-                        "config_validate::file_not_found",
-                        format!("{}", file_path.display()),
-                    );
-                    return Ok(false);
-                }
-
-                // 超时保护
-                let file_read_result = tokio::time::timeout(
-                    Duration::from_secs(5),
-                    tokio::fs::read_to_string(&file_path),
-                )
-                .await;
-
-                match file_read_result {
-                    Ok(Ok(content)) => {
-                        let yaml_parse_result = tokio::task::spawn_blocking(move || {
-                            serde_yaml::from_str::<serde_yaml::Value>(&content)
-                        })
-                        .await;
-
-                        match yaml_parse_result {
-                            Ok(Ok(_)) => {
-                                logging!(info, Type::Cmd, true, "目标配置文件语法正确");
-                            }
-                            Ok(Err(err)) => {
-                                let error_msg = format!(" {}", err);
-                                logging!(
-                                    error,
-                                    Type::Cmd,
-                                    true,
-                                    "目标配置文件存在YAML语法错误:{}",
-                                    error_msg
-                                );
-                                handle::Handle::notice_message(
-                                    "config_validate::yaml_syntax_error",
-                                    &error_msg,
-                                );
-                                return Ok(false);
-                            }
-                            Err(join_err) => {
-                                let error_msg = format!("YAML解析任务失败: {}", join_err);
-                                logging!(error, Type::Cmd, true, "{}", error_msg);
-                                handle::Handle::notice_message(
-                                    "config_validate::yaml_parse_error",
-                                    &error_msg,
-                                );
-                                return Ok(false);
-                            }
-                        }
-                    }
-                    Ok(Err(err)) => {
-                        let error_msg = format!("无法读取目标配置文件: {}", err);
-                        logging!(error, Type::Cmd, true, "{}", error_msg);
-                        handle::Handle::notice_message(
-                            "config_validate::file_read_error",
-                            &error_msg,
-                        );
-                        return Ok(false);
-                    }
-                    Err(_) => {
-                        let error_msg = "读取配置文件超时(5秒)".to_string();
-                        logging!(error, Type::Cmd, true, "{}", error_msg);
-                        handle::Handle::notice_message(
-                            "config_validate::file_read_timeout",
-                            &error_msg,
-                        );
-                        return Ok(false);
-                    }
-                }
-            }
-        }
-    }
+    println!("[cmd配置patch] 当前配置: {:?}", current_profile);
 
     // 更新profiles配置
-    logging!(info, Type::Cmd, true, "正在更新配置草稿");
-
-    let current_value = profiles.current.clone();
-
-    let _ = Config::profiles().draft().patch_config(profiles);
-
-    // 为配置更新添加超时保护
-    let update_result = tokio::time::timeout(
-        Duration::from_secs(30), // 30秒超时
-        CoreManager::global().update_config(),
-    )
-    .await;
+    println!("[cmd配置patch] 正在更新配置草稿");
+    wrap_err!({ Config::profiles().draft().patch_config(profiles) })?;
 
     // 更新配置并进行验证
-    match update_result {
-        Ok(Ok((true, _))) => {
-            logging!(info, Type::Cmd, true, "配置更新成功");
-            Config::profiles().apply();
+    match CoreManager::global().update_config().await {
+        Ok((true, _)) => {
+            println!("[cmd配置patch] 配置更新成功");
             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().save_file() {
-                    log::warn!(target: "app", "异步保存配置文件失败: {}", e);
-                }
-            });
-
-            // 立即通知前端配置变更
-            if let Some(current) = &current_value {
-                logging!(info, Type::Cmd, true, "向前端发送配置变更事件: {}", current);
-                handle::Handle::notify_profile_changed(current.clone());
-            }
-
+            let _ = tray::Tray::global().update_tooltip();
+            Config::profiles().apply();
+            wrap_err!(Config::profiles().data().save_file())?;
             Ok(true)
         }
-        Ok(Ok((false, error_msg))) => {
-            logging!(warn, Type::Cmd, true, "配置验证失败: {}", error_msg);
+        Ok((false, error_msg)) => {
+            println!("[cmd配置patch] 配置验证失败: {}", error_msg);
             Config::profiles().discard();
+
             // 如果验证失败，恢复到之前的配置
             if let Some(prev_profile) = current_profile {
-                logging!(
-                    info,
-                    Type::Cmd,
-                    true,
-                    "尝试恢复到之前的配置: {}",
-                    prev_profile
-                );
+                println!("[cmd配置patch] 尝试恢复到之前的配置: {}", prev_profile);
                 let restore_profiles = IProfiles {
                     current: Some(prev_profile),
                     items: None,
@@ -339,51 +111,20 @@ pub async fn patch_profiles_config(profiles: IProfiles) -> CmdResult<bool> {
                 // 静默恢复，不触发验证
                 wrap_err!({ Config::profiles().draft().patch_config(restore_profiles) })?;
                 Config::profiles().apply();
-
-                crate::process::AsyncHandler::spawn(|| async move {
-                    if let Err(e) = Config::profiles().data().save_file() {
-                        log::warn!(target: "app", "异步保存恢复配置文件失败: {}", e);
-                    }
-                });
-
-                logging!(info, Type::Cmd, true, "成功恢复到之前的配置");
+                wrap_err!(Config::profiles().data().save_file())?;
+                println!("[cmd配置patch] 成功恢复到之前的配置");
             }
 
             // 发送验证错误通知
             handle::Handle::notice_message("config_validate::error", &error_msg);
             Ok(false)
         }
-        Ok(Err(e)) => {
-            logging!(warn, Type::Cmd, true, "更新过程发生错误: {}", e);
+        Err(e) => {
+            println!("[cmd配置patch] 更新过程发生错误: {}", e);
             Config::profiles().discard();
             handle::Handle::notice_message("config_validate::boot_error", e.to_string());
             Ok(false)
         }
-        Err(_) => {
-            // 超时处理
-            let timeout_msg = "配置更新超时(30秒)，可能是配置验证或核心通信阻塞";
-            logging!(error, Type::Cmd, true, "{}", timeout_msg);
-            Config::profiles().discard();
-
-            if let Some(prev_profile) = current_profile {
-                logging!(
-                    info,
-                    Type::Cmd,
-                    true,
-                    "超时后尝试恢复到之前的配置: {}",
-                    prev_profile
-                );
-                let restore_profiles = IProfiles {
-                    current: Some(prev_profile),
-                    items: None,
-                };
-                wrap_err!({ Config::profiles().draft().patch_config(restore_profiles) })?;
-                Config::profiles().apply();
-            }
-
-            handle::Handle::notice_message("config_validate::timeout", timeout_msg);
-            Ok(false)
-        }
     }
 }
 
@@ -393,8 +134,6 @@ pub async fn patch_profiles_config_by_profile_index(
     _app_handle: tauri::AppHandle,
     profile_index: String,
 ) -> CmdResult<bool> {
-    logging!(info, Type::Cmd, true, "切换配置到: {}", profile_index);
-
     let profiles = IProfiles {
         current: Some(profile_index),
         items: None,
@@ -405,33 +144,7 @@ pub async fn patch_profiles_config_by_profile_index(
 /// 修改某个profile item的
 #[tauri::command]
 pub fn patch_profile(index: String, profile: PrfItem) -> CmdResult {
-    // 保存修改前检查是否有更新 update_interval
-    let update_interval_changed =
-        if let Ok(old_profile) = Config::profiles().latest().get_item(&index) {
-            let old_interval = old_profile.option.as_ref().and_then(|o| o.update_interval);
-            let new_interval = profile.option.as_ref().and_then(|o| o.update_interval);
-            old_interval != new_interval
-        } else {
-            false
-        };
-
-    // 保存修改
-    wrap_err!(Config::profiles().data().patch_item(index.clone(), profile))?;
-
-    // 如果更新间隔变更，异步刷新定时器
-    if update_interval_changed {
-        let index_clone = index.clone();
-        crate::process::AsyncHandler::spawn(move || async move {
-            logging!(info, Type::Timer, "定时器更新间隔已变更，正在刷新定时器...");
-            if let Err(e) = crate::core::Timer::global().refresh() {
-                logging!(error, Type::Timer, "刷新定时器失败: {}", e);
-            } else {
-                // 刷新成功后发送自定义事件，不触发配置重载
-                crate::core::handle::Handle::notify_timer_updated(index_clone);
-            }
-        });
-    }
-
+    wrap_err!(Config::profiles().data().patch_item(index, profile))?;
     Ok(())
 }
 
@@ -462,11 +175,3 @@ pub fn read_profile_file(index: String) -> CmdResult<String> {
     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)
-}

src-tauri/src/cmd/proxy.rs

@@ -1,99 +1,24 @@
 use super::CmdResult;
-use crate::{core::handle, module::mihomo::MihomoManager, state::proxy::CmdProxyState};
-use std::{
-    sync::Mutex,
-    time::{Duration, Instant},
-};
-use tauri::Manager;
-
-const PROVIDERS_REFRESH_INTERVAL: Duration = Duration::from_secs(3);
-const PROXIES_REFRESH_INTERVAL: Duration = Duration::from_secs(1);
+use crate::module::mihomo::MihomoManager;
 
 #[tauri::command]
 pub async fn get_proxies() -> CmdResult<serde_json::Value> {
-    let manager = MihomoManager::global();
-
-    let app_handle = handle::Handle::global().app_handle().unwrap();
-    let cmd_proxy_state = app_handle.state::<Mutex<CmdProxyState>>();
-
-    let should_refresh = {
-        let mut state = cmd_proxy_state.lock().unwrap();
-        let now = Instant::now();
-        if now.duration_since(state.last_refresh_time) > PROXIES_REFRESH_INTERVAL {
-            state.need_refresh = true;
-            state.last_refresh_time = now;
-        }
-        state.need_refresh
-    };
-
-    if should_refresh {
-        let proxies = manager.get_refresh_proxies().await?;
-        {
-            let mut state = cmd_proxy_state.lock().unwrap();
-            state.proxies = Box::new(proxies);
-            state.need_refresh = false;
-        }
-        log::debug!(target: "app", "proxies刷新成功");
-    }
-
-    let proxies = {
-        let state = cmd_proxy_state.lock().unwrap();
-        state.proxies.clone()
-    };
-    Ok(*proxies)
-}
-
-/// 强制刷新代理缓存用于profile切换
-#[tauri::command]
-pub async fn force_refresh_proxies() -> CmdResult<serde_json::Value> {
-    let manager = MihomoManager::global();
-    let app_handle = handle::Handle::global().app_handle().unwrap();
-    let cmd_proxy_state = app_handle.state::<Mutex<CmdProxyState>>();
-
-    log::debug!(target: "app", "强制刷新代理缓存");
-
-    let proxies = manager.get_refresh_proxies().await?;
-
-    {
-        let mut state = cmd_proxy_state.lock().unwrap();
-        state.proxies = Box::new(proxies.clone());
-        state.need_refresh = false;
-        state.last_refresh_time = Instant::now();
-    }
-
-    log::debug!(target: "app", "强制刷新代理缓存完成");
-    Ok(proxies)
+    let mannager = MihomoManager::global();
+    let proxies = mannager
+        .refresh_proxies()
+        .await
+        .map(|_| mannager.get_proxies())
+        .or_else(|_| Ok(mannager.get_proxies()));
+    proxies
 }
 
 #[tauri::command]
 pub async fn get_providers_proxies() -> CmdResult<serde_json::Value> {
-    let app_handle = handle::Handle::global().app_handle().unwrap();
-    let cmd_proxy_state = app_handle.state::<Mutex<CmdProxyState>>();
-
-    let should_refresh = {
-        let mut state = cmd_proxy_state.lock().unwrap();
-        let now = Instant::now();
-        if now.duration_since(state.last_refresh_time) > PROVIDERS_REFRESH_INTERVAL {
-            state.need_refresh = true;
-            state.last_refresh_time = now;
-        }
-        state.need_refresh
-    };
-
-    if should_refresh {
-        let manager = MihomoManager::global();
-        let providers = manager.get_providers_proxies().await?;
-        {
-            let mut state = cmd_proxy_state.lock().unwrap();
-            state.providers_proxies = Box::new(providers);
-            state.need_refresh = false;
-        }
-        log::debug!(target: "app", "providers_proxies刷新成功");
-    }
-
-    let providers_proxies = {
-        let state = cmd_proxy_state.lock().unwrap();
-        state.providers_proxies.clone()
-    };
-    Ok(*providers_proxies)
+    let mannager = MihomoManager::global();
+    let providers = mannager
+        .refresh_providers_proxies()
+        .await
+        .map(|_| mannager.get_providers_proxies())
+        .or_else(|_| Ok(mannager.get_providers_proxies()));
+    providers
 }

src-tauri/src/cmd/save_profile.rs

@@ -1,11 +1,5 @@
 use super::CmdResult;
-use crate::{
-    config::*,
-    core::*,
-    logging,
-    utils::{dirs, logging::Type},
-    wrap_err,
-};
+use crate::{config::*, core::*, utils::dirs, wrap_err};
 use std::fs;
 
 /// 保存profiles的配置
@@ -32,54 +26,29 @@ pub async fn save_profile_file(index: String, file_data: Option<String>) -> CmdR
     wrap_err!(fs::write(&file_path, file_data.clone().unwrap()))?;
 
     let file_path_str = file_path.to_string_lossy().to_string();
-    logging!(
-        info,
-        Type::Config,
-        true,
+    println!(
         "[cmd配置save] 开始验证配置文件: {}, 是否为merge文件: {}",
-        file_path_str,
-        is_merge_file
+        file_path_str, is_merge_file
     );
 
     // 对于 merge 文件，只进行语法验证，不进行后续内核验证
     if is_merge_file {
-        logging!(
-            info,
-            Type::Config,
-            true,
-            "[cmd配置save] 检测到merge文件，只进行语法验证"
-        );
+        println!("[cmd配置save] 检测到merge文件，只进行语法验证");
         match CoreManager::global()
             .validate_config_file(&file_path_str, Some(true))
             .await
         {
             Ok((true, _)) => {
-                logging!(
-                    info,
-                    Type::Config,
-                    true,
-                    "[cmd配置save] merge文件语法验证通过"
-                );
+                println!("[cmd配置save] merge文件语法验证通过");
                 // 成功后尝试更新整体配置
                 if let Err(e) = CoreManager::global().update_config().await {
-                    logging!(
-                        warn,
-                        Type::Config,
-                        true,
-                        "[cmd配置save] 更新整体配置时发生错误: {}",
-                        e
-                    );
+                    println!("[cmd配置save] 更新整体配置时发生错误: {}", e);
+                    log::warn!(target: "app", "更新整体配置时发生错误: {}", e);
                 }
                 return Ok(());
             }
             Ok((false, error_msg)) => {
-                logging!(
-                    warn,
-                    Type::Config,
-                    true,
-                    "[cmd配置save] merge文件语法验证失败: {}",
-                    error_msg
-                );
+                println!("[cmd配置save] merge文件语法验证失败: {}", error_msg);
                 // 恢复原始配置文件
                 wrap_err!(fs::write(&file_path, original_content))?;
                 // 发送合并文件专用错误通知
@@ -88,13 +57,7 @@ pub async fn save_profile_file(index: String, file_data: Option<String>) -> CmdR
                 return Ok(());
             }
             Err(e) => {
-                logging!(
-                    error,
-                    Type::Config,
-                    true,
-                    "[cmd配置save] 验证过程发生错误: {}",
-                    e
-                );
+                println!("[cmd配置save] 验证过程发生错误: {}", e);
                 // 恢复原始配置文件
                 wrap_err!(fs::write(&file_path, original_content))?;
                 return Err(e.to_string());
@@ -108,17 +71,11 @@ pub async fn save_profile_file(index: String, file_data: Option<String>) -> CmdR
         .await
     {
         Ok((true, _)) => {
-            logging!(info, Type::Config, true, "[cmd配置save] 验证成功");
+            println!("[cmd配置save] 验证成功");
             Ok(())
         }
         Ok((false, error_msg)) => {
-            logging!(
-                warn,
-                Type::Config,
-                true,
-                "[cmd配置save] 验证失败: {}",
-                error_msg
-            );
+            println!("[cmd配置save] 验证失败: {}", error_msg);
             // 恢复原始配置文件
             wrap_err!(fs::write(&file_path, original_content))?;
 
@@ -133,30 +90,24 @@ pub async fn save_profile_file(index: String, file_data: Option<String>) -> CmdR
                 || (!file_path_str.ends_with(".js") && !is_script_error)
             {
                 // 普通YAML错误使用YAML通知处理
-                log::info!(target: "app", "[cmd配置save] YAML配置文件验证失败，发送通知");
+                println!("[cmd配置save] YAML配置文件验证失败，发送通知");
                 let result = (false, error_msg.clone());
                 crate::cmd::validate::handle_yaml_validation_notice(&result, "YAML配置文件");
             } else if is_script_error {
                 // 脚本错误使用专门的通知处理
-                log::info!(target: "app", "[cmd配置save] 脚本文件验证失败，发送通知");
+                println!("[cmd配置save] 脚本文件验证失败，发送通知");
                 let result = (false, error_msg.clone());
                 crate::cmd::validate::handle_script_validation_notice(&result, "脚本文件");
             } else {
                 // 普通配置错误使用一般通知
-                log::info!(target: "app", "[cmd配置save] 其他类型验证失败，发送一般通知");
+                println!("[cmd配置save] 其他类型验证失败，发送一般通知");
                 handle::Handle::notice_message("config_validate::error", &error_msg);
             }
 
             Ok(())
         }
         Err(e) => {
-            logging!(
-                error,
-                Type::Config,
-                true,
-                "[cmd配置save] 验证过程发生错误: {}",
-                e
-            );
+            println!("[cmd配置save] 验证过程发生错误: {}", e);
             // 恢复原始配置文件
             wrap_err!(fs::write(&file_path, original_content))?;
             Err(e.to_string())

src-tauri/src/cmd/service.rs

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

src-tauri/src/cmd/system.rs

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

src-tauri/src/cmd/validate.rs

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

src-tauri/src/cmd/verge.rs

@@ -6,7 +6,7 @@ use crate::{config::*, feat, wrap_err};
 pub fn get_verge_config() -> CmdResult<IVergeResponse> {
     let verge = Config::verge();
     let verge_data = verge.data().clone();
-    Ok(IVergeResponse::from(*verge_data))
+    Ok(IVergeResponse::from(verge_data))
 }
 
 /// 修改Verge配置

src-tauri/src/config/clash.rs

@@ -20,12 +20,6 @@ impl IClashTemp {
                         map.insert(key.clone(), template.0.get(key).unwrap().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) => {
@@ -38,13 +32,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")]
@@ -52,27 +46,14 @@ 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(), "warning".into());
+        map.insert("log-level".into(), "info".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();
         cors_map.insert("allow-private-network".into(), true.into());
-        cors_map.insert(
-            "allow-origins".into(),
-            vec![
-                "tauri://localhost",
-                "http://tauri.localhost",
-                // Only enable this in dev mode
-                #[cfg(feature = "verge-dev")]
-                "http://localhost:3000",
-                "https://yacd.metacubex.one",
-                "https://metacubex.github.io",
-                "https://board.zash.run.place",
-            ]
-            .into(),
-        );
-        map.insert("secret".into(), "set-your-secret".into());
+        cors_map.insert("allow-origins".into(), vec!["*"].into());
+        map.insert("secret".into(), "".into());
         map.insert("tun".into(), tun.into());
         map.insert("external-controller-cors".into(), cors_map.into());
         map.insert("unified-delay".into(), true.into());
@@ -96,26 +77,6 @@ impl IClashTemp {
         config.insert("socks-port".into(), socks_port.into());
         config.insert("port".into(), port.into());
         config.insert("external-controller".into(), ctrl.into());
-
-        // 强制覆盖 external-controller-cors 字段，允许本地和 tauri 前端
-        let mut cors_map = Mapping::new();
-        cors_map.insert("allow-private-network".into(), true.into());
-        cors_map.insert(
-            "allow-origins".into(),
-            vec![
-                "tauri://localhost",
-                "http://tauri.localhost",
-                // 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(),
-        );
-        config.insert("external-controller-cors".into(), cors_map.into());
-
         config
     }
 
@@ -355,13 +316,6 @@ 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 {
@@ -375,7 +329,6 @@ 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)]

src-tauri/src/config/config.rs

@@ -2,9 +2,8 @@ use super::{Draft, IClashTemp, IProfiles, IRuntime, IVerge};
 use crate::{
     config::PrfItem,
     core::{handle, CoreManager},
-    enhance, logging,
-    process::AsyncHandler,
-    utils::{dirs, help, logging::Type},
+    enhance,
+    utils::{dirs, help},
 };
 use anyhow::{anyhow, Result};
 use once_cell::sync::OnceCell;
@@ -15,10 +14,10 @@ pub const RUNTIME_CONFIG: &str = "clash-verge.yaml";
 pub const CHECK_CONFIG: &str = "clash-verge-check.yaml";
 
 pub struct Config {
-    clash_config: Draft<Box<IClashTemp>>,
-    verge_config: Draft<Box<IVerge>>,
-    profiles_config: Draft<Box<IProfiles>>,
-    runtime_config: Draft<Box<IRuntime>>,
+    clash_config: Draft<IClashTemp>,
+    verge_config: Draft<IVerge>,
+    profiles_config: Draft<IProfiles>,
+    runtime_config: Draft<IRuntime>,
 }
 
 impl Config {
@@ -26,26 +25,26 @@ impl Config {
         static CONFIG: OnceCell<Config> = OnceCell::new();
 
         CONFIG.get_or_init(|| Config {
-            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())),
+            clash_config: Draft::from(IClashTemp::new()),
+            verge_config: Draft::from(IVerge::new()),
+            profiles_config: Draft::from(IProfiles::new()),
+            runtime_config: Draft::from(IRuntime::new()),
         })
     }
 
-    pub fn clash() -> Draft<Box<IClashTemp>> {
+    pub fn clash() -> Draft<IClashTemp> {
         Self::global().clash_config.clone()
     }
 
-    pub fn verge() -> Draft<Box<IVerge>> {
+    pub fn verge() -> Draft<IVerge> {
         Self::global().verge_config.clone()
     }
 
-    pub fn profiles() -> Draft<Box<IProfiles>> {
+    pub fn profiles() -> Draft<IProfiles> {
         Self::global().profiles_config.clone()
     }
 
-    pub fn runtime() -> Draft<Box<IRuntime>> {
+    pub fn runtime() -> Draft<IRuntime> {
         Self::global().runtime_config.clone()
     }
 
@@ -67,27 +66,21 @@ impl Config {
             let script_item = PrfItem::from_script(Some("Script".to_string()))?;
             Self::profiles().data().append_item(script_item.clone())?;
         }
+
         // 生成运行时配置
-        if let Err(err) = Self::generate().await {
-            logging!(error, Type::Config, true, "生成运行时配置失败: {}", err);
-        } else {
-            logging!(info, Type::Config, true, "生成运行时配置成功");
-        }
+        crate::log_err!(Self::generate().await);
 
         // 生成运行时配置文件并验证
         let config_result = Self::generate_file(ConfigType::Run);
 
         let validation_result = if config_result.is_ok() {
             // 验证配置文件
-            logging!(info, Type::Config, true, "开始验证配置");
+            println!("[首次启动] 开始验证配置");
 
             match CoreManager::global().validate_config().await {
                 Ok((is_valid, error_msg)) => {
                     if !is_valid {
-                        logging!(
-                            warn,
-                            Type::Config,
-                            true,
+                        println!(
                             "[首次启动] 配置验证失败，使用默认最小配置启动: {}",
                             error_msg
                         );
@@ -96,12 +89,12 @@ impl Config {
                             .await?;
                         Some(("config_validate::boot_error", error_msg))
                     } else {
-                        logging!(info, Type::Config, true, "配置验证成功");
+                        println!("[首次启动] 配置验证成功");
                         Some(("config_validate::success", String::new()))
                     }
                 }
                 Err(err) => {
-                    logging!(warn, Type::Config, true, "验证进程执行失败: {}", err);
+                    println!("[首次启动] 验证进程执行失败: {}", err);
                     CoreManager::global()
                         .use_default_config("config_validate::process_terminated", "")
                         .await?;
@@ -109,7 +102,7 @@ impl Config {
                 }
             }
         } else {
-            logging!(warn, Type::Config, true, "生成配置文件失败，使用默认配置");
+            println!("[首次启动] 生成配置文件失败，使用默认配置");
             CoreManager::global()
                 .use_default_config("config_validate::error", "")
                 .await?;
@@ -118,7 +111,7 @@ impl Config {
 
         // 在单独的任务中发送通知
         if let Some((msg_type, msg_content)) = validation_result {
-            AsyncHandler::spawn(move || async move {
+            tauri::async_runtime::spawn(async move {
                 sleep(Duration::from_secs(2)).await;
                 handle::Handle::notice_message(msg_type, &msg_content);
             });
@@ -149,11 +142,11 @@ impl Config {
     pub async fn generate() -> Result<()> {
         let (config, exists_keys, logs) = enhance::enhance().await;
 
-        *Config::runtime().draft() = Box::new(IRuntime {
+        *Config::runtime().draft() = IRuntime {
             config: Some(config),
             exists_keys,
             chain_logs: logs,
-        });
+        };
 
         Ok(())
     }
@@ -164,42 +157,3 @@ pub enum ConfigType {
     Run,
     Check,
 }
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::mem;
-
-    #[test]
-    fn test_prfitem_from_merge_size() {
-        let merge_item = PrfItem::from_merge(Some("Merge".to_string())).unwrap();
-        dbg!(&merge_item);
-        let prfitem_size = mem::size_of_val(&merge_item);
-        dbg!(prfitem_size);
-        // Boxed version
-        let boxed_merge_item = Box::new(merge_item);
-        let box_prfitem_size = mem::size_of_val(&boxed_merge_item);
-        dbg!(box_prfitem_size);
-        // 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]
-    fn test_draft_size_non_boxed() {
-        let draft = Draft::from(IRuntime::new());
-        let iruntime_size = std::mem::size_of_val(&draft);
-        dbg!(iruntime_size);
-        assert_eq!(iruntime_size, std::mem::size_of::<Draft<IRuntime>>());
-    }
-
-    #[test]
-    fn test_draft_size_boxed() {
-        let draft = Draft::from(Box::new(IRuntime::new()));
-        let box_iruntime_size = std::mem::size_of_val(&draft);
-        dbg!(box_iruntime_size);
-        assert_eq!(
-            box_iruntime_size,
-            std::mem::size_of::<Draft<Box<IRuntime>>>()
-        );
-    }
-}

src-tauri/src/config/draft.rs

@@ -9,21 +9,13 @@ pub struct Draft<T: Clone + ToOwned> {
 
 macro_rules! draft_define {
     ($id: ident) => {
-        impl From<$id> for Draft<$id> {
-            fn from(data: $id) -> Self {
-                Draft {
-                    inner: Arc::new(Mutex::new((data, None))),
-                }
-            }
-        }
-
-        impl Draft<Box<$id>> {
+        impl Draft<$id> {
             #[allow(unused)]
-            pub fn data(&self) -> MappedMutexGuard<Box<$id>> {
+            pub fn data(&self) -> MappedMutexGuard<$id> {
                 MutexGuard::map(self.inner.lock(), |guard| &mut guard.0)
             }
 
-            pub fn latest(&self) -> MappedMutexGuard<Box<$id>> {
+            pub fn latest(&self) -> MappedMutexGuard<$id> {
                 MutexGuard::map(self.inner.lock(), |inner| {
                     if inner.1.is_none() {
                         &mut inner.0
@@ -33,7 +25,7 @@ macro_rules! draft_define {
                 })
             }
 
-            pub fn draft(&self) -> MappedMutexGuard<Box<$id>> {
+            pub fn draft(&self) -> MappedMutexGuard<$id> {
                 MutexGuard::map(self.inner.lock(), |inner| {
                     if inner.1.is_none() {
                         inner.1 = Some(inner.0.clone());
@@ -43,7 +35,7 @@ macro_rules! draft_define {
                 })
             }
 
-            pub fn apply(&self) -> Option<Box<$id>> {
+            pub fn apply(&self) -> Option<$id> {
                 let mut inner = self.inner.lock();
 
                 match inner.1.take() {
@@ -56,14 +48,14 @@ macro_rules! draft_define {
                 }
             }
 
-            pub fn discard(&self) -> Option<Box<$id>> {
+            pub fn discard(&self) -> Option<$id> {
                 let mut inner = self.inner.lock();
                 inner.1.take()
             }
         }
 
-        impl From<Box<$id>> for Draft<Box<$id>> {
-            fn from(data: Box<$id>) -> Self {
+        impl From<$id> for Draft<$id> {
+            fn from(data: $id) -> Self {
                 Draft {
                     inner: Arc::new(Mutex::new((data, None))),
                 }
@@ -79,12 +71,12 @@ draft_define!(IRuntime);
 draft_define!(IVerge);
 
 #[test]
-fn test_draft_box() {
-    let verge = Box::new(IVerge {
+fn test_draft() {
+    let verge = IVerge {
         enable_auto_launch: Some(true),
         enable_tun_mode: Some(false),
         ..IVerge::default()
-    });
+    };
 
     let draft = Draft::from(verge);
 
@@ -94,11 +86,10 @@ fn test_draft_box() {
     assert_eq!(draft.draft().enable_auto_launch, Some(true));
     assert_eq!(draft.draft().enable_tun_mode, Some(false));
 
-    {
     let mut d = draft.draft();
     d.enable_auto_launch = Some(false);
     d.enable_tun_mode = Some(true);
-    }
+    drop(d);
 
     assert_eq!(draft.data().enable_auto_launch, Some(true));
     assert_eq!(draft.data().enable_tun_mode, Some(false));
@@ -118,17 +109,18 @@ fn test_draft_box() {
     assert_eq!(draft.draft().enable_auto_launch, Some(false));
     assert_eq!(draft.draft().enable_tun_mode, Some(true));
 
-    {
     let mut d = draft.draft();
     d.enable_auto_launch = Some(true);
-    }
+    drop(d);
 
     assert_eq!(draft.data().enable_auto_launch, Some(false));
+
     assert_eq!(draft.draft().enable_auto_launch, Some(true));
 
     assert!(draft.discard().is_some());
 
     assert_eq!(draft.data().enable_auto_launch, Some(false));
+
     assert!(draft.discard().is_none());
 
     assert_eq!(draft.draft().enable_auto_launch, Some(false));

src-tauri/src/config/prfitem.rs

@@ -1,13 +1,10 @@
-use crate::utils::{
-    dirs, help,
-    network::{NetworkManager, ProxyType},
-    tmpl,
-};
+use crate::utils::{dirs, help, resolve::VERSION, tmpl};
 use anyhow::{bail, Context, Result};
 use reqwest::StatusCode;
 use serde::{Deserialize, Serialize};
 use serde_yaml::Mapping;
-use std::{fs, time::Duration};
+use std::fs;
+use sysproxy::Sysproxy;
 
 use super::Config;
 
@@ -92,12 +89,6 @@ 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`
@@ -131,7 +122,6 @@ 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),
@@ -250,40 +240,59 @@ 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();
 
-        // 选择代理类型
-        let proxy_type = if self_proxy {
-            ProxyType::Localhost
-        } else if with_proxy {
-            ProxyType::System
-        } else {
-            ProxyType::None
-        };
+        // 使用软件自己的代理
+        if self_proxy {
+            let port = Config::verge()
+                .latest()
+                .verge_mixed_port
+                .unwrap_or(Config::clash().data().get_mixed_port());
 
-        // 使用网络管理器发送请求
-        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 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(),
         };
 
+        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 status_code = resp.status();
         if !StatusCode::is_success(&status_code) {
             bail!("failed to fetch remote profile with status {status_code}")

src-tauri/src/config/profiles.rs

@@ -3,7 +3,7 @@ use crate::utils::{dirs, help};
 use anyhow::{bail, Context, Result};
 use serde::{Deserialize, Serialize};
 use serde_yaml::Mapping;
-use std::{collections::HashSet, fs, io::Write};
+use std::{fs, io::Write};
 
 /// Define the `profiles.yaml` schema
 #[derive(Default, Debug, Clone, Deserialize, Serialize)]
@@ -15,14 +15,6 @@ pub struct IProfiles {
     pub items: Option<Vec<PrfItem>>,
 }
 
-/// 清理结果
-#[derive(Debug, Clone)]
-pub struct CleanupResult {
-    pub total_files: usize,
-    pub deleted_files: Vec<String>,
-    pub failed_deletions: Vec<String>,
-}
-
 macro_rules! patch {
     ($lv: expr, $rv: expr, $key: tt) => {
         if ($rv.$key).is_some() {
@@ -493,197 +485,4 @@ impl IProfiles {
                 .collect()
         })
     }
-
-    /// 以 app 中的 profile 列表为准，删除不再需要的文件
-    pub fn cleanup_orphaned_files(&self) -> Result<CleanupResult> {
-        let profiles_dir = dirs::app_profiles_dir()?;
-
-        if !profiles_dir.exists() {
-            return Ok(CleanupResult {
-                total_files: 0,
-                deleted_files: vec![],
-                failed_deletions: vec![],
-            });
-        }
-
-        // 获取所有 active profile 的文件名集合
-        let active_files = self.get_all_active_files();
-
-        // 添加全局扩展配置文件到保护列表
-        let protected_files = self.get_protected_global_files();
-
-        // 扫描 profiles 目录下的所有文件
-        let mut total_files = 0;
-        let mut deleted_files = vec![];
-        let mut failed_deletions = vec![];
-
-        for entry in std::fs::read_dir(&profiles_dir)? {
-            let entry = entry?;
-            let path = entry.path();
-
-            if !path.is_file() {
-                continue;
-            }
-
-            total_files += 1;
-
-            if let Some(file_name) = path.file_name().and_then(|n| n.to_str()) {
-                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(())
-            }
-        }
-    }
 }

src-tauri/src/config/verge.rs

@@ -1,7 +1,6 @@
 use crate::{
     config::{deserialize_encrypted, serialize_encrypted, DEFAULT_PAC},
-    logging,
-    utils::{dirs, help, i18n, logging::Type},
+    utils::{dirs, help, i18n},
 };
 use anyhow::Result;
 use log::LevelFilter;
@@ -89,9 +88,6 @@ 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>,
 
@@ -135,7 +131,7 @@ pub struct IVerge {
     pub test_list: Option<Vec<IVergeTestItem>>,
 
     /// 日志清理
-    /// 0: 不清理; 1: 1天；2: 7天; 3: 30天; 4: 90天
+    /// 0: 不清理; 1: 7天; 2: 30天; 3: 90天
     pub auto_log_clean: Option<i32>,
 
     /// 是否启用随机端口
@@ -193,19 +189,11 @@ pub struct IVerge {
 
     pub enable_tray_speed: Option<bool>,
 
-    pub enable_tray_icon: Option<bool>,
-
     /// 自动进入轻量模式
     pub enable_auto_light_weight_mode: Option<bool>,
 
     /// 自动进入轻量模式的延迟（分钟）
     pub auto_light_weight_minutes: Option<u64>,
-
-    /// 启用代理页面自动滚动
-    pub enable_hover_jump_navigator: Option<bool>,
-
-    /// 服务状态跟踪
-    pub service_state: Option<crate::core::service::ServiceState>,
 }
 
 #[derive(Default, Debug, Clone, Deserialize, Serialize)]
@@ -233,93 +221,6 @@ 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() = 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"))
@@ -366,11 +267,9 @@ impl IVerge {
             tun_tray_icon: Some(false),
             enable_auto_launch: Some(false),
             enable_silent_start: Some(false),
-            enable_hover_jump_navigator: Some(true),
             enable_system_proxy: Some(false),
             proxy_auto_config: Some(false),
             pac_file_content: Some(DEFAULT_PAC.into()),
-            proxy_host: Some("127.0.0.1".into()),
             enable_random_port: Some(false),
             #[cfg(not(target_os = "windows"))]
             verge_redir_port: Some(7895),
@@ -395,14 +294,12 @@ impl IVerge {
             webdav_url: None,
             webdav_username: None,
             webdav_password: None,
-            enable_tray_speed: Some(false),
-            enable_tray_icon: Some(true),
+            enable_tray_speed: Some(true),
             enable_global_hotkey: Some(true),
             enable_auto_light_weight_mode: Some(false),
             auto_light_weight_minutes: Some(10),
-            enable_dns_settings: Some(false),
+            enable_dns_settings: Some(true),
             home_cards: None,
-            service_state: None,
             ..Self::default()
         }
     }
@@ -443,7 +340,6 @@ impl IVerge {
         patch!(enable_tun_mode);
         patch!(enable_auto_launch);
         patch!(enable_silent_start);
-        patch!(enable_hover_jump_navigator);
         patch!(enable_random_port);
         #[cfg(not(target_os = "windows"))]
         patch!(verge_redir_port);
@@ -465,7 +361,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);
@@ -485,12 +381,10 @@ impl IVerge {
         patch!(webdav_username);
         patch!(webdav_password);
         patch!(enable_tray_speed);
-        patch!(enable_tray_icon);
         patch!(enable_auto_light_weight_mode);
         patch!(auto_light_weight_minutes);
         patch!(enable_dns_settings);
         patch!(home_cards);
-        patch!(service_state);
     }
 
     /// 在初始化前尝试拿到单例端口的值
@@ -549,7 +443,6 @@ 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>,
@@ -580,19 +473,14 @@ pub struct IVergeResponse {
     pub webdav_username: Option<String>,
     pub webdav_password: Option<String>,
     pub enable_tray_speed: Option<bool>,
-    pub enable_tray_icon: Option<bool>,
     pub enable_auto_light_weight_mode: Option<bool>,
     pub auto_light_weight_minutes: Option<u64>,
     pub enable_dns_settings: Option<bool>,
     pub home_cards: Option<serde_json::Value>,
-    pub enable_hover_jump_navigator: 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,
@@ -621,10 +509,9 @@ 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: Some(valid_clash_core),
+            clash_core: verge.clash_core,
             hotkeys: verge.hotkeys,
             auto_close_connection: verge.auto_close_connection,
             auto_check_update: verge.auto_check_update,
@@ -652,13 +539,10 @@ impl From<IVerge> for IVergeResponse {
             webdav_username: verge.webdav_username,
             webdav_password: verge.webdav_password,
             enable_tray_speed: verge.enable_tray_speed,
-            enable_tray_icon: verge.enable_tray_icon,
             enable_auto_light_weight_mode: verge.enable_auto_light_weight_mode,
             auto_light_weight_minutes: verge.auto_light_weight_minutes,
             enable_dns_settings: verge.enable_dns_settings,
             home_cards: verge.home_cards,
-            enable_hover_jump_navigator: verge.enable_hover_jump_navigator,
-            service_state: verge.service_state,
         }
     }
 }

src-tauri/src/core/backup.rs

@@ -15,9 +15,6 @@ 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 秒
@@ -108,18 +105,6 @@ impl WebDavClient {
                 reqwest::Client::builder()
                     .danger_accept_invalid_certs(true)
                     .timeout(Duration::from_secs(op.timeout()))
-                    .user_agent(format!(
-                        "clash-verge/{} ({} WebDAV-Client)",
-                        APP_VERSION, OS
-                    ))
-                    .redirect(reqwest::redirect::Policy::custom(|attempt| {
-                        // 允许所有请求类型的重定向，包括PUT
-                        if attempt.previous().len() >= 5 {
-                            attempt.error("重定向次数过多")
-                        } else {
-                            attempt.follow()
-                        }
-                    }))
                     .build()
                     .unwrap(),
             )
@@ -127,13 +112,12 @@ impl WebDavClient {
             .set_auth(reqwest_dav::Auth::Basic(config.username, config.password))
             .build()?;
 
-        // 尝试检查目录是否存在，如果不存在尝试创建，但创建失败不报错
-        if client
+        // 确保备份目录存在
+        let list_result = client
             .list(dirs::BACKUP_DIR, reqwest_dav::Depth::Number(0))
-            .await
-            .is_err()
-        {
-            let _ = client.mkcol(dirs::BACKUP_DIR).await;
+            .await;
+        if list_result.is_err() {
+            client.mkcol(dirs::BACKUP_DIR).await?;
         }
 
         // 缓存客户端
@@ -153,43 +137,11 @@ 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 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??;
+        let fut = client.put(webdav_path.as_ref(), fs::read(file_path)?);
+        timeout(Duration::from_secs(TIMEOUT_UPLOAD), fut).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> {
         let client = self.get_client(Operation::Download).await?;
         let path = format!("{}/{}", dirs::BACKUP_DIR, filename);

src-tauri/src/core/handle.rs

@@ -1,302 +1,39 @@
+use crate::log_err;
 use once_cell::sync::OnceCell;
 use parking_lot::RwLock;
-use std::{
-    sync::{
-        atomic::{AtomicU64, Ordering},
-        mpsc, Arc,
-    },
-    thread,
-    time::{Duration, Instant},
-};
+use std::sync::Arc;
 use tauri::{AppHandle, Emitter, Manager, WebviewWindow};
+use tauri_plugin_shell::process::CommandChild;
 
-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)]
-struct ErrorMessage {
-    status: String,
-    message: String,
-}
-
-/// 全局前端通知系统
-#[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();
-
-        self.worker_handle = Some(
-            thread::Builder::new()
-                .name("frontend-notifier".into())
-                .spawn(move || {
-                    let handle = Handle::global();
-
-                    while !handle.is_exiting() {
-                        match rx.recv_timeout(Duration::from_millis(100)) {
-                            Ok(event) => {
-                                let system_guard = handle.notification_system.read();
-                                if system_guard.as_ref().is_none() {
-                                    log::warn!("NotificationSystem not found in handle while processing event.");
-                                    continue;
-                                }
-                                let system = system_guard.as_ref().unwrap();
-
-                                let is_emergency = *system.emergency_mode.read();
-
-                                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 errors, entering emergency mode",
-                                                        EMIT_ERROR_THRESHOLD
-                                                    );
-                                                    *system.emergency_mode.write() = true;
-                                                }
-                                            }
-                                        }
-                                    } else {
-                                        system.stats.total_errors.fetch_add(1, Ordering::SeqCst);
-                                        *system.stats.last_error_time.write() = Some(Instant::now());
-                                        log::warn!("Skipped emitting event due to payload serialization error for {}", event_name_str);
-                                    }
-                                } else {
-                                    log::warn!("No window found, skipping event emit.");
-                                }
-                                thread::sleep(Duration::from_millis(20));
-                            }
-                            Err(mpsc::RecvTimeoutError::Timeout) => {
-                                continue;
-                            }
-                            Err(mpsc::RecvTimeoutError::Disconnected) => {
-                                log::info!(
-                                    "Notification channel disconnected, exiting worker thread"
-                                );
-                                break;
-                            }
-                        }
-                    }
-
-                    log::info!("Notification worker thread exiting");
-                })
-                .expect("Failed to start notification worker thread"),
-        );
-    }
-
-    /// 发送事件到队列
-    fn send_event(&self, event: FrontendEvent) -> bool {
-        if *self.emergency_mode.read() {
-            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)]
+#[derive(Debug, Default, 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 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()))),
-        }
-    }
+    pub core_process: Arc<RwLock<Option<CommandChild>>>,
 }
 
 impl Handle {
     pub fn global() -> &'static Handle {
         static HANDLE: OnceCell<Handle> = OnceCell::new();
-        HANDLE.get_or_init(Handle::default)
+
+        HANDLE.get_or_init(|| Handle {
+            app_handle: Arc::new(RwLock::new(None)),
+            is_exiting: Arc::new(RwLock::new(false)),
+            core_process: Arc::new(RwLock::new(None)),
+        })
     }
 
     pub fn init(&self, app_handle: &AppHandle) {
-        {
         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> {
         self.app_handle.read().clone()
     }
 
     pub fn get_window(&self) -> Option<WebviewWindow> {
-        let app_handle = self.app_handle()?;
+        let app_handle = self.app_handle().unwrap();
         let window: Option<WebviewWindow> = app_handle.get_webview_window("main");
         if window.is_none() {
             log::debug!(target:"app", "main window not found");
@@ -305,213 +42,48 @@ impl Handle {
     }
 
     pub fn refresh_clash() {
-        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);
+        if let Some(window) = Self::global().get_window() {
+            log_err!(window.emit("verge://refresh-clash-config", "yes"));
         }
     }
 
     pub fn refresh_verge() {
-        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);
+        if let Some(window) = Self::global().get_window() {
+            log_err!(window.emit("verge://refresh-verge-config", "yes"));
         }
     }
 
-    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() {
+            log_err!(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,
-                Type::Frontend,
-                true,
-                "启动过程中发现错误，加入消息队列: {} - {}",
-                status_str,
-                msg_str
-            );
-
-            let mut errors = handle.startup_errors.write();
-            errors.push(ErrorMessage {
-                status: status_str,
-                message: msg_str,
-            });
-            return;
-        }
-
-        if 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();
-            *completed = true;
-        }
-
-        self.send_startup_errors();
-    }
-
-    /// 发送启动时累积的所有错误消息
-    fn send_startup_errors(&self) {
-        let errors = {
-            let mut errors = self.startup_errors.write();
-            std::mem::take(&mut *errors)
-        };
-
-        if errors.is_empty() {
-            return;
-        }
-
-        logging!(
-            info,
-            Type::Frontend,
-            true,
-            "发送{}条启动时累积的错误消息",
-            errors.len()
-        );
-
-        // 启动单独线程处理启动错误，避免阻塞主线程
-        let thread_result = thread::Builder::new()
-            .name("startup-errors-sender".into())
-            .spawn(move || {
-                thread::sleep(Duration::from_secs(2));
-
-                let handle = Handle::global();
-                if handle.is_exiting() {
-                    return;
-                }
-
-                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);
+        if let Some(window) = Self::global().get_window() {
+            log_err!(window.emit("verge://notice-message", (status.into(), msg.into())));
         }
     }
 
     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 set_core_process(&self, process: CommandChild) {
+        let mut core_process = self.core_process.write();
+        *core_process = Some(process);
+    }
+
+    pub fn take_core_process(&self) -> Option<CommandChild> {
+        let mut core_process = self.core_process.write();
+        core_process.take()
+    }
+
+    /// 检查是否有运行中的核心进程
+    pub fn has_core_process(&self) -> bool {
+        self.core_process.read().is_some()
     }
 
     pub fn is_exiting(&self) -> bool {

src-tauri/src/core/hotkey.rs

@@ -1,16 +1,9 @@
-use crate::{
-    config::Config,
-    core::handle,
-    feat, logging, logging_error,
-    module::lightweight::entry_lightweight_mode,
-    process::AsyncHandler,
-    utils::{logging::Type, resolve},
-};
+use crate::{config::Config, core::handle, feat, log_err, utils::resolve};
 use anyhow::{bail, Result};
 use once_cell::sync::OnceCell;
 use parking_lot::Mutex;
 use std::{collections::HashMap, sync::Arc};
-use tauri::Manager;
+use tauri::{async_runtime, Manager};
 use tauri_plugin_global_shortcut::{Code, GlobalShortcutExt, ShortcutState};
 
 pub struct Hotkey {
@@ -30,27 +23,22 @@ impl Hotkey {
         let verge = Config::verge();
         let enable_global_hotkey = verge.latest().enable_global_hotkey.unwrap_or(true);
 
-        logging!(
-            debug,
-            Type::Hotkey,
-            true,
-            "Initializing global hotkeys: {}",
+        println!(
+            "Initializing hotkeys, global hotkey enabled: {}",
             enable_global_hotkey
         );
+        log::info!(target: "app", "Initializing hotkeys, global hotkey enabled: {}", enable_global_hotkey);
 
         // 如果全局热键被禁用，则不注册热键
         if !enable_global_hotkey {
+            println!("Global hotkey is disabled, skipping registration");
+            log::info!(target: "app", "Global hotkey is disabled, skipping registration");
             return Ok(());
         }
 
         if let Some(hotkeys) = verge.latest().hotkeys.as_ref() {
-            logging!(
-                debug,
-                Type::Hotkey,
-                true,
-                "Has {} hotkeys need to register",
-                hotkeys.len()
-            );
+            println!("Found {} hotkeys to register", hotkeys.len());
+            log::info!(target: "app", "Found {} hotkeys to register", hotkeys.len());
 
             for hotkey in hotkeys.iter() {
                 let mut iter = hotkey.split(',');
@@ -59,51 +47,28 @@ impl Hotkey {
 
                 match (key, func) {
                     (Some(key), Some(func)) => {
-                        logging!(
-                            debug,
-                            Type::Hotkey,
-                            true,
-                            "Registering hotkey: {} -> {}",
-                            key,
-                            func
-                        );
+                        println!("Registering hotkey: {} -> {}", key, func);
+                        log::info!(target: "app", "Registering hotkey: {} -> {}", key, func);
                         if let Err(e) = self.register(key, func) {
-                            logging!(
-                                error,
-                                Type::Hotkey,
-                                true,
-                                "Failed to register hotkey {} -> {}: {:?}",
-                                key,
-                                func,
-                                e
-                            );
+                            println!("Failed to register hotkey {} -> {}: {:?}", key, func, e);
+                            log::error!(target: "app", "Failed to register hotkey {} -> {}: {:?}", key, func, e);
                         } else {
-                            logging!(
-                                debug,
-                                Type::Hotkey,
-                                "Successfully registered hotkey {} -> {}",
-                                key,
-                                func
-                            );
+                            println!("Successfully registered hotkey {} -> {}", key, func);
+                            log::info!(target: "app", "Successfully registered hotkey {} -> {}", key, func);
                         }
                     }
                     _ => {
                         let key = key.unwrap_or("None");
                         let func = func.unwrap_or("None");
-                        logging!(
-                            error,
-                            Type::Hotkey,
-                            true,
-                            "Invalid hotkey configuration: `{}`:`{}`",
-                            key,
-                            func
-                        );
+                        println!("Invalid hotkey configuration: `{key}`:`{func}`");
+                        log::error!(target: "app", "Invalid hotkey configuration: `{key}`:`{func}`");
                     }
                 }
             }
             self.current.lock().clone_from(hotkeys);
         } else {
-            logging!(debug, Type::Hotkey, "No hotkeys configured");
+            println!("No hotkeys configured");
+            log::info!(target: "app", "No hotkeys configured");
         }
 
         Ok(())
@@ -120,115 +85,61 @@ impl Hotkey {
         let app_handle = handle::Handle::global().app_handle().unwrap();
         let manager = app_handle.global_shortcut();
 
-        logging!(
-            debug,
-            Type::Hotkey,
+        println!(
             "Attempting to register hotkey: {} for function: {}",
-            hotkey,
-            func
+            hotkey, func
         );
+        log::info!(target: "app", "Attempting to register hotkey: {} for function: {}", hotkey, func);
 
         if manager.is_registered(hotkey) {
-            logging!(
-                debug,
-                Type::Hotkey,
+            println!(
                 "Hotkey {} was already registered, unregistering first",
                 hotkey
             );
+            log::info!(target: "app", "Hotkey {} was already registered, unregistering first", hotkey);
             manager.unregister(hotkey)?;
         }
 
         let f = match func.trim() {
             "open_or_close_dashboard" => {
-                logging!(
-                    debug,
-                    Type::Hotkey,
-                    "Registering open_or_close_dashboard function"
-                );
+                println!("Registering open_or_close_dashboard function");
+                log::info!(target: "app", "Registering open_or_close_dashboard function");
                 || {
-                    logging!(
-                        debug,
-                        Type::Hotkey,
-                        true,
-                        "=== Hotkey Dashboard Window Operation Start ==="
-                    );
+                    println!("=== Hotkey Dashboard Window Operation Start ===");
+                    log::info!(target: "app", "=== Hotkey Dashboard Window Operation Start ===");
 
-                    // 检查是否在轻量模式下，如果是，需要同步处理
-                    if crate::module::lightweight::is_in_lightweight_mode() {
-                        logging!(
-                            info,
-                            Type::Hotkey,
-                            true,
-                            "In lightweight mode, calling open_or_close_dashboard directly"
-                        );
-                        crate::feat::open_or_close_dashboard();
-                    } else {
-                        AsyncHandler::spawn(move || async move {
-                            logging!(
-                                debug,
-                                Type::Hotkey,
-                                true,
-                                "Toggle dashboard window visibility (async)"
-                            );
+                    // 使用 spawn_blocking 来确保在正确的线程上执行
+                    async_runtime::spawn_blocking(|| {
+                        println!("Toggle dashboard window visibility");
+                        log::info!(target: "app", "Toggle dashboard window visibility");
 
                         // 检查窗口是否存在
                         if let Some(window) = handle::Handle::global().get_window() {
-                                // 如果窗口可见，则隐藏
-                                match window.is_visible() {
-                                    Ok(visible) => {
-                                        if visible {
-                                            logging!(
-                                                info,
-                                                Type::Window,
-                                                true,
-                                                "Window is visible, hiding it"
-                                            );
+                            // 如果窗口可见，则隐藏它
+                            if window.is_visible().unwrap_or(false) {
+                                println!("Window is visible, hiding it");
+                                log::info!(target: "app", "Window is visible, hiding it");
                                 let _ = window.hide();
                             } else {
-                                            // 如果窗口不可见，则显示
-                                            logging!(
-                                                info,
-                                                Type::Window,
-                                                true,
-                                                "Window is hidden, showing it"
-                                            );
+                                // 如果窗口不可见，则显示它
+                                println!("Window is hidden, showing it");
+                                log::info!(target: "app", "Window is hidden, showing it");
                                 if window.is_minimized().unwrap_or(false) {
                                     let _ = window.unminimize();
                                 }
                                 let _ = window.show();
                                 let _ = window.set_focus();
                             }
-                                    }
-                                    Err(e) => {
-                                        logging!(
-                                            warn,
-                                            Type::Window,
-                                            true,
-                                            "Failed to check window visibility: {}",
-                                            e
-                                        );
-                                        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);
+                            println!("Window does not exist, creating a new one");
+                            log::info!(target: "app", "Window does not exist, creating a new one");
+                            resolve::create_window();
                         }
                     });
-                    }
 
-                    logging!(
-                        debug,
-                        Type::Hotkey,
-                        "=== Hotkey Dashboard Window Operation End ==="
-                    );
+                    println!("=== Hotkey Dashboard Window Operation End ===");
+                    log::info!(target: "app", "=== Hotkey Dashboard Window Operation End ===");
                 }
             }
             "clash_mode_rule" => || feat::change_clash_mode("rule".into()),
@@ -236,13 +147,13 @@ impl Hotkey {
             "clash_mode_direct" => || feat::change_clash_mode("direct".into()),
             "toggle_system_proxy" => || feat::toggle_system_proxy(),
             "toggle_tun_mode" => || feat::toggle_tun_mode(None),
-            "entry_lightweight_mode" => || entry_lightweight_mode(),
-            "quit" => || feat::quit(),
+            "quit" => || feat::quit(Some(0)),
             #[cfg(target_os = "macos")]
             "hide" => || feat::hide(),
 
             _ => {
-                logging!(error, Type::Hotkey, "Invalid function: {}", func);
+                println!("Invalid function: {}", func);
+                log::error!(target: "app", "Invalid function: {}", func);
                 bail!("invalid function \"{func}\"");
             }
         };
@@ -251,18 +162,21 @@ impl Hotkey {
 
         let _ = manager.on_shortcut(hotkey, move |app_handle, hotkey, event| {
             if event.state == ShortcutState::Pressed {
-                logging!(debug, Type::Hotkey, "Hotkey pressed: {:?}", hotkey);
+                println!("Hotkey pressed: {:?}", hotkey);
+                log::info!(target: "app", "Hotkey pressed: {:?}", hotkey);
 
                 if hotkey.key == Code::KeyQ && is_quit {
                     if let Some(window) = app_handle.get_webview_window("main") {
                         if window.is_focused().unwrap_or(false) {
-                            logging!(debug, Type::Hotkey, "Executing quit function");
+                            println!("Executing quit function");
+                            log::info!(target: "app", "Executing quit function");
                             f();
                         }
                     }
                 } else {
                     // 直接执行函数，不做任何状态检查
-                    logging!(debug, Type::Hotkey, "Executing function directly");
+                    println!("Executing function directly");
+                    log::info!(target: "app", "Executing function directly");
 
                     // 获取全局热键状态
                     let is_enable_global_hotkey = Config::verge()
@@ -272,11 +186,10 @@ impl Hotkey {
 
                     if is_enable_global_hotkey {
                         f();
-                    } else {
-                        use crate::utils::window_manager::WindowManager;
+                    } else if let Some(window) = app_handle.get_webview_window("main") {
                         // 非轻量模式且未启用全局热键时，只在窗口可见且有焦点的情况下响应热键
-                        let is_visible = WindowManager::is_main_window_visible();
-                        let is_focused = WindowManager::is_main_window_focused();
+                        let is_visible = window.is_visible().unwrap_or(false);
+                        let is_focused = window.is_focused().unwrap_or(false);
 
                         if is_focused && is_visible {
                             f();
@@ -286,13 +199,8 @@ impl Hotkey {
             }
         });
 
-        logging!(
-            debug,
-            Type::Hotkey,
-            "Successfully registered hotkey {} for {}",
-            hotkey,
-            func
-        );
+        println!("Successfully registered hotkey {} for {}", hotkey, func);
+        log::info!(target: "app", "Successfully registered hotkey {} for {}", hotkey, func);
         Ok(())
     }
 
@@ -300,7 +208,7 @@ impl Hotkey {
         let app_handle = handle::Handle::global().app_handle().unwrap();
         let manager = app_handle.global_shortcut();
         manager.unregister(hotkey)?;
-        logging!(debug, Type::Hotkey, "Unregister hotkey {}", hotkey);
+        log::debug!(target: "app", "unregister hotkey {hotkey}");
         Ok(())
     }
 
@@ -316,7 +224,7 @@ impl Hotkey {
         });
 
         add.iter().for_each(|(key, func)| {
-            logging_error!(Type::Hotkey, self.register(key, func));
+            log_err!(self.register(key, func));
         });
 
         *current = new_hotkeys;
@@ -331,9 +239,9 @@ impl Hotkey {
             let func = iter.next();
             let key = iter.next();
 
-            if let (Some(func), Some(key)) = (func, key) {
-                let func = func.trim();
-                let key = key.trim();
+            if func.is_some() && key.is_some() {
+                let func = func.unwrap().trim();
+                let key = key.unwrap().trim();
                 map.insert(key, func);
             }
         });
@@ -373,13 +281,7 @@ impl Drop for Hotkey {
     fn drop(&mut self) {
         let app_handle = handle::Handle::global().app_handle().unwrap();
         if let Err(e) = app_handle.global_shortcut().unregister_all() {
-            logging!(
-                error,
-                Type::Hotkey,
-                true,
-                "Error unregistering all hotkeys: {:?}",
-                e
-            );
+            log::error!(target:"app", "Error unregistering all hotkeys: {:?}", e);
         }
     }
 }

src-tauri/src/core/mod.rs

@@ -4,10 +4,9 @@ mod core;
 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::*, timer::Timer};
+pub use self::core::*;

src-tauri/src/core/service_ipc.rs

@@ -1,340 +0,0 @@
-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 = tokio::task::spawn_blocking(move || -> Result<IpcResponse> {
-        let c_pipe_name = match CString::new(IPC_SOCKET_NAME) {
-            Ok(name) => name,
-            Err(e) => {
-                logging!(error, Type::Service, true, "创建CString失败: {}", e);
-                return Err(anyhow::anyhow!("创建CString失败: {}", e));
-            }
-        };
-
-        let handle = unsafe {
-            CreateFileA(
-                c_pipe_name.as_ptr(),
-                GENERIC_READ | GENERIC_WRITE,
-                FILE_SHARE_READ | FILE_SHARE_WRITE,
-                ptr::null_mut(),
-                OPEN_EXISTING,
-                0,
-                ptr::null_mut(),
-            )
-        };
-
-        if handle == INVALID_HANDLE_VALUE {
-            let error = std::io::Error::last_os_error();
-            logging!(
-                error,
-                Type::Service,
-                true,
-                "连接到服务命名管道失败: {}",
-                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)
-}

src-tauri/src/core/sysopt.rs

@@ -1,11 +1,7 @@
-#[cfg(target_os = "windows")]
-use crate::utils::autostart as startup_shortcut;
 use crate::{
     config::{Config, IVerge},
     core::handle::Handle,
-    logging, logging_error,
-    process::AsyncHandler,
-    utils::logging::Type,
+    log_err,
 };
 use anyhow::Result;
 use once_cell::sync::OnceCell;
@@ -19,6 +15,8 @@ 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>>,
 }
@@ -59,6 +57,7 @@ impl Sysopt {
         SYSOPT.get_or_init(|| 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()),
         })
     }
@@ -78,16 +77,12 @@ impl Sysopt {
             .unwrap_or(Config::clash().data().get_mixed_port());
         let pac_port = IVerge::get_singleton_port();
 
-        let (sys_enable, pac_enable, proxy_host) = {
+        let (sys_enable, pac_enable) = {
             let verge = Config::verge();
             let verge = verge.latest();
             (
                 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")),
             )
         };
 
@@ -95,13 +90,13 @@ impl Sysopt {
         {
             let mut sys = Sysproxy {
                 enable: false,
-                host: proxy_host.clone(),
+                host: String::from("127.0.0.1"),
                 port,
                 bypass: get_bypass(),
             };
             let mut auto = Autoproxy {
                 enable: false,
-                url: format!("http://{}:{}/commands/pac", proxy_host, pac_port),
+                url: format!("http://127.0.0.1:{pac_port}/commands/pac"),
             };
 
             if !sys_enable {
@@ -145,7 +140,7 @@ impl Sysopt {
 
             let shell = app_handle.shell();
             let output = if pac_enable {
-                let address = format!("http://{}:{}/commands/pac", proxy_host, pac_port);
+                let address = format!("http://{}:{}/commands/pac", "127.0.0.1", pac_port);
                 let output = shell
                     .command(sysproxy_exe.as_path().to_str().unwrap())
                     .args(["pac", address.as_str()])
@@ -154,7 +149,7 @@ impl Sysopt {
                     .unwrap();
                 output
             } else {
-                let address = format!("{}:{}", proxy_host, port);
+                let address = format!("{}:{}", "127.0.0.1", port);
                 let bypass = get_bypass();
                 let output = shell
                     .command(sysproxy_exe.as_path().to_str().unwrap())
@@ -220,67 +215,40 @@ impl Sysopt {
 
     /// update the startup
     pub fn update_launch(&self) -> Result<()> {
-        let enable_auto_launch = { Config::verge().latest().enable_auto_launch };
-        let is_enable = enable_auto_launch.unwrap_or(false);
-        logging!(info, true, "Setting auto-launch state to: {:?}", is_enable);
+        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();
         
-        // 首先尝试使用快捷方式方法
-        #[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(());
-            }
-        }
+        log::info!(target: "app", "Setting auto launch to: {}", enable);
         
-        #[cfg(not(target_os = "windows"))]
-        {
-            // 非Windows平台使用原来的方法
-            self.try_original_autostart_method(is_enable);
+        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");
                 }
+                log_err!(result)
+            },
+            false => {
+                let result = autostart_manager.disable();
+                if let Err(ref e) = result {
+                    log::error!(target: "app", "Failed to disable auto launch: {}", e);
+                } else {
+                    log::info!(target: "app", "Auto launch disabled successfully");
+                }
+                log_err!(result)
+            },
+        };
 
         Ok(())
     }
 
-    /// 尝试使用原来的自启动方法
-    fn try_original_autostart_method(&self, is_enable: bool) {
-        let app_handle = Handle::global().app_handle().unwrap();
-        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> {
-        // 首先尝试检查快捷方式是否存在
-        #[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().unwrap();
         let autostart_manager = app_handle.autolaunch();
         
@@ -288,7 +256,7 @@ impl Sysopt {
             Ok(status) => {
                 log::info!(target: "app", "Auto launch status: {}", status);
                 Ok(status)
-            }
+            },
             Err(e) => {
                 log::error!(target: "app", "Failed to get auto launch status: {}", e);
                 Err(anyhow::anyhow!("Failed to get auto launch status: {}", e))
@@ -299,14 +267,14 @@ impl Sysopt {
     fn guard_proxy(&self) {
         let _lock = self.guard_state.lock();
 
-        AsyncHandler::spawn(move || async move {
+        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, proxy_host) = {
+                let (enable, guard, guard_duration, pac) = {
                     let verge = Config::verge();
                     let verge = verge.latest();
                     (
@@ -314,10 +282,6 @@ impl Sysopt {
                         verge.enable_proxy_guard.unwrap_or(false),
                         verge.proxy_guard_duration.unwrap_or(10),
                         verge.proxy_auto_config.unwrap_or(false),
-                        verge
-                            .proxy_host
-                            .clone()
-                            .unwrap_or_else(|| String::from("127.0.0.1")),
                     )
                 };
 
@@ -331,36 +295,45 @@ impl Sysopt {
 
                 log::debug!(target: "app", "try to guard the system proxy");
 
-                // 获取期望的代理端口
-                let port = Config::verge()
+                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();
-                let bypass = get_bypass();
-
-                // 检查系统代理配置
-                if pac {
-                    // 检查 PAC 代理设置
-                    let expected_url = format!("http://{}:{}/commands/pac", proxy_host, pac_port);
-                    let autoproxy = match Autoproxy::get_auto_proxy() {
-                        Ok(ap) => ap,
-                        Err(e) => {
-                            log::error!(target: "app", "failed to get the auto proxy: {}", e);
-                            continue;
-                        }
+                        .unwrap_or(Config::clash().data().get_mixed_port())
                 };
-
-                    // 检查自动代理是否启用且URL是否正确
-                    if !autoproxy.enable || autoproxy.url != expected_url {
-                        log::info!(target: "app", "auto proxy settings changed, restoring...");
+                let pac_port = IVerge::get_singleton_port();
                 #[cfg(not(target_os = "windows"))]
                 {
-                            let new_autoproxy = Autoproxy {
+                    if pac {
+                        let autoproxy = Autoproxy {
                             enable: true,
-                                url: expected_url,
+                            url: format!("http://127.0.0.1:{pac_port}/commands/pac"),
                         };
-                            logging_error!(Type::System, true, new_autoproxy.set_auto_proxy());
+                        log_err!(autoproxy.set_auto_proxy());
+                    } else {
+                        let sysproxy = Sysproxy {
+                            enable: true,
+                            host: "127.0.0.1".into(),
+                            port,
+                            bypass: get_bypass(),
+                        };
+
+                        log_err!(sysproxy.set_system_proxy());
+                    }
                 }
 
                 #[cfg(target_os = "windows")]
@@ -369,92 +342,38 @@ impl Sysopt {
                     use tauri_plugin_shell::ShellExt;
 
                     let app_handle = Handle::global().app_handle().unwrap();
-                            let binary_path = match dirs::service_path() {
-                                Ok(path) => path,
-                                Err(e) => {
-                                    log::error!(target: "app", "failed to get service path: {}", e);
-                                    continue;
-                                }
-                            };
 
+                    let binary_path = dirs::service_path().unwrap();
                     let sysproxy_exe = binary_path.with_file_name("sysproxy.exe");
                     if !sysproxy_exe.exists() {
-                                log::error!(target: "app", "sysproxy.exe not found");
-                                continue;
+                        break;
                     }
 
                     let shell = app_handle.shell();
-                            let output = 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", expected_url.as_str()])
+                            .args(["pac", address.as_str()])
                             .output()
                             .await
-                                .unwrap();
-
-                            if !output.status.success() {
-                                log::error!(target: "app", "failed to set auto proxy");
-                            }
-                        }
-                    }
+                            .unwrap()
                     } else {
-                    // 检查常规系统代理设置
-                    let sysproxy = match Sysproxy::get_system_proxy() {
-                        Ok(sp) => sp,
-                        Err(e) => {
-                            log::error!(target: "app", "failed to get the system proxy: {}", e);
-                            continue;
-                        }
-                    };
+                        let address = format!("{}:{}", "127.0.0.1", port);
+                        let bypass = get_bypass();
 
-                    // 检查系统代理是否启用且配置是否匹配
-                    if !sysproxy.enable || sysproxy.host != proxy_host || sysproxy.port != port {
-                        log::info!(target: "app", "system proxy settings changed, restoring...");
-                        #[cfg(not(target_os = "windows"))]
-                        {
-                            let new_sysproxy = Sysproxy {
-                                enable: true,
-                                host: proxy_host.clone(),
-                                port,
-                                bypass: bypass.clone(),
-                            };
-                            logging_error!(Type::System, true, new_sysproxy.set_system_proxy());
-                        }
-
-                        #[cfg(target_os = "windows")]
-                        {
-                            use crate::{core::handle::Handle, utils::dirs};
-                            use tauri_plugin_shell::ShellExt;
-
-                            let app_handle = Handle::global().app_handle().unwrap();
-                            let binary_path = match dirs::service_path() {
-                                Ok(path) => path,
-                                Err(e) => {
-                                    log::error!(target: "app", "failed to get service path: {}", e);
-                                    continue;
-                                }
-                            };
-
-                            let sysproxy_exe = binary_path.with_file_name("sysproxy.exe");
-                            if !sysproxy_exe.exists() {
-                                log::error!(target: "app", "sysproxy.exe not found");
-                                continue;
-                            }
-
-                            let address = format!("{}:{}", proxy_host, port);
-                            let shell = app_handle.shell();
-                            let output = shell
+                        shell
                             .command(sysproxy_exe.as_path().to_str().unwrap())
                             .args(["global", address.as_str(), bypass.as_ref()])
                             .output()
                             .await
-                                .unwrap();
-
+                            .unwrap()
+                    };
                     if !output.status.success() {
-                                log::error!(target: "app", "failed to set system proxy");
-                            }
-                        }
-                    }
+                        break;
                     }
+                };
             }
         });
     }

src-tauri/src/core/timer.rs

@@ -1,4 +1,4 @@
-use crate::{config::Config, feat, logging, logging_error, utils::logging::Type};
+use crate::{config::Config, core::CoreManager, feat};
 use anyhow::{Context, Result};
 use delay_timer::prelude::{DelayTimer, DelayTimerBuilder, TaskBuilder};
 use once_cell::sync::OnceCell;
@@ -54,40 +54,21 @@ impl Timer {
             )
             .is_err()
         {
-            logging!(debug, Type::Timer, "Timer already initialized, skipping...");
+            log::debug!(target: "app", "Timer already initialized, skipping...");
             return Ok(());
         }
 
-        logging!(info, Type::Timer, true, "Initializing timer...");
+        log::info!(target: "app", "Initializing timer...");
 
         // Initialize timer tasks
         if let Err(e) = self.refresh() {
             // Reset initialization flag on error
             self.initialized
                 .store(false, std::sync::atomic::Ordering::SeqCst);
-            logging_error!(Type::Timer, false, "Failed to initialize timer: {}", e);
+            log::error!(target: "app", "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
@@ -100,7 +81,6 @@ 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
@@ -113,26 +93,20 @@ 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, "立即执行任务: uid={}", uid);
+                    log::info!(target: "app", "Advancing task for uid: {}", uid);
                     if let Err(e) = delay_timer.advance_task(task.task_id) {
-                        logging!(warn, Type::Timer, "Failed to advance task {}: {}", uid, e);
+                        log::warn!(target: "app", "Failed to advance task {}: {}", uid, e);
                     }
                 }
             }
         }
 
-        logging!(info, Type::Timer, "Timer initialization completed");
+        log::info!(target: "app", "Timer initialization completed");
         Ok(())
     }
 
@@ -142,16 +116,11 @@ impl Timer {
         let diff_map = self.gen_diff();
 
         if diff_map.is_empty() {
-            logging!(debug, Type::Timer, "No timer changes needed");
+            log::debug!(target: "app", "No timer changes needed");
             return Ok(());
         }
 
-        logging!(
-            info,
-            Type::Timer,
-            "Refreshing {} timer tasks",
-            diff_map.len()
-        );
+        log::info!(target: "app", "Refreshing {} timer tasks", diff_map.len());
 
         // Apply changes while holding locks
         let mut timer_map = self.timer_map.write();
@@ -162,16 +131,9 @@ impl Timer {
                 DiffFlag::Del(tid) => {
                     timer_map.remove(&uid);
                     if let Err(e) = delay_timer.remove_task(tid) {
-                        logging!(
-                            warn,
-                            Type::Timer,
-                            "Failed to remove task {} for uid {}: {}",
-                            tid,
-                            uid,
-                            e
-                        );
+                        log::warn!(target: "app", "Failed to remove task {} for uid {}: {}", tid, uid, e);
                     } else {
-                        logging!(debug, Type::Timer, "Removed task {} for uid {}", tid, uid);
+                        log::debug!(target: "app", "Removed task {} for uid {}", tid, uid);
                     }
                 }
                 DiffFlag::Add(tid, interval) => {
@@ -184,23 +146,16 @@ impl Timer {
                     timer_map.insert(uid.clone(), task);
 
                     if let Err(e) = self.add_task(&mut delay_timer, uid.clone(), tid, interval) {
-                        logging_error!(Type::Timer, "Failed to add task for uid {}: {}", uid, e);
+                        log::error!(target: "app", "Failed to add task for uid {}: {}", uid, e);
                         timer_map.remove(&uid); // Rollback on failure
                     } else {
-                        logging!(debug, Type::Timer, "Added task {} for uid {}", tid, uid);
+                        log::debug!(target: "app", "Added task {} for uid {}", tid, uid);
                     }
                 }
                 DiffFlag::Mod(tid, interval) => {
                     // Remove old task first
                     if let Err(e) = delay_timer.remove_task(tid) {
-                        logging!(
-                            warn,
-                            Type::Timer,
-                            "Failed to remove old task {} for uid {}: {}",
-                            tid,
-                            uid,
-                            e
-                        );
+                        log::warn!(target: "app", "Failed to remove old task {} for uid {}: {}", tid, uid, e);
                     }
 
                     // Then add the new one
@@ -213,10 +168,10 @@ impl Timer {
                     timer_map.insert(uid.clone(), task);
 
                     if let Err(e) = self.add_task(&mut delay_timer, uid.clone(), tid, interval) {
-                        logging_error!(Type::Timer, "Failed to update task for uid {}: {}", uid, e);
+                        log::error!(target: "app", "Failed to update task for uid {}: {}", uid, e);
                         timer_map.remove(&uid); // Rollback on failure
                     } else {
-                        logging!(debug, Type::Timer, "Updated task {} for uid {}", tid, uid);
+                        log::debug!(target: "app", "Updated task {} for uid {}", tid, uid);
                     }
                 }
             }
@@ -234,13 +189,6 @@ impl Timer {
                 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);
                         }
                     }
@@ -248,12 +196,6 @@ impl Timer {
             }
         }
 
-        logging!(
-            debug,
-            Type::Timer,
-            "生成的定时更新配置数量: {}",
-            new_map.len()
-        );
         new_map
     }
 
@@ -264,36 +206,20 @@ 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);
                 }
             }
         }
@@ -303,13 +229,6 @@ impl Timer {
 
         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;
             }
@@ -320,7 +239,6 @@ impl Timer {
             *self.timer_count.lock() = next_id;
         }
 
-        logging!(debug, Type::Timer, "定时任务变更数量: {}", diff_map.len());
         diff_map
     }
 
@@ -332,14 +250,7 @@ impl Timer {
         tid: TaskID,
         minutes: u64,
     ) -> Result<()> {
-        logging!(
-            info,
-            Type::Timer,
-            "Adding task: uid={}, id={}, interval={}min",
-            uid,
-            tid,
-            minutes
-        );
+        log::info!(target: "app", "Adding task: uid={}, id={}, interval={}min", uid, tid, minutes);
 
         // Create a task with reasonable retries and backoff
         let task = TaskBuilder::default()
@@ -361,118 +272,39 @@ 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();
-        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);
+        log::info!(target: "app", "Running timer task for profile: {}", uid);
 
-        match tokio::time::timeout(std::time::Duration::from_secs(40), async {
-            Self::emit_update_event(&uid, true);
+        // Update profile
+        let profile_result = feat::update_profile(uid.clone(), None).await;
 
-            let is_current = Config::profiles().latest().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 {
+        match profile_result {
+            Ok(_) => {
+                // Update configuration
+                match CoreManager::global().update_config().await {
                     Ok(_) => {
                         let duration = task_start.elapsed().as_millis();
-                    logging!(
-                        info,
-                        Type::Timer,
+                        log::info!(
+                            target: "app",
                             "Timer task completed successfully for uid: {} (took {}ms)",
-                        uid,
-                        duration
+                            uid, duration
                         );
                     }
                     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);
+                        log::error!(
+                            target: "app",
+                            "Failed to refresh config after profile update for uid {}: {}",
+                            uid, e
+                        );
+                    }
+                }
+            }
+            Err(e) => {
+                log::error!(target: "app", "Failed to update profile uid {}: {}", uid, e);
             }
         }
-
-        // Emit completed event
-        Self::emit_update_event(&uid, false);
     }
 }
 

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

@@ -5,15 +5,16 @@ pub mod speed_rate;
 use crate::{
     cmd,
     config::Config,
-    feat, logging,
-    module::{lightweight::is_in_lightweight_mode, mihomo::Rate},
-    utils::{dirs::find_target_icons, i18n::t, resolve::VERSION},
-    Type,
+    feat,
+    module::mihomo::Rate,
+    resolve,
+    utils::{dirs, i18n::t, resolve::VERSION},
 };
 
 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;
@@ -21,142 +22,24 @@ use parking_lot::RwLock;
 pub use speed_rate::{SpeedRate, Traffic};
 #[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},
-    AppHandle, Wry,
+    App, AppHandle, Wry,
 };
 #[cfg(target_os = "macos")]
 use tokio::sync::broadcast;
 
 use super::handle;
-
-#[derive(Clone)]
-struct TrayState {}
-
 #[cfg(target_os = "macos")]
 pub struct Tray {
     pub speed_rate: Arc<Mutex<Option<SpeedRate>>>,
     shutdown_tx: Arc<RwLock<Option<broadcast::Sender<()>>>>,
     is_subscribed: Arc<RwLock<bool>>,
-    pub rate_cache: Arc<Mutex<Option<Rate>>>,
-    last_menu_update: Mutex<Option<Instant>>,
-    menu_updating: AtomicBool,
 }
 
 #[cfg(not(target_os = "macos"))]
-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 is_common_tray_icon = verge.common_tray_icon.unwrap_or(false);
-        if is_common_tray_icon {
-            if let Some(common_icon_path) = find_target_icons("common").unwrap() {
-                let icon_data = fs::read(common_icon_path).unwrap();
-                return (true, icon_data);
-            }
-        }
-        #[cfg(target_os = "macos")]
-        {
-            let tray_icon_colorful = verge.tray_icon.unwrap_or("monochrome".to_string());
-            if tray_icon_colorful == "monochrome" {
-                (
-                    false,
-                    include_bytes!("../../../icons/tray-icon-mono.ico").to_vec(),
-                )
-            } else {
-                (
-                    false,
-                    include_bytes!("../../../icons/tray-icon.ico").to_vec(),
-                )
-            }
-        }
-
-        #[cfg(not(target_os = "macos"))]
-        {
-            (
-                false,
-                include_bytes!("../../../icons/tray-icon.ico").to_vec(),
-            )
-        }
-    }
-
-    pub fn get_sysproxy_tray_icon() -> (bool, Vec<u8>) {
-        let verge = Config::verge().latest().clone();
-        let is_sysproxy_tray_icon = verge.sysproxy_tray_icon.unwrap_or(false);
-        if is_sysproxy_tray_icon {
-            if let Some(sysproxy_icon_path) = find_target_icons("sysproxy").unwrap() {
-                let icon_data = fs::read(sysproxy_icon_path).unwrap();
-                return (true, icon_data);
-            }
-        }
-        #[cfg(target_os = "macos")]
-        {
-            let tray_icon_colorful = verge.tray_icon.clone().unwrap_or("monochrome".to_string());
-            if tray_icon_colorful == "monochrome" {
-                (
-                    false,
-                    include_bytes!("../../../icons/tray-icon-sys-mono.ico").to_vec(),
-                )
-            } else {
-                (
-                    false,
-                    include_bytes!("../../../icons/tray-icon-sys.ico").to_vec(),
-                )
-            }
-        }
-
-        #[cfg(not(target_os = "macos"))]
-        {
-            (
-                false,
-                include_bytes!("../../../icons/tray-icon-sys.ico").to_vec(),
-            )
-        }
-    }
-
-    pub fn get_tun_tray_icon() -> (bool, Vec<u8>) {
-        let verge = Config::verge().latest().clone();
-        let is_tun_tray_icon = verge.tun_tray_icon.unwrap_or(false);
-        if is_tun_tray_icon {
-            if let Some(tun_icon_path) = find_target_icons("tun").unwrap() {
-                let icon_data = fs::read(tun_icon_path).unwrap();
-                return (true, icon_data);
-            }
-        }
-        #[cfg(target_os = "macos")]
-        {
-            let tray_icon_colorful = verge.tray_icon.clone().unwrap_or("monochrome".to_string());
-            if tray_icon_colorful == "monochrome" {
-                (
-                    false,
-                    include_bytes!("../../../icons/tray-icon-tun-mono.ico").to_vec(),
-                )
-            } else {
-                (
-                    false,
-                    include_bytes!("../../../icons/tray-icon-tun.ico").to_vec(),
-                )
-            }
-        }
-        #[cfg(not(target_os = "macos"))]
-        {
-            (
-                false,
-                include_bytes!("../../../icons/tray-icon-tun.ico").to_vec(),
-            )
-        }
-    }
-}
+pub struct Tray {}
 
 impl Tray {
     pub fn global() -> &'static Tray {
@@ -167,16 +50,10 @@ impl Tray {
             speed_rate: Arc::new(Mutex::new(None)),
             shutdown_tx: Arc::new(RwLock::new(None)),
             is_subscribed: Arc::new(RwLock::new(false)),
-            rate_cache: Arc::new(Mutex::new(None)),
-            last_menu_update: Mutex::new(None),
-            menu_updating: AtomicBool::new(false),
         });
 
         #[cfg(not(target_os = "macos"))]
-        return TRAY.get_or_init(|| Tray {
-            last_menu_update: Mutex::new(None),
-            menu_updating: AtomicBool::new(false),
-        });
+        return TRAY.get_or_init(|| Tray {});
     }
 
     pub fn init(&self) -> Result<()> {
@@ -188,6 +65,44 @@ impl Tray {
         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());
+
+            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(),
+                    _ => {}
+                }
+            }
+        });
+        tray.on_menu_event(on_menu_event);
+        Ok(())
+    }
+
     /// 更新托盘点击行为
     pub fn update_click_behavior(&self) -> Result<()> {
         let app_handle = handle::Handle::global().app_handle().unwrap();
@@ -203,54 +118,7 @@ impl Tray {
 
     /// 更新托盘菜单
     pub fn update_menu(&self) -> Result<()> {
-        // 调整最小更新间隔，确保状态及时刷新
-        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 app_handle = handle::Handle::global().app_handle().unwrap();
         let verge = Config::verge().latest().clone();
         let system_proxy = verge.enable_system_proxy.as_ref().unwrap_or(&false);
         let tun_mode = verge.enable_tun_mode.as_ref().unwrap_or(&false);
@@ -267,164 +135,133 @@ impl Tray {
             .data()
             .all_profile_uid_and_name()
             .unwrap_or_default();
-        let is_lightweight_mode = is_in_lightweight_mode();
 
-        match app_handle.tray_by_id("main") {
-            Some(tray) => {
+        let tray = app_handle.tray_by_id("main").unwrap();
         let _ = tray.set_menu(Some(create_tray_menu(
-                    app_handle,
+            &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(())
-            }
-        }
-    }
 
     /// 更新托盘图标
-    #[cfg(target_os = "macos")]
+    #[allow(unused_variables)]
     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 app_handle = handle::Handle::global().app_handle().unwrap();
         let verge = Config::verge().latest().clone();
-        let system_mode = verge.enable_system_proxy.as_ref().unwrap_or(&false);
+        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 (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 common_tray_icon = verge.common_tray_icon.as_ref().unwrap_or(&false);
+        let sysproxy_tray_icon = verge.sysproxy_tray_icon.as_ref().unwrap_or(&false);
+        let tun_tray_icon = verge.tun_tray_icon.as_ref().unwrap_or(&false);
+
+        let tray = app_handle.tray_by_id("main").unwrap();
+
+        #[cfg(target_os = "macos")]
+        let tray_icon = verge.tray_icon.clone().unwrap_or("monochrome".to_string());
+
+        let icon_bytes = if *system_proxy && !*tun_mode {
+            #[cfg(target_os = "macos")]
+            let mut icon = match tray_icon.as_str() {
+                "colorful" => include_bytes!("../../../icons/tray-icon-sys.ico").to_vec(),
+                _ => include_bytes!("../../../icons/tray-icon-sys-mono.ico").to_vec(),
             };
 
-        let enable_tray_speed = verge.enable_tray_speed.unwrap_or(false);
-        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";
+            #[cfg(not(target_os = "macos"))]
+            let mut icon = include_bytes!("../../../icons/tray-icon-sys.ico").to_vec();
+            if *sysproxy_tray_icon {
+                let icon_dir_path = dirs::app_home_dir()?.join("icons");
+                let png_path = icon_dir_path.join("sysproxy.png");
+                let ico_path = icon_dir_path.join("sysproxy.ico");
+                if ico_path.exists() {
+                    icon = std::fs::read(ico_path).unwrap();
+                } else if png_path.exists() {
+                    icon = std::fs::read(png_path).unwrap();
+                }
+            }
+            icon
+        } else if *tun_mode {
+            #[cfg(target_os = "macos")]
+            let mut icon = match tray_icon.as_str() {
+                "colorful" => include_bytes!("../../../icons/tray-icon-tun.ico").to_vec(),
+                _ => include_bytes!("../../../icons/tray-icon-tun-mono.ico").to_vec(),
+            };
 
-        if !enable_tray_speed {
-            let _ = tray.set_icon(Some(tauri::image::Image::from_bytes(&icon_bytes)?));
+            #[cfg(not(target_os = "macos"))]
+            let mut icon = include_bytes!("../../../icons/tray-icon-tun.ico").to_vec();
+            if *tun_tray_icon {
+                let icon_dir_path = dirs::app_home_dir()?.join("icons");
+                let png_path = icon_dir_path.join("tun.png");
+                let ico_path = icon_dir_path.join("tun.ico");
+                if ico_path.exists() {
+                    icon = std::fs::read(ico_path).unwrap();
+                } else if png_path.exists() {
+                    icon = std::fs::read(png_path).unwrap();
+                }
+            }
+            icon
+        } else {
+            #[cfg(target_os = "macos")]
+            let mut icon = match tray_icon.as_str() {
+                "colorful" => include_bytes!("../../../icons/tray-icon.ico").to_vec(),
+                _ => include_bytes!("../../../icons/tray-icon-mono.ico").to_vec(),
+            };
+
+            #[cfg(not(target_os = "macos"))]
+            let mut icon = include_bytes!("../../../icons/tray-icon.ico").to_vec();
+            if *common_tray_icon {
+                let icon_dir_path = dirs::app_home_dir()?.join("icons");
+                let png_path = icon_dir_path.join("common.png");
+                let ico_path = icon_dir_path.join("common.ico");
+                if ico_path.exists() {
+                    icon = std::fs::read(ico_path).unwrap();
+                } else if png_path.exists() {
+                    icon = std::fs::read(png_path).unwrap();
+                }
+            }
+            icon
+        };
+
+        #[cfg(target_os = "macos")]
+        {
+            let enable_tray_speed = Config::verge().latest().enable_tray_speed.unwrap_or(true);
+            let is_colorful = tray_icon == "colorful";
+
+            // 处理图标和速率
+            let final_icon_bytes = if enable_tray_speed {
+                let rate = rate.or_else(|| {
+                    self.speed_rate
+                        .lock()
+                        .as_ref()
+                        .and_then(|speed_rate| speed_rate.get_curent_rate())
+                });
+
+                // 使用新的方法渲染图标和速率
+                SpeedRate::add_speed_text(icon_bytes, rate)?
+            } else {
+                icon_bytes
+            };
+
+            // 设置系统托盘图标
+            let _ = tray.set_icon(Some(tauri::image::Image::from_bytes(&final_icon_bytes)?));
+            // 只对单色图标使用 template 模式
             let _ = tray.set_icon_as_template(!is_colorful);
-            return Ok(());
-        }
-
-        let rate = if let Some(rate) = rate {
-            Some(rate)
-        } else {
-            let guard = self.speed_rate.lock();
-            if let Some(guard) = guard.as_ref() {
-                if let Some(rate) = guard.get_curent_rate() {
-                    Some(rate)
-                } else {
-                    Some(Rate::default())
-                }
-            } 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();
-            if let Ok(rate_bytes) = SpeedRate::add_speed_text(is_custom_icon, bytes, rate) {
-                let _ = tray.set_icon(Some(tauri::image::Image::from_bytes(&rate_bytes)?));
-                let _ = tray.set_icon_as_template(!is_custom_icon && !is_colorful);
-            }
-        }
-        Ok(())
         }
 
         #[cfg(not(target_os = "macos"))]
-    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().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().unwrap();
-        let _tray = app_handle.tray_by_id("main").unwrap();
-
-        // 更新菜单
-        self.update_menu()?;
 
         Ok(())
     }
 
     /// 更新托盘提示
     pub fn update_tooltip(&self) -> Result<()> {
-        let app_handle = match handle::Handle::global().app_handle() {
-            Some(handle) => handle,
-            None => {
-                log::warn!(target: "app", "更新托盘提示失败: app_handle不存在");
-                return Ok(());
-            }
-        };
-
-        let version = match VERSION.get() {
-            Some(v) => v,
-            None => {
-                log::warn!(target: "app", "更新托盘提示失败: 版本信息不存在");
-                return Ok(());
-            }
-        };
+        let app_handle = handle::Handle::global().app_handle().unwrap();
+        let version = VERSION.get().unwrap();
 
         let verge = Config::verge().latest().clone();
         let system_proxy = verge.enable_system_proxy.as_ref().unwrap_or(&false);
@@ -441,15 +278,14 @@ impl Tray {
         let profiles = Config::profiles();
         let profiles = profiles.latest();
         if let Some(current_profile_uid) = profiles.get_current() {
-            if let Ok(profile) = profiles.get_item(&current_profile_uid) {
-                current_profile_name = match &profile.name {
+            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 Some(tray) = app_handle.tray_by_id("main") {
+        let tray = app_handle.tray_by_id("main").unwrap();
         let _ = tray.set_tooltip(Some(&format!(
             "Clash Verge {version}\n{}: {}\n{}: {}\n{}: {}",
             t("SysProxy"),
@@ -459,10 +295,6 @@ impl Tray {
             t("Profile"),
             current_profile_name
         )));
-        } else {
-            log::warn!(target: "app", "更新托盘提示失败: 托盘不存在");
-        }
-
         Ok(())
     }
 
@@ -470,8 +302,6 @@ impl Tray {
         self.update_menu()?;
         self.update_icon(None)?;
         self.update_tooltip()?;
-        // 更新轻量模式显示状态
-        self.update_tray_display()?;
         Ok(())
     }
 
@@ -483,134 +313,52 @@ impl Tray {
         // 如果已经订阅，先取消订阅
         if *self.is_subscribed.read() {
             self.unsubscribe_traffic();
-            tokio::time::sleep(std::time::Duration::from_millis(100)).await;
         }
 
-        let (shutdown_tx, shutdown_rx) = broadcast::channel(3);
+        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);
 
-        // 使用单线程防止阻塞主线程
-        std::thread::Builder::new()
-            .name("traffic-monitor".into())
-            .spawn(move || {
-                let rt = tokio::runtime::Builder::new_current_thread()
-                    .enable_all()
-                    .build()
-                    .expect("Failed to build tokio runtime for traffic monitor");
-                // 在单独的运行时中执行异步任务
-                rt.block_on(async move {
+        tauri::async_runtime::spawn(async move {
             let mut shutdown = shutdown_rx;
-                    let speed_rate = speed_rate.clone();
-                    let is_subscribed = is_subscribed.clone();
-                    let mut consecutive_errors = 0;
-                    let max_consecutive_errors = 5;
-
-                    let mut interval = tokio::time::interval(std::time::Duration::from_secs(10));
 
             'outer: loop {
-                        if !*is_subscribed.read() {
-                            log::info!(target: "app", "Traffic subscription has been cancelled");
-                            break;
-                        }
-
-                        match tokio::time::timeout(
-                            std::time::Duration::from_secs(5),
-                            Traffic::get_traffic_stream()
-                        ).await {
-                            Ok(stream_result) => {
-                                match stream_result {
-                                    Ok(mut stream) => {
-                                        consecutive_errors = 0;
-
-                                        loop {
+                match Traffic::get_traffic_stream().await {
+                    Ok(mut stream) => loop {
                         tokio::select! {
-                                                traffic_result = stream.next() => {
-                                                    match traffic_result {
-                                                        Some(Ok(traffic)) => {
-                                                            if let Ok(Some(rate)) = tokio::time::timeout(
-                                                                std::time::Duration::from_millis(50),
-                                                                async {
-                                                                    let guard = speed_rate.try_lock();
-                                                                    if let Some(guard) = guard {
+                            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() {
-                                                                            sr.update_and_check_changed(traffic.up, traffic.down)
-                                                                        } else {
-                                                                            None
-                                                                        }
-                                                                    } else {
-                                                                        None
+                                        if let Some(rate) = sr.update_and_check_changed(traffic.up, traffic.down) {
+                                            let _ = Tray::global().update_icon(Some(rate));
                                         }
                                     }
-                                                            ).await {
-                                                                let _ = tokio::time::timeout(
-                                                                    std::time::Duration::from_millis(100),
-                                                                    async { let _ = Tray::global().update_icon(Some(rate)); }
-                                                                ).await;
-                                                            }
-                                                        },
-                                                        Some(Err(e)) => {
-                                                            log::error!(target: "app", "Traffic stream error: {}", e);
-                                                            consecutive_errors += 1;
-                                                            if consecutive_errors >= max_consecutive_errors {
-                                                                log::error!(target: "app", "Too many errors, reconnecting traffic stream");
-                                                                break;
-                                                            }
-                                                        },
-                                                        None => {
-                                                            log::info!(target: "app", "Traffic stream ended, reconnecting");
-                                                            break;
-                                                        }
-                                                    }
-                                                },
-                                                _ = shutdown.recv() => {
-                                                    log::info!(target: "app", "Received shutdown signal for traffic stream");
-                                                    break 'outer;
-                                                },
-                                                _ = interval.tick() => {
-                                                    if !*is_subscribed.read() {
-                                                        log::info!(target: "app", "Traffic monitor detected subscription cancelled");
-                                                        break 'outer;
-                                                    }
-                                                    log::debug!(target: "app", "Traffic subscription periodic health check");
-                                                },
-                                                _ = tokio::time::sleep(std::time::Duration::from_secs(60)) => {
-                                                    log::info!(target: "app", "Traffic stream max active time reached, reconnecting");
-                                                    break;
                                 }
                             }
+                            _ = shutdown.recv() => break 'outer,
                         }
                     },
                     Err(e) => {
                         log::error!(target: "app", "Failed to get traffic stream: {}", e);
-                                        consecutive_errors += 1;
-                                        if consecutive_errors >= max_consecutive_errors {
-                                            log::error!(target: "app", "Too many consecutive errors, pausing traffic monitoring");
-                                            tokio::time::sleep(std::time::Duration::from_secs(30)).await;
-                                            consecutive_errors = 0;
-                                        } else {
-                                            tokio::time::sleep(std::time::Duration::from_secs(2)).await;
-                                        }
-                                    }
-                                }
-                            },
-                            Err(_) => {
-                                log::error!(target: "app", "Traffic stream initialization timed out");
-                                tokio::time::sleep(std::time::Duration::from_secs(2)).await;
-                            }
-                        }
+                        // 如果获取流失败，等待一段时间后重试
+                        tokio::time::sleep(std::time::Duration::from_secs(1)).await;
 
+                        // 检查是否应该继续重试
                         if !*is_subscribed.read() {
                             break;
                         }
                     }
-                    log::info!(target: "app", "Traffic subscription thread terminated");
+                }
+            }
         });
-            })
-            .expect("Failed to spawn traffic monitor thread");
 
         Ok(())
     }
@@ -624,78 +372,6 @@ impl Tray {
             drop(tx);
         }
     }
-
-    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().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().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" => {
-                        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(())
-    }
 }
 
 fn create_tray_menu(
@@ -704,13 +380,9 @@ 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 unknown_version = String::from("unknown");
-    let version = VERSION.get().unwrap_or(&unknown_version);
-
+    let version = VERSION.get().unwrap();
     let hotkeys = Config::verge()
         .latest()
         .hotkeys
@@ -818,16 +490,6 @@ fn create_tray_menu(
     )
     .unwrap();
 
-    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();
 
@@ -920,8 +582,6 @@ fn create_tray_menu(
             separator,
             system_proxy,
             tun_mode,
-            separator,
-            lighteweight_mode,
             copy_env,
             open_dir,
             more,
@@ -937,63 +597,21 @@ 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];
-            logging!(
-                info,
-                Type::ProxyMode,
-                true,
-                "Switch Proxy Mode To: {}",
-                mode
-            );
+            println!("change mode to: {}", mode);
             feat::change_clash_mode(mode.into());
         }
-        "open_window" => {
-            use crate::utils::window_manager::WindowManager;
-            log::info!(target: "app", "托盘菜单点击: 打开窗口");
-            // 如果在轻量模式中，先退出轻量模式
-            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);
-        }
+        "open_window" => resolve::create_window(),
+        "system_proxy" => feat::toggle_system_proxy(),
+        "tun_mode" => feat::toggle_tun_mode(None),
         "copy_env" => feat::copy_clash_env(),
-        "open_app_dir" => {
-            let _ = cmd::open_app_dir();
-        }
-        "open_core_dir" => {
-            let _ = cmd::open_core_dir();
-        }
-        "open_logs_dir" => {
-            let _ = cmd::open_logs_dir();
-        }
+        "open_app_dir" => crate::log_err!(cmd::open_app_dir()),
+        "open_core_dir" => crate::log_err!(cmd::open_core_dir()),
+        "open_logs_dir" => crate::log_err!(cmd::open_logs_dir()),
         "restart_clash" => feat::restart_clash_core(),
         "restart_app" => feat::restart_app(),
-        "entry_lightweight_mode" => {
-            // 处理轻量模式的切换
-            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();
+            println!("quit");
+            feat::quit(Some(0));
         }
         id if id.starts_with("profiles_") => {
             let profile_index = &id["profiles_".len()..];
@@ -1001,9 +619,4 @@ fn on_menu_event(_: &AppHandle, event: MenuEvent) {
         }
         _ => {}
     }
-
-    // 统一调用状态更新
-    if let Err(e) = Tray::global().update_all_states() {
-        log::warn!(target: "app", "更新托盘状态失败: {}", e);
-    }
 }

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

@@ -9,12 +9,13 @@ use image::{GenericImageView, Rgba, RgbaImage};
 use imageproc::drawing::draw_text_mut;
 use parking_lot::Mutex;
 use std::{io::Cursor, sync::Arc};
-use tokio_tungstenite::tungstenite::http;
+use tokio_tungstenite::tungstenite::{http, Message};
 use tungstenite::client::IntoClientRequest;
 #[derive(Debug, Clone)]
 pub struct SpeedRate {
     rate: Arc<Mutex<(Rate, Rate)>>,
     last_update: Arc<Mutex<std::time::Instant>>,
+    // 移除 base_image，不再缓存原始图像
 }
 
 impl SpeedRate {
@@ -76,71 +77,44 @@ impl SpeedRate {
     }
 
     // 分离图标加载和速率渲染
-    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 });
+    pub fn add_speed_text(icon_bytes: Vec<u8>, rate: Option<Rate>) -> Result<Vec<u8>> {
+        let rate = rate.unwrap_or(Rate { up: 0, down: 0 });
 
-        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 icon_image = image::load_from_memory(&icon_bytes)?;
+        let (icon_width, icon_height) = (icon_image.width(), icon_image.height());
 
-        let total_width = match (is_custom_icon, icon_bytes.is_some()) {
-            (true, true) => 510,
-            (true, false) => 740,
-            (false, false) => 740,
-            (false, true) => icon_width + 740,
-        };
+        // 判断是否为彩色图标
+        let is_colorful =
+            !crate::utils::help::is_monochrome_image_from_bytes(&icon_bytes).unwrap_or(false);
 
-        // println!(
-        //     "icon_height: {}, icon_wight: {}, total_width: {}",
-        //     icon_height, icon_width, total_width
-        // );
+        // 增加文本宽度和间距
+        let text_width = 580; // 文本区域宽度
+        let total_width = icon_width + text_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]),
+                Rgba([0u8, 0u8, 0u8, 160u8]),
+            )
+        } else {
+            // 单色图标使用白色文本和轻微黑色阴影
+            (
+                Rgba([255u8, 255u8, 255u8, 255u8]),
+                Rgba([0u8, 0u8, 0u8, 120u8]),
             )
         };
         // 减小字体大小以适应文本区域
@@ -150,30 +124,17 @@ impl SpeedRate {
         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 = format_bytes_speed(rate.up);
+        let down_text = format_bytes_speed(rate.down);
 
         // 计算文本位置，确保垂直间距合适
         // 修改文本位置为居右显示
-        // 计算右对齐的文本位置
-        // let up_text_width = imageproc::drawing::text_size(scale, &font, &up_text).0 as u32;
-        // let down_text_width = imageproc::drawing::text_size(scale, &font, &down_text).0 as u32;
-        // let up_text_x = total_width - up_text_width;
-        // let down_text_x = total_width - down_text_width;
+        let up_text_width = imageproc::drawing::text_size(scale, &font, &up_text).0 as u32;
+        let down_text_width = imageproc::drawing::text_size(scale, &font, &down_text).0 as u32;
 
-        // 计算左对齐的文本位置
-        let (up_text_x, 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 up_text_x = total_width - up_text_width;
+        let down_text_x = total_width - down_text_width;
 
         // 优化垂直位置，使速率显示的高度和上下间距正好等于图标大小
         let text_height = font_size as i32;
@@ -240,92 +201,41 @@ pub struct Traffic {
 impl Traffic {
     pub async fn get_traffic_stream() -> Result<impl Stream<Item = Result<Traffic, anyhow::Error>>>
     {
-        use futures::{
-            future::FutureExt,
-            stream::{self, StreamExt},
-        };
+        use futures::stream::{self, StreamExt};
         use std::time::Duration;
 
-        // 先处理错误和超时情况
         let stream = Box::pin(
-            stream::unfold((), move |_| async move {
-                'retry: loop {
-                    log::info!(target: "app", "establishing traffic websocket connection");
+            stream::unfold((), |_| async {
+                loop {
                     let (url, token) = MihomoManager::get_traffic_ws_url();
-                    let mut request = match url.into_client_request() {
-                        Ok(req) => req,
-                        Err(e) => {
-                            log::error!(target: "app", "failed to create websocket request: {}", e);
-                            tokio::time::sleep(Duration::from_secs(2)).await;
-                            continue 'retry;
-                        }
-                    };
+                    let mut request = url.into_client_request().unwrap();
+                    request
+                        .headers_mut()
+                        .insert(http::header::AUTHORIZATION, token);
 
-                    request.headers_mut().insert(http::header::AUTHORIZATION, token);
-
-                    match tokio::time::timeout(Duration::from_secs(3),
-                        tokio_tungstenite::connect_async(request)
-                    ).await {
-                        Ok(Ok((ws_stream, _))) => {
-                            log::info!(target: "app", "traffic websocket connection established");
-                            // 设置流超时控制
-                            let traffic_stream = ws_stream
-                                .take_while(|msg| {
-                                    let continue_stream = msg.is_ok();
-                                    async move { continue_stream }.boxed()
+                    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),
                                         })
-                                .filter_map(|msg| async move {
-                                    match msg {
-                                        Ok(msg) => {
-                                            if !msg.is_text() {
-                                                return None;
+                                    })
+                                }),
+                                (),
+                            ));
                         }
-
-                                            match tokio::time::timeout(
-                                                Duration::from_millis(200),
-                                                async { msg.into_text() }
-                                            ).await {
-                                                Ok(Ok(text)) => {
-                                                    match serde_json::from_str::<serde_json::Value>(&text) {
-                                                        Ok(json) => {
-                                                            let up = json["up"].as_u64().unwrap_or(0);
-                                                            let down = json["down"].as_u64().unwrap_or(0);
-                                                            Some(Ok(Traffic { up, down }))
-                                                        },
                         Err(e) => {
-                                                            log::warn!(target: "app", "traffic json parse error: {} for {}", e, text);
-                                                            None
+                            log::error!(target: "app", "traffic ws connection failed: {e}");
+                            tokio::time::sleep(Duration::from_secs(5)).await;
+                            continue;
                         }
                     }
-                                                },
-                                                Ok(Err(e)) => {
-                                                    log::warn!(target: "app", "traffic text conversion error: {}", e);
-                                                    None
-                                                },
-                                                Err(_) => {
-                                                    log::warn!(target: "app", "traffic text processing timeout");
-                                                    None
-                                                }
-                                            }
-                                        },
-                                        Err(e) => {
-                                            log::error!(target: "app", "traffic websocket error: {}", e);
-                                            None
-                                        }
-                                    }
-                                });
-
-                            return Some((traffic_stream, ()));
-                        },
-                        Ok(Err(e)) => {
-                            log::error!(target: "app", "traffic websocket connection failed: {}", e);
-                        },
-                        Err(_) => {
-                            log::error!(target: "app", "traffic websocket connection timed out");
-                        }
-                    }
-
-                    tokio::time::sleep(Duration::from_secs(2)).await;
                 }
             })
             .flatten(),

src-tauri/src/enhance/mod.rs

@@ -22,7 +22,7 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
         let verge = Config::verge();
         let verge = verge.latest();
         (
-            Some(verge.get_valid_clash_core()),
+            verge.clash_core.clone(),
             verge.enable_tun_mode.unwrap_or(false),
             verge.enable_builtin_enhanced.unwrap_or(true),
             verge.verge_socks_enabled.unwrap_or(false),
@@ -261,26 +261,14 @@ 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) {
-                        // 处理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 {
+                        // 将DNS配置合并到最终配置中
                         config.insert("dns".into(), dns_config.into());
                         log::info!(target: "app", "apply dns_config.yaml");
                     }
@@ -288,7 +276,6 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
             }
         }
     }
-    }
 
     let mut exists_set = HashSet::new();
     exists_set.extend(exists_keys);

src-tauri/src/enhance/script.rs

@@ -33,40 +33,37 @@ pub fn use_script(
     }
     let _ = context.eval(Source::from_bytes(
         r#"var console = Object.freeze({
-        log(data){__verge_log__("log",JSON.stringify(data, null, 2))},
-        info(data){__verge_log__("info",JSON.stringify(data, null, 2))},
-        error(data){__verge_log__("error",JSON.stringify(data, null, 2))},
-        debug(data){__verge_log__("debug",JSON.stringify(data, null, 2))},
-        warn(data){__verge_log__("warn",JSON.stringify(data, null, 2))},
-        table(data){__verge_log__("table",JSON.stringify(data, null, 2))},
+        log(data){__verge_log__("log",JSON.stringify(data))}, 
+        info(data){__verge_log__("info",JSON.stringify(data))}, 
+        error(data){__verge_log__("error",JSON.stringify(data))},
+        debug(data){__verge_log__("debug",JSON.stringify(data))},
       });"#,
     ));
 
     let config = use_lowercase(config.clone());
     let config_str = serde_json::to_string(&config)?;
 
-    // 仅处理 name 参数中的特殊字符
-    let safe_name = escape_js_string_for_single_quote(&name);
-
     let code = format!(
         r#"try{{
         {script};
-        JSON.stringify(main({config_str},'{safe_name}')||'')
+        JSON.stringify(main({config_str},'{name}')||'')
       }} catch(err) {{
         `__error_flag__ ${{err.toString()}}`
       }}"#
     );
-
     if let Ok(result) = context.eval(Source::from_bytes(code.as_str())) {
         if !result.is_string() {
             anyhow::bail!("main function should return object");
         }
         let result = result.to_string(&mut context).unwrap();
         let result = result.to_std_string().unwrap();
-
-        // 直接解析JSON结果,不做其他解析
-        let res: Result<Mapping, Error> = parse_json_safely(&result);
-
+        if result.starts_with("__error_flag__") {
+            anyhow::bail!(result[15..].to_owned());
+        }
+        if result == "\"\"" {
+            anyhow::bail!("main function should return object");
+        }
+        let res: Result<Mapping, Error> = Ok(serde_json::from_str::<Mapping>(result.as_str())?);
         let mut out = outputs.lock().unwrap();
         match res {
             Ok(config) => Ok((use_lowercase(config), out.to_vec())),
@@ -80,27 +77,6 @@ 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]
 fn test_script() {
     let script = r#"
@@ -128,31 +104,6 @@ fn test_script() {
     let (config, results) = use_script(script.into(), config, "".to_string()).unwrap();
 
     let _ = serde_yaml::to_string(&config).unwrap();
-    let yaml_config_size = std::mem::size_of_val(&config);
-    dbg!(yaml_config_size);
-    let box_yaml_config_size = std::mem::size_of_val(&Box::new(config));
-    dbg!(box_yaml_config_size);
+
     dbg!(results);
-    assert!(box_yaml_config_size < yaml_config_size);
-}
-
-// 测试特殊字符转义功能
-#[test]
-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).unwrap();
-
-    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).unwrap();
-
-    assert!(parsed_quoted.contains_key("key"));
-    assert!(parsed_quoted.contains_key("nested"));
 }

src-tauri/src/feat/backup.rs

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

src-tauri/src/feat/clash.rs

@@ -1,17 +1,16 @@
 use crate::{
     config::Config,
     core::{handle, tray, CoreManager},
-    logging_error,
+    log_err,
     module::mihomo::MihomoManager,
-    process::AsyncHandler,
-    utils::{logging::Type, resolve},
+    utils::resolve,
 };
 use serde_yaml::{Mapping, Value};
 use tauri::Manager;
 
 /// Restart the Clash core
 pub fn restart_clash_core() {
-    AsyncHandler::spawn(move || async move {
+    tauri::async_runtime::spawn(async {
         match CoreManager::global().restart_core().await {
             Ok(_) => {
                 handle::Handle::refresh_clash();
@@ -27,34 +26,17 @@ pub fn restart_clash_core() {
 
 /// Restart the application
 pub fn restart_app() {
-    AsyncHandler::spawn(move || async move {
-        logging_error!(Type::Core, true, CoreManager::global().stop_core().await);
-        resolve::resolve_reset_async().await;
+    tauri::async_runtime::spawn_blocking(|| {
+        tauri::async_runtime::block_on(async {
+            log_err!(CoreManager::global().stop_core().await);
+        });
+        resolve::resolve_reset();
         let app_handle = handle::Handle::global().app_handle().unwrap();
         std::thread::sleep(std::time::Duration::from_secs(1));
         tauri::process::restart(&app_handle.env());
     });
 }
 
-fn after_change_clash_mode() {
-    AsyncHandler::spawn(move || async {
-        match MihomoManager::global().get_connections().await {
-            Ok(connections) => {
-                if let Some(connections_array) = connections["connections"].as_array() {
-                    for connection in connections_array {
-                        if let Some(id) = connection["id"].as_str() {
-                            let _ = MihomoManager::global().delete_connection(id).await;
-                        }
-                    }
-                }
-            }
-            Err(err) => {
-                log::error!(target: "app", "Failed to get connections: {}", err);
-            }
-        }
-    });
-}
-
 /// Change Clash mode (rule/global/direct/script)
 pub fn change_clash_mode(mode: String) {
     let mut mapping = Mapping::new();
@@ -63,8 +45,9 @@ pub fn change_clash_mode(mode: String) {
     let json_value = serde_json::json!({
         "mode": mode
     });
-    AsyncHandler::spawn(move || async move {
+    tauri::async_runtime::spawn(async move {
         log::debug!(target: "app", "change clash mode to {mode}");
+
         match MihomoManager::global().patch_configs(json_value).await {
             Ok(_) => {
                 // 更新订阅
@@ -72,45 +55,47 @@ pub fn change_clash_mode(mode: String) {
 
                 if Config::clash().data().save_config().is_ok() {
                     handle::Handle::refresh_clash();
-                    logging_error!(Type::Tray, true, tray::Tray::global().update_menu());
-                    logging_error!(Type::Tray, true, tray::Tray::global().update_icon(None));
-                }
-
-                let is_auto_close_connection = Config::verge()
-                    .data()
-                    .auto_close_connection
-                    .unwrap_or(false);
-                if is_auto_close_connection {
-                    after_change_clash_mode();
+                    log_err!(tray::Tray::global().update_menu());
+                    log_err!(tray::Tray::global().update_icon(None));
                 }
             }
-            Err(err) => log::error!(target: "app", "{err}"),
+            Err(err) => println!("{err}"),
         }
     });
 }
 
 /// Test connection delay to a URL
 pub async fn test_delay(url: String) -> anyhow::Result<u32> {
-    use crate::utils::network::{NetworkManager, ProxyType};
-    use tokio::time::Instant;
+    use tokio::time::{Duration, Instant};
+    let mut builder = reqwest::ClientBuilder::new().use_rustls_tls().no_proxy();
 
+    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);
 
-    // 如果是TUN模式，不使用代理，否则使用自身代理
-    let proxy_type = if !tun_mode {
-        ProxyType::Localhost
-    } else {
-        ProxyType::None
-    };
+    let proxy_scheme = format!("http://127.0.0.1:{port}");
 
-    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());
+    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 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 = NetworkManager::global()
-        .get_with_interrupt(&url, proxy_type, Some(10), user_agent, false)
-        .await;
-
+    let response = request.send().await;
     match response {
         Ok(response) => {
             log::trace!(target: "app", "test_delay response: {:#?}", response);
@@ -122,7 +107,7 @@ pub async fn test_delay(url: String) -> anyhow::Result<u32> {
         }
         Err(err) => {
             log::trace!(target: "app", "test_delay error: {:#?}", err);
-            Err(err)
+            Err(err.into())
         }
     }
 }

src-tauri/src/feat/config.rs

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

src-tauri/src/feat/profile.rs

@@ -2,15 +2,12 @@ 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) {
-    AsyncHandler::spawn(|| async move {
+    tauri::async_runtime::spawn(async move {
         let app_handle = handle::Handle::global().app_handle().unwrap();
         match cmd::patch_profiles_config_by_profile_index(app_handle, profile_index).await {
             Ok(_) => {
@@ -25,14 +22,8 @@ pub fn toggle_proxy_profile(profile_index: String) {
 
 /// Update a profile
 /// If updating current profile, activate it
-/// 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，保持兼容性
+pub async fn update_profile(uid: String, option: Option<PrfOption>) -> Result<()> {
+    println!("[订阅更新] 开始更新订阅 {}", uid);
 
     let url_opt = {
         let profiles = Config::profiles();
@@ -41,13 +32,13 @@ pub async fn update_profile(
         let is_remote = item.itype.as_ref().is_some_and(|s| s == "remote");
 
         if !is_remote {
-            log::info!(target: "app", "[订阅更新] {} 不是远程订阅，跳过更新", uid);
+            println!("[订阅更新] {} 不是远程订阅，跳过更新", uid);
             None // 非远程订阅直接更新
         } else if item.url.is_none() {
-            log::warn!(target: "app", "[订阅更新] {} 缺少URL，无法更新", uid);
+            println!("[订阅更新] {} 缺少URL，无法更新", uid);
             bail!("failed to get the profile item url");
         } else {
-            log::info!(target: "app",
+            println!(
                 "[订阅更新] {} 是远程订阅，URL: {}",
                 uid,
                 item.url.clone().unwrap()
@@ -58,88 +49,32 @@ pub async fn update_profile(
 
     let should_update = match url_opt {
         Some((url, opt)) => {
-            log::info!(target: "app", "[订阅更新] 开始下载新的订阅内容");
-            let merged_opt = PrfOption::merge(opt.clone(), option.clone());
+            println!("[订阅更新] 开始下载新的订阅内容");
+            let merged_opt = PrfOption::merge(opt, option);
+            let item = PrfItem::from_url(&url, None, None, merged_opt).await?;
 
-            // 尝试使用正常设置更新
-            match PrfItem::from_url(&url, None, None, merged_opt.clone()).await {
-                Ok(item) => {
-                    log::info!(target: "app", "[订阅更新] 更新订阅配置成功");
+            println!("[订阅更新] 更新订阅配置");
             let profiles = Config::profiles();
             let mut profiles = profiles.latest();
             profiles.update_item(uid.clone(), item)?;
 
             let is_current = Some(uid.clone()) == profiles.get_current();
-                    log::info!(target: "app", "[订阅更新] 是否为当前使用的订阅: {}", is_current);
-                    is_current && auto_refresh
+            println!("[订阅更新] 是否为当前使用的订阅: {}", is_current);
+            is_current
         }
-                Err(err) => {
-                    // 首次更新失败，尝试使用Clash代理
-                    log::warn!(target: "app", "[订阅更新] 正常更新失败: {}，尝试使用Clash代理更新", err);
-
-                    // 发送通知
-                    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.latest();
-                            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 => auto_refresh,
+        None => true,
     };
 
     if should_update {
-        logging!(info, Type::Config, true, "[订阅更新] 更新内核配置");
+        println!("[订阅更新] 更新内核配置");
         match CoreManager::global().update_config().await {
             Ok(_) => {
-                logging!(info, Type::Config, true, "[订阅更新] 更新成功");
+                println!("[订阅更新] 更新成功");
                 handle::Handle::refresh_clash();
             }
             Err(err) => {
-                logging!(error, Type::Config, true, "[订阅更新] 更新失败: {}", err);
-                handle::Handle::notice_message("update_failed", format!("{err}"));
+                println!("[订阅更新] 更新失败: {}", err);
+                handle::Handle::notice_message("set_config::error", format!("{err}"));
                 log::error!(target: "app", "{err}");
             }
         }
@@ -147,11 +82,3 @@ pub async fn update_profile(
 
     Ok(())
 }
-
-/// 增强配置
-pub async fn enhance_profiles() -> Result<()> {
-    crate::core::CoreManager::global()
-        .update_config()
-        .await
-        .map(|_| ())
-}

src-tauri/src/feat/proxy.rs

@@ -1,7 +1,6 @@
 use crate::{
     config::{Config, IVerge},
     core::handle,
-    process::AsyncHandler,
 };
 use std::env;
 use tauri_plugin_clipboard_manager::ClipboardExt;
@@ -10,22 +9,8 @@ use tauri_plugin_clipboard_manager::ClipboardExt;
 pub fn toggle_system_proxy() {
     let enable = Config::verge().draft().enable_system_proxy;
     let enable = enable.unwrap_or(false);
-    let auto_close_connection = Config::verge()
-        .data()
-        .auto_close_connection
-        .unwrap_or(false);
-
-    AsyncHandler::spawn(move || async move {
-        // 如果当前系统代理即将关闭，且自动关闭连接设置为true，则关闭所有连接
-        if enable && auto_close_connection {
-            if let Err(err) = crate::module::mihomo::MihomoManager::global()
-                .close_all_connections()
-                .await
-            {
-                log::error!(target: "app", "Failed to close all connections: {}", err);
-            }
-        }
 
+    tauri::async_runtime::spawn(async move {
         match super::patch_verge(
             IVerge {
                 enable_system_proxy: Some(!enable),
@@ -46,7 +31,7 @@ pub fn toggle_tun_mode(not_save_file: Option<bool>) {
     let enable = Config::verge().data().enable_tun_mode;
     let enable = enable.unwrap_or(false);
 
-    AsyncHandler::spawn(async move || {
+    tauri::async_runtime::spawn(async move {
         match super::patch_verge(
             IVerge {
                 enable_tun_mode: Some(!enable),
@@ -64,14 +49,9 @@ pub fn toggle_tun_mode(not_save_file: Option<bool>) {
 
 /// Copy proxy environment variables to clipboard
 pub fn copy_clash_env() {
-    // 从环境变量获取IP地址，如果没有则从配置中获取 proxy_host，默认为 127.0.0.1
-    let clash_verge_rev_ip = env::var("CLASH_VERGE_REV_IP").unwrap_or_else(|_| {
-        Config::verge()
-            .latest()
-            .proxy_host
-            .clone()
-            .unwrap_or_else(|| "127.0.0.1".to_string())
-    });
+    // 从环境变量获取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());
 
     let app_handle = handle::Handle::global().app_handle().unwrap();
     let port = { Config::verge().latest().verge_mixed_port.unwrap_or(7897) };

src-tauri/src/feat/window.rs

@@ -3,37 +3,87 @@ use crate::AppHandleManager;
 use crate::{
     config::Config,
     core::{handle, sysopt, CoreManager},
-    logging,
     module::mihomo::MihomoManager,
-    utils::logging::Type,
+    utils::resolve,
 };
+use tauri::Manager;
+use tauri_plugin_window_state::{AppHandleExt, StateFlags};
 
 /// Open or close the dashboard window
 #[allow(dead_code)]
 pub fn open_or_close_dashboard() {
-    use crate::utils::window_manager::WindowManager;
-
+    println!("Attempting to open/close dashboard");
     log::info!(target: "app", "Attempting to open/close dashboard");
 
-    // 检查是否在轻量模式下
-    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;
+    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();
+    }
 }
 
-    // 使用统一的窗口管理器切换窗口状态
-    let result = WindowManager::toggle_main_window();
-    log::info!(target: "app", "Window toggle result: {:?}", result);
+/// Setup window state monitor to save window position and size in real-time
+pub fn setup_window_state_monitor(app_handle: &tauri::AppHandle) {
+    let window = app_handle.get_webview_window("main").unwrap();
+    let app_handle_clone = app_handle.clone();
+
+    // 监听窗口移动事件
+    let app_handle_move = app_handle_clone.clone();
+    window.on_window_event(move |event| {
+        match event {
+            // 窗口移动时保存状态
+            tauri::WindowEvent::Moved(_) => {
+                let _ = app_handle_move.save_window_state(StateFlags::all());
+            }
+            // 窗口调整大小时保存状态
+            tauri::WindowEvent::Resized(_) => {
+                let _ = app_handle_move.save_window_state(StateFlags::all());
+            }
+            // 其他可能改变窗口状态的事件
+            tauri::WindowEvent::ScaleFactorChanged { .. } => {
+                let _ = app_handle_move.save_window_state(StateFlags::all());
+            }
+            // 窗口关闭时保存
+            tauri::WindowEvent::CloseRequested { .. } => {
+                let _ = app_handle_move.save_window_state(StateFlags::all());
+            }
+            _ => {}
+        }
+    });
 }
 
-/// 异步优化的应用退出函数
-pub fn quit() {
-    use crate::process::AsyncHandler;
-    logging!(debug, Type::System, true, "启动退出流程");
+/// 优化的应用退出函数
+pub fn quit(code: Option<i32>) {
+    log::debug!(target: "app", "启动退出流程");
 
     // 获取应用句柄并设置退出标志
     let app_handle = handle::Handle::global().app_handle().unwrap();
@@ -42,185 +92,60 @@ pub fn quit() {
     // 优先关闭窗口，提供立即反馈
     if let Some(window) = handle::Handle::global().get_window() {
         let _ = window.hide();
-        log::info!(target: "app", "窗口已隐藏");
     }
 
-    // 使用异步任务处理资源清理，避免阻塞
-    AsyncHandler::spawn(move || async move {
-        logging!(info, Type::System, true, "开始异步清理资源");
-        let cleanup_result = clean_async().await;
-
-        logging!(
-            info,
-            Type::System,
-            true,
-            "资源清理完成，退出代码: {}",
-            if cleanup_result { 0 } else { 1 }
-        );
-        app_handle.exit(if cleanup_result { 0 } else { 1 });
-    });
-}
-
-async fn clean_async() -> bool {
+    // 在单独线程中处理资源清理，避免阻塞主线程
+    std::thread::spawn(move || {
+        // 使用tokio运行时执行异步清理任务
+        tauri::async_runtime::block_on(async {
+            // 使用超时机制处理清理操作
             use tokio::time::{timeout, Duration};
 
-    logging!(info, Type::System, true, "开始执行异步清理操作...");
-
-    // 1. 处理TUN模式
-    let tun_task = async {
+            // 1. 直接关闭TUN模式 (优先处理，通常最容易卡住)
             if Config::verge().data().enable_tun_mode.unwrap_or(false) {
-            let disable_tun = serde_json::json!({
+                let disable = serde_json::json!({
                     "tun": {
                         "enable": false
                     }
                 });
-            match timeout(
-                Duration::from_secs(2),
-                MihomoManager::global().patch_configs(disable_tun),
-            )
-            .await
-            {
-                Ok(_) => {
-                    log::info!(target: "app", "TUN模式已禁用");
-                    true
-                }
-                Err(_) => {
-                    log::warn!(target: "app", "禁用TUN模式超时");
-                    false
-                }
-            }
-        } else {
-            true
-        }
-    };
 
-    // 2. 系统代理重置
-    let proxy_task = async {
-        match timeout(
-            Duration::from_secs(3),
+                // 设置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(),
-        )
-        .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 (tun_success, proxy_success, core_success) = tokio::join!(tun_task, 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
+            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;
             }
-
-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
-        }
-    }
+        // 无论清理结果如何，确保应用退出
+        app_handle.exit(code.unwrap_or(0));
+    });
 }
 
 #[cfg(target_os = "macos")]
 pub fn hide() {
-    use crate::module::lightweight::add_light_weight_timer;
-
-    let enable_auto_light_weight_mode = Config::verge()
-        .data()
-        .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();
 }

src-tauri/src/lib.rs

@@ -4,23 +4,18 @@ mod core;
 mod enhance;
 mod feat;
 mod module;
-mod process;
-mod state;
 mod utils;
 use crate::{
     core::hotkey,
-    process::AsyncHandler,
     utils::{resolve, resolve::resolve_scheme, server},
 };
 use config::Config;
 use std::sync::{Mutex, Once};
 use tauri::AppHandle;
-use tauri::Manager;
 #[cfg(target_os = "macos")]
+use tauri::Manager;
 use tauri_plugin_autostart::MacosLauncher;
 use tauri_plugin_deep_link::DeepLinkExt;
-use tokio::time::{timeout, Duration};
-use utils::logging::Type;
 
 /// A global singleton handle to the application.
 pub struct AppHandleManager {
@@ -86,136 +81,60 @@ impl AppHandleManager {
 
 #[allow(clippy::panic)]
 pub fn run() {
-    utils::network::NetworkManager::global().init();
-
-    let _ = utils::dirs::init_portable_flag();
-
-    // 异步单例检测
-    AsyncHandler::spawn(move || async move {
-        logging!(info, Type::Setup, true, "开始检查单例实例...");
-        match timeout(Duration::from_secs(3), server::check_singleton()).await {
-            Ok(result) => {
-                if result.is_err() {
-                    logging!(info, Type::Setup, true, "检测到已有应用实例运行");
-                    if let Some(app_handle) = AppHandleManager::global().get() {
-                        app_handle.exit(0);
+    // 单例检测
+    let app_exists: bool = tauri::async_runtime::block_on(async move {
+        if server::check_singleton().await.is_err() {
+            println!("app exists");
+            true
         } else {
-                        std::process::exit(0);
-                    }
-                } else {
-                    logging!(info, Type::Setup, true, "未检测到其他应用实例");
-                }
-            }
-            Err(_) => {
-                logging!(
-                    warn,
-                    Type::Setup,
-                    true,
-                    "单例检查超时，假定没有其他实例运行"
-                );
-            }
+            false
         }
     });
+    if app_exists {
+        return;
+    }
 
     #[cfg(target_os = "linux")]
     std::env::set_var("WEBKIT_DISABLE_DMABUF_RENDERER", "1");
 
     #[cfg(debug_assertions)]
     let devtools = tauri_plugin_devtools::init();
-
     #[allow(unused_mut)]
     let mut builder = tauri::Builder::default()
+        .plugin(tauri_plugin_autostart::init(
+            MacosLauncher::LaunchAgent,
+            None,
+        ))
+        .plugin(tauri_plugin_window_state::Builder::new().build())
         .plugin(tauri_plugin_updater::Builder::new().build())
         .plugin(tauri_plugin_clipboard_manager::init())
         .plugin(tauri_plugin_process::init())
         .plugin(tauri_plugin_global_shortcut::Builder::new().build())
+        .plugin(tauri_plugin_notification::init())
         .plugin(tauri_plugin_fs::init())
         .plugin(tauri_plugin_dialog::init())
         .plugin(tauri_plugin_shell::init())
         .plugin(tauri_plugin_deep_link::init())
+        .plugin(tauri_plugin_window_state::Builder::default().build())
         .setup(|app| {
-            logging!(info, Type::Setup, true, "开始应用初始化...");
-            let mut auto_start_plugin_builder = tauri_plugin_autostart::Builder::new();
-            #[cfg(target_os = "macos")]
-            {
-                auto_start_plugin_builder = auto_start_plugin_builder
-                    .macos_launcher(MacosLauncher::LaunchAgent)
-                    .app_name(app.config().identifier.clone());
-            }
-            let _ = app.handle().plugin(auto_start_plugin_builder.build());
-
             #[cfg(any(target_os = "linux", all(debug_assertions, windows)))]
             {
                 use tauri_plugin_deep_link::DeepLinkExt;
-                logging!(info, Type::Setup, true, "注册深层链接...");
-                logging_error!(Type::System, true, app.deep_link().register_all());
+                log_err!(app.deep_link().register_all());
             }
 
             app.deep_link().on_open_url(|event| {
-                AsyncHandler::spawn(move || {
-                    let url = event.urls().first().map(|u| u.to_string());
-                    async move {
-                        if let Some(url) = url {
-                            logging_error!(Type::Setup, true, resolve_scheme(url).await);
-                        }
+                tauri::async_runtime::spawn(async move {
+                    if let Some(url) = event.urls().first() {
+                        log_err!(resolve_scheme(url.to_string()).await);
                     }
                 });
             });
 
-            // 窗口管理
-            logging!(info, Type::Setup, true, "初始化窗口状态管理...");
-            let window_state_plugin = tauri_plugin_window_state::Builder::new()
-                .with_filename("window_state.json")
-                .with_state_flags(tauri_plugin_window_state::StateFlags::default())
-                .build();
-            let _ = app.handle().plugin(window_state_plugin);
-
-            // 异步处理
-            let app_handle = app.handle().clone();
-            AsyncHandler::spawn(move || async move {
-                logging!(info, Type::Setup, true, "异步执行应用设置...");
-                match timeout(
-                    Duration::from_secs(30),
-                    resolve::resolve_setup_async(&app_handle),
-                )
-                .await
-                {
-                    Ok(_) => {
-                        logging!(info, Type::Setup, true, "应用设置成功完成");
-                    }
-                    Err(_) => {
-                        logging!(
-                            error,
-                            Type::Setup,
-                            true,
-                            "应用设置超时(30秒)，继续执行后续流程"
-                        );
-                    }
-                }
+            tauri::async_runtime::block_on(async move {
+                resolve::resolve_setup(app).await;
             });
 
-            logging!(info, Type::Setup, true, "执行主要设置操作...");
-
-            logging!(info, Type::Setup, true, "初始化AppHandleManager...");
-            AppHandleManager::global().init(app.handle().clone());
-
-            logging!(info, Type::Setup, true, "初始化核心句柄...");
-            core::handle::Handle::global().init(app.handle());
-
-            logging!(info, Type::Setup, true, "初始化配置...");
-            if let Err(e) = utils::init::init_config() {
-                logging!(error, Type::Setup, true, "初始化配置失败: {}", e);
-            }
-
-            logging!(info, Type::Setup, true, "初始化资源...");
-            if let Err(e) = utils::init::init_resources() {
-                logging!(error, Type::Setup, true, "初始化资源失败: {}", e);
-            }
-
-            app.manage(Mutex::new(state::proxy::CmdProxyState::default()));
-            app.manage(Mutex::new(state::lightweight::LightWeightState::default()));
-
-            logging!(info, Type::Setup, true, "初始化完成，继续执行");
             Ok(())
         })
         .invoke_handler(tauri::generate_handler![
@@ -228,29 +147,13 @@ pub fn run() {
             cmd::open_core_dir,
             cmd::get_portable_flag,
             cmd::get_network_interfaces,
-            cmd::get_system_hostname,
-            cmd::restart_app,
-            // 内核管理
-            cmd::start_core,
-            cmd::stop_core,
             cmd::restart_core,
-            // 启动命令
-            cmd::notify_ui_ready,
-            cmd::update_ui_stage,
-            cmd::reset_ui_ready_state,
+            cmd::restart_app,
+            // 添加新的命令
             cmd::get_running_mode,
+            cmd::install_service,
             cmd::get_app_uptime,
             cmd::get_auto_launch_status,
-            cmd::is_admin,
-            // 添加轻量模式相关命令
-            cmd::entry_lightweight_mode,
-            cmd::exit_lightweight_mode,
-            // service 管理
-            cmd::install_service,
-            cmd::uninstall_service,
-            cmd::reinstall_service,
-            cmd::repair_service,
-            cmd::is_service_available,
             // clash
             cmd::get_clash_info,
             cmd::patch_clash_config,
@@ -263,13 +166,11 @@ pub fn run() {
             cmd::invoke_uwp_tool,
             cmd::copy_clash_env,
             cmd::get_proxies,
-            cmd::force_refresh_proxies,
             cmd::get_providers_proxies,
             cmd::save_dns_config,
             cmd::apply_dns_config,
             cmd::check_dns_config_exists,
             cmd::get_dns_config_content,
-            cmd::validate_dns_config,
             // verge
             cmd::get_verge_config,
             cmd::patch_verge_config,
@@ -293,7 +194,6 @@ pub fn run() {
             cmd::delete_profile,
             cmd::read_profile_file,
             cmd::save_profile_file,
-            cmd::get_next_update_time,
             // script validation
             cmd::script_validate_notice,
             cmd::validate_script_file,
@@ -333,7 +233,6 @@ pub fn run() {
 
     app.run(|app_handle, e| match e {
         tauri::RunEvent::Ready | tauri::RunEvent::Resumed => {
-            logging!(info, Type::System, true, "应用就绪或恢复");
             AppHandleManager::global().init(app_handle.clone());
             #[cfg(target_os = "macos")]
             {
@@ -341,7 +240,6 @@ pub fn run() {
                     .get_handle()
                     .get_webview_window("main")
                 {
-                    logging!(info, Type::Window, true, "设置macOS窗口标题");
                     let _ = window.set_title("Clash Verge");
                 }
             }
@@ -361,13 +259,6 @@ pub fn run() {
                 api.prevent_exit();
             }
         }
-        tauri::RunEvent::Exit => {
-            // avoid duplicate cleanup
-            if core::handle::Handle::global().is_exiting() {
-                return;
-            }
-            feat::clean();
-        }
         tauri::RunEvent::WindowEvent { label, event, .. } => {
             if label == "main" {
                 match event {
@@ -377,76 +268,63 @@ pub fn run() {
                         if core::handle::Handle::global().is_exiting() {
                             return;
                         }
-                        log::info!(target: "app", "closing window...");
+                        println!("closing window...");
                         api.prevent_close();
-                        if let Some(window) = core::handle::Handle::global().get_window() {
+                        let window = core::handle::Handle::global().get_window().unwrap();
                         let _ = window.hide();
-                        } else {
-                            logging!(warn, Type::Window, true, "尝试隐藏窗口但窗口不存在");
-                        }
                     }
                     tauri::WindowEvent::Focused(true) => {
                         #[cfg(target_os = "macos")]
                         {
-                            logging_error!(
-                                Type::Hotkey,
-                                true,
-                                hotkey::Hotkey::global().register("CMD+Q", "quit")
-                            );
-                            logging_error!(
-                                Type::Hotkey,
-                                true,
-                                hotkey::Hotkey::global().register("CMD+W", "hide")
-                            );
+                            log_err!(hotkey::Hotkey::global().register("CMD+Q", "quit"));
+                            log_err!(hotkey::Hotkey::global().register("CMD+W", "hide"));
                         }
+
+                        #[cfg(not(target_os = "macos"))]
+                        {
+                            log_err!(hotkey::Hotkey::global().register("Control+Q", "quit"));
+                        };
                         {
                             let is_enable_global_hotkey = Config::verge()
                                 .latest()
                                 .enable_global_hotkey
                                 .unwrap_or(true);
                             if !is_enable_global_hotkey {
-                                logging_error!(Type::Hotkey, true, hotkey::Hotkey::global().init())
+                                log_err!(hotkey::Hotkey::global().init())
                             }
                         }
                     }
                     tauri::WindowEvent::Focused(false) => {
                         #[cfg(target_os = "macos")]
                         {
-                            logging_error!(
-                                Type::Hotkey,
-                                true,
-                                hotkey::Hotkey::global().unregister("CMD+Q")
-                            );
-                            logging_error!(
-                                Type::Hotkey,
-                                true,
-                                hotkey::Hotkey::global().unregister("CMD+W")
-                            );
+                            log_err!(hotkey::Hotkey::global().unregister("CMD+Q"));
+                            log_err!(hotkey::Hotkey::global().unregister("CMD+W"));
                         }
+                        #[cfg(not(target_os = "macos"))]
+                        {
+                            log_err!(hotkey::Hotkey::global().unregister("Control+Q"));
+                        };
                         {
                             let is_enable_global_hotkey = Config::verge()
                                 .latest()
                                 .enable_global_hotkey
                                 .unwrap_or(true);
                             if !is_enable_global_hotkey {
-                                logging_error!(Type::Hotkey, true, hotkey::Hotkey::global().reset())
+                                log_err!(hotkey::Hotkey::global().reset())
                             }
                         }
                     }
                     tauri::WindowEvent::Destroyed => {
                         #[cfg(target_os = "macos")]
                         {
-                            logging_error!(
-                                Type::Hotkey,
-                                true,
-                                hotkey::Hotkey::global().unregister("CMD+Q")
-                            );
-                            logging_error!(
-                                Type::Hotkey,
-                                true,
-                                hotkey::Hotkey::global().unregister("CMD+W")
-                            );
+                            log_err!(hotkey::Hotkey::global().unregister("CMD+Q"));
+                            log_err!(hotkey::Hotkey::global().unregister("CMD+W"));
                         }
+
+                        #[cfg(not(target_os = "macos"))]
+                        {
+                            log_err!(hotkey::Hotkey::global().unregister("Control+Q"));
+                        };
                     }
                     _ => {}
                 }

src-tauri/src/module/lightweight.rs

@@ -1,171 +1,50 @@
-use crate::{
-    config::Config,
-    core::{handle, timer::Timer, tray::Tray},
-    log_err, logging,
-    state::lightweight::LightWeightState,
-    utils::logging::Type,
-};
-
-#[cfg(target_os = "macos")]
-use crate::logging_error;
-#[cfg(target_os = "macos")]
-use crate::AppHandleManager;
-
 use anyhow::{Context, Result};
 use delay_timer::prelude::TaskBuilder;
-use std::sync::Mutex;
 use tauri::{Listener, Manager};
 
+use crate::{
+    config::Config,
+    core::{handle, timer::Timer},
+    log_err,
+};
+
 const LIGHT_WEIGHT_TASK_UID: &str = "light_weight_task";
 
-fn with_lightweight_status<F, R>(f: F) -> R
-where
-    F: FnOnce(&mut LightWeightState) -> R,
-{
-    let app_handle = handle::Handle::global().app_handle().unwrap();
-    let state = app_handle.state::<Mutex<LightWeightState>>();
-    let mut guard = state.lock().unwrap();
-    f(&mut guard)
-}
-
-pub fn run_once_auto_lightweight() {
-    LightWeightState::default().run_once_time(|| {
-        let is_silent_start = Config::verge().data().enable_silent_start.unwrap_or(true);
-        let enable_auto = Config::verge()
-            .data()
-            .enable_auto_light_weight_mode
-            .unwrap_or(true);
-        if enable_auto && is_silent_start {
-            logging!(
-                info,
-                Type::Lightweight,
-                true,
-                "正常创建窗口和添加定时器监听器"
-            );
-            set_lightweight_mode(false);
-            disable_auto_light_weight_mode();
-
-            // 触发托盘更新
-            if let Err(e) = Tray::global().update_part() {
-                log::warn!("Failed to update tray: {}", e);
-            }
-        }
-    });
-}
-
-pub fn auto_lightweight_mode_init() {
-    if let Some(app_handle) = handle::Handle::global().app_handle() {
-        let _ = app_handle.state::<Mutex<LightWeightState>>();
-        let is_silent_start = { Config::verge().data().enable_silent_start }.unwrap_or(false);
-        let enable_auto = { Config::verge().data().enable_auto_light_weight_mode }.unwrap_or(false);
-
-        if enable_auto && is_silent_start {
-            logging!(info, Type::Lightweight, true, "自动轻量模式静默启动");
-            set_lightweight_mode(true);
-            enable_auto_light_weight_mode();
-
-            // 确保托盘状态更新
-            if let Err(e) = Tray::global().update_part() {
-                log::warn!("Failed to update tray: {}", e);
-            }
-        }
-    }
-}
-
-// 检查是否处于轻量模式
-pub fn is_in_lightweight_mode() -> bool {
-    with_lightweight_status(|state| state.is_lightweight)
-}
-
-// 设置轻量模式状态
-fn set_lightweight_mode(value: bool) {
-    with_lightweight_status(|state| {
-        state.set_lightweight_mode(value);
-    });
-
-    // 触发托盘更新
-    if let Err(e) = Tray::global().update_part() {
-        log::warn!("Failed to update tray: {}", e);
-    }
-}
-
 pub fn enable_auto_light_weight_mode() {
-    Timer::global().init().unwrap();
-    logging!(info, Type::Lightweight, true, "开启自动轻量模式");
+    println!("[lightweight_mode] 开启自动轻量模式");
+    log::info!(target: "app", "[lightweight_mode] 开启自动轻量模式");
     setup_window_close_listener();
     setup_webview_focus_listener();
 }
 
 pub fn disable_auto_light_weight_mode() {
-    logging!(info, Type::Lightweight, true, "关闭自动轻量模式");
+    println!("[lightweight_mode] 关闭自动轻量模式");
+    log::info!(target: "app", "[lightweight_mode] 关闭自动轻量模式");
     let _ = cancel_light_weight_timer();
     cancel_window_close_listener();
 }
 
 pub fn entry_lightweight_mode() {
-    use crate::utils::window_manager::WindowManager;
-
-    let result = WindowManager::hide_main_window();
-    logging!(
-        info,
-        Type::Lightweight,
-        true,
-        "轻量模式隐藏窗口结果: {:?}",
-        result
-    );
+    println!("尝试进入轻量模式。motherfucker");
+    if let Some(window) = handle::Handle::global().get_window() {
+        log_err!(window.close());
+    }
 
     if let Some(window) = handle::Handle::global().get_window() {
         if let Some(webview) = window.get_webview_window("main") {
-            let _ = webview.destroy();
+            log_err!(webview.destroy());
+            println!("[lightweight_mode] 轻量模式已开启");
+            log::info!(target: "app", "[lightweight_mode] 轻量模式已开启");
         }
-        #[cfg(target_os = "macos")]
-        AppHandleManager::global().set_activation_policy_accessory();
-        logging!(info, Type::Lightweight, true, "轻量模式已开启");
     }
-    set_lightweight_mode(true);
-    let _ = cancel_light_weight_timer();
-
-    // 更新托盘显示
-    let _tray = crate::core::tray::Tray::global();
-}
-
-// 添加从轻量模式恢复的函数
-pub fn exit_lightweight_mode() {
-    // 确保当前确实处于轻量模式才执行退出操作
-    if !is_in_lightweight_mode() {
-        logging!(info, Type::Lightweight, true, "当前不在轻量模式，无需退出");
-        return;
-    }
-
-    set_lightweight_mode(false);
-    logging!(info, Type::Lightweight, true, "正在退出轻量模式");
-
-    // macOS激活策略
-    #[cfg(target_os = "macos")]
-    AppHandleManager::global().set_activation_policy_regular();
-
-    // 重置UI就绪状态
-    crate::utils::resolve::reset_ui_ready();
-
-    // 更新托盘显示
-    let _tray = crate::core::tray::Tray::global();
-}
-
-#[cfg(target_os = "macos")]
-pub fn add_light_weight_timer() {
-    logging_error!(Type::Lightweight, setup_light_weight_timer());
 }
 
 fn setup_window_close_listener() -> u32 {
     if let Some(window) = handle::Handle::global().get_window() {
         let handler = window.listen("tauri://close-requested", move |_event| {
             let _ = setup_light_weight_timer();
-            logging!(
-                info,
-                Type::Lightweight,
-                true,
-                "监听到关闭请求，开始轻量模式计时"
-            );
+            println!("[lightweight_mode] 监听到关闭请求，开始轻量模式计时");
+            log::info!(target: "app", "[lightweight_mode] 监听到关闭请求，开始轻量模式计时");
         });
         return handler;
     }
@@ -176,11 +55,8 @@ fn setup_webview_focus_listener() -> u32 {
     if let Some(window) = handle::Handle::global().get_window() {
         let handler = window.listen("tauri://focus", move |_event| {
             log_err!(cancel_light_weight_timer());
-            logging!(
-                info,
-                Type::Lightweight,
-                "监听到窗口获得焦点，取消轻量模式计时"
-            );
+            println!("[lightweight_mode] 监听到窗口获得焦点，取消轻量模式计时");
+            log::info!(target: "app", "[lightweight_mode] 监听到窗口获得焦点，取消轻量模式计时");
         });
         return handler;
     }
@@ -190,60 +66,58 @@ fn setup_webview_focus_listener() -> u32 {
 fn cancel_window_close_listener() {
     if let Some(window) = handle::Handle::global().get_window() {
         window.unlisten(setup_window_close_listener());
-        logging!(info, Type::Lightweight, true, "取消了窗口关闭监听");
+        println!("[lightweight_mode] 取消了窗口关闭监听");
+        log::info!(target: "app", "[lightweight_mode] 取消了窗口关闭监听");
     }
 }
 
 fn setup_light_weight_timer() -> Result<()> {
     Timer::global().init()?;
+
+    let mut timer_map = Timer::global().timer_map.write();
+    let delay_timer = Timer::global().delay_timer.write();
+    let mut timer_count = Timer::global().timer_count.lock();
+
+    let task_id = *timer_count;
+    *timer_count += 1;
+
     let once_by_minutes = Config::verge()
         .latest()
         .auto_light_weight_minutes
+        .clone()
         .unwrap_or(10);
 
-    // 获取task_id
-    let task_id = {
-        let mut timer_count = Timer::global().timer_count.lock();
-        let id = *timer_count;
-        *timer_count += 1;
-        id
-    };
-
-    // 创建任务
     let task = TaskBuilder::default()
         .set_task_id(task_id)
         .set_maximum_parallel_runnable_num(1)
         .set_frequency_once_by_minutes(once_by_minutes)
         .spawn_async_routine(move || async move {
-            logging!(info, Type::Timer, true, "计时器到期，开始进入轻量模式");
+            println!("[lightweight_mode] 计时器到期，开始进入轻量模式");
+            log::info!(target: "app",
+                "[lightweight_mode] 计时器到期，开始进入轻量模式"
+            );
             entry_lightweight_mode();
         })
-        .context("failed to create timer task")?;
+        .context("failed to create light weight timer task")?;
 
-    // 添加任务到定时器
-    {
-        let delay_timer = Timer::global().delay_timer.write();
     delay_timer
         .add_task(task)
-            .context("failed to add timer task")?;
-    }
+        .context("failed to add light weight timer task")?;
 
-    // 更新任务映射
-    {
-        let mut timer_map = Timer::global().timer_map.write();
     let timer_task = crate::core::timer::TimerTask {
         task_id,
         interval_minutes: once_by_minutes,
         last_run: chrono::Local::now().timestamp(),
     };
-        timer_map.insert(LIGHT_WEIGHT_TASK_UID.to_string(), timer_task);
-    }
 
-    logging!(
-        info,
-        Type::Timer,
-        true,
-        "计时器已设置，{} 分钟后将自动进入轻量模式",
+    timer_map.insert(LIGHT_WEIGHT_TASK_UID.to_string(), timer_task);
+
+    println!(
+        "[lightweight_mode] 轻量模式计时器已设置，{} 分钟后将自动进入轻量模式",
+        once_by_minutes
+    );
+    log::info!(target: "app",
+        "[lightweight_mode] 轻量模式计时器已设置，{} 分钟后将自动进入轻量模式",
         once_by_minutes
     );
 
@@ -257,9 +131,11 @@ fn cancel_light_weight_timer() -> Result<()> {
     if let Some(task) = timer_map.remove(LIGHT_WEIGHT_TASK_UID) {
         delay_timer
             .remove_task(task.task_id)
-            .context("failed to remove timer task")?;
-        logging!(info, Type::Timer, true, "计时器已取消");
+            .context("failed to remove light weight timer task")?;
     }
 
+    println!("[lightweight_mode] 轻量模式计时器已取消");
+    log::info!(target: "app", "[lightweight_mode] 轻量模式计时器已取消");
+
     Ok(())
 }

src-tauri/src/module/mihomo.rs

@@ -1,94 +1,43 @@
 use crate::config::Config;
 use mihomo_api;
-use once_cell::sync::Lazy;
-use parking_lot::{Mutex, RwLock};
-use std::time::{Duration, Instant};
-use tauri::http::HeaderMap;
+use once_cell::sync::{Lazy, OnceCell};
+use std::sync::Mutex;
+use tauri::http::{HeaderMap, HeaderValue};
 #[cfg(target_os = "macos")]
-use tauri::http::HeaderValue;
-
-// 缓存的最大有效期（5秒）
-const CACHE_TTL: Duration = Duration::from_secs(5);
+use tokio_tungstenite::tungstenite::http;
 
 #[derive(Debug, Clone, Default, PartialEq)]
 pub struct Rate {
     pub up: u64,
     pub down: u64,
 }
-// 缓存MihomoManager实例
-struct MihomoCache {
-    manager: mihomo_api::MihomoManager,
-    created_at: Instant,
-    server: String,
-}
-// 使用RwLock替代Mutex，允许多个读取操作并发进行
+
 pub struct MihomoManager {
-    mihomo_cache: RwLock<Option<MihomoCache>>,
-    create_lock: Mutex<()>,
+    mihomo: Mutex<OnceCell<mihomo_api::MihomoManager>>,
 }
 
 impl MihomoManager {
     fn __global() -> &'static MihomoManager {
         static INSTANCE: Lazy<MihomoManager> = Lazy::new(|| MihomoManager {
-            mihomo_cache: RwLock::new(None),
-            create_lock: Mutex::new(()),
+            mihomo: Mutex::new(OnceCell::new()),
         });
         &INSTANCE
     }
 
     pub fn global() -> mihomo_api::MihomoManager {
         let instance = MihomoManager::__global();
+        let (current_server, headers) = MihomoManager::get_clash_client_info().unwrap();
 
-        // 尝试从缓存读取（只需读锁）
-        {
-            let cache = instance.mihomo_cache.read();
-            if let Some(cache_entry) = &*cache {
-                let (current_server, _) = MihomoManager::get_clash_client_info()
-                    .unwrap_or_else(|| (String::new(), HeaderMap::new()));
-
-                // 检查缓存是否有效
-                if cache_entry.server == current_server
-                    && cache_entry.created_at.elapsed() < CACHE_TTL
-                {
-                    return cache_entry.manager.clone();
-                }
+        let lock = instance.mihomo.lock().unwrap();
+        if let Some(mihomo) = lock.get() {
+            if mihomo.get_mihomo_server() == current_server {
+                return mihomo.clone();
             }
         }
 
-        // 缓存无效，获取创建锁
-        let _create_guard = instance.create_lock.lock();
-
-        // 再次检查缓存（双重检查锁定模式）
-        {
-            let cache = instance.mihomo_cache.read();
-            if let Some(cache_entry) = &*cache {
-                let (current_server, _) = MihomoManager::get_clash_client_info()
-                    .unwrap_or_else(|| (String::new(), HeaderMap::new()));
-
-                if cache_entry.server == current_server
-                    && cache_entry.created_at.elapsed() < CACHE_TTL
-                {
-                    return cache_entry.manager.clone();
-                }
-            }
-        }
-
-        // 创建新实例
-        let (current_server, headers) = MihomoManager::get_clash_client_info()
-            .unwrap_or_else(|| (String::new(), HeaderMap::new()));
-        let manager = mihomo_api::MihomoManager::new(current_server.clone(), headers);
-
-        // 更新缓存
-        {
-            let mut cache = instance.mihomo_cache.write();
-            *cache = Some(MihomoCache {
-                manager: manager.clone(),
-                created_at: Instant::now(),
-                server: current_server,
-            });
-        }
-
-        manager
+        lock.set(mihomo_api::MihomoManager::new(current_server, headers))
+            .ok();
+        lock.get().unwrap().clone()
     }
 }
 
@@ -105,32 +54,17 @@ impl MihomoManager {
 
         Some((server, headers))
     }
-
-    // 提供默认值的版本，避免在connection_info为None时panic
-    #[cfg(target_os = "macos")]
-    fn get_clash_client_info_or_default() -> (String, HeaderMap) {
-        Self::get_clash_client_info().unwrap_or_else(|| {
-            let mut headers = HeaderMap::new();
-            headers.insert("Content-Type", "application/json".parse().unwrap());
-            ("http://127.0.0.1:9090".to_string(), headers)
-        })
-    }
-
     #[cfg(target_os = "macos")]
     pub fn get_traffic_ws_url() -> (String, HeaderValue) {
-        let (url, headers) = MihomoManager::get_clash_client_info_or_default();
+        let (url, headers) = MihomoManager::get_clash_client_info().unwrap();
         let ws_url = url.replace("http://", "ws://") + "/traffic";
         let auth = headers
             .get("Authorization")
-            .map(|val| val.to_str().unwrap_or("").to_string())
-            .unwrap_or_default();
-
-        // 创建默认的空HeaderValue而不是使用unwrap_or_default
-        let token = match HeaderValue::from_str(&auth) {
-            Ok(v) => v,
-            Err(_) => HeaderValue::from_static(""),
-        };
-
+            .unwrap()
+            .to_str()
+            .unwrap()
+            .to_string();
+        let token = http::header::HeaderValue::from_str(&auth).unwrap();
         (ws_url, token)
     }
 }

src-tauri/src/module/mod.rs

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

src-tauri/src/module/sysinfo.rs

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

src-tauri/src/process/async_handler.rs

@@ -1,14 +0,0 @@
-use std::future::Future;
-use tauri::{async_runtime, async_runtime::JoinHandle};
-
-pub struct AsyncHandler;
-
-impl AsyncHandler {
-    pub fn spawn<F, Fut>(f: F) -> JoinHandle<()>
-    where
-        F: FnOnce() -> Fut + Send + 'static,
-        Fut: Future<Output = ()> + Send + 'static,
-    {
-        async_runtime::spawn(f())
-    }
-}

src-tauri/src/process/mod.rs

@@ -1,2 +0,0 @@
-mod async_handler;
-pub use async_handler::AsyncHandler;

src-tauri/src/state/lightweight.rs

@@ -1,44 +0,0 @@
-use std::sync::{Arc, Once, OnceLock};
-
-use crate::{logging, utils::logging::Type};
-
-#[derive(Clone)]
-pub struct LightWeightState {
-    #[allow(unused)]
-    once: Arc<Once>,
-    pub is_lightweight: bool,
-}
-
-impl LightWeightState {
-    pub fn new() -> Self {
-        Self {
-            once: Arc::new(Once::new()),
-            is_lightweight: false,
-        }
-    }
-
-    #[allow(unused)]
-    pub fn run_once_time<F>(&self, f: F)
-    where
-        F: FnOnce() + Send + 'static,
-    {
-        self.once.call_once(f);
-    }
-
-    pub fn set_lightweight_mode(&mut self, value: bool) -> &Self {
-        self.is_lightweight = value;
-        if value {
-            logging!(info, Type::Lightweight, true, "轻量模式已开启");
-        } else {
-            logging!(info, Type::Lightweight, true, "轻量模式已关闭");
-        }
-        self
-    }
-}
-
-impl Default for LightWeightState {
-    fn default() -> Self {
-        static INSTANCE: OnceLock<LightWeightState> = OnceLock::new();
-        INSTANCE.get_or_init(LightWeightState::new).clone()
-    }
-}

src-tauri/src/state/mod.rs

@@ -1,5 +0,0 @@
-// Tauri Manager 会进行 Arc 管理，无需额外 Arc
-// https://tauri.app/develop/state-management/#do-you-need-arc
-
-pub mod lightweight;
-pub mod proxy;

src-tauri/src/state/proxy.rs

@@ -1,19 +0,0 @@
-use serde_json::Value;
-
-pub struct CmdProxyState {
-    pub last_refresh_time: std::time::Instant,
-    pub need_refresh: bool,
-    pub proxies: Box<Value>,
-    pub providers_proxies: Box<Value>,
-}
-
-impl Default for CmdProxyState {
-    fn default() -> Self {
-        Self {
-            last_refresh_time: std::time::Instant::now(),
-            need_refresh: true,
-            proxies: Box::new(Value::Null),
-            providers_proxies: Box::new(Value::Null),
-        }
-    }
-}

src-tauri/src/utils/autostart.rs

@@ -1,116 +0,0 @@
-#[cfg(target_os = "windows")]
-use anyhow::{anyhow, Result};
-#[cfg(target_os = "windows")]
-use log::info;
-
-#[cfg(target_os = "windows")]
-use std::{fs, path::Path, path::PathBuf};
-
-/// Windows 下的开机启动文件夹路径
-#[cfg(target_os = "windows")]
-pub fn get_startup_dir() -> Result<PathBuf> {
-    let appdata = std::env::var("APPDATA").map_err(|_| anyhow!("无法获取 APPDATA 环境变量"))?;
-
-    let startup_dir = Path::new(&appdata)
-        .join("Microsoft")
-        .join("Windows")
-        .join("Start Menu")
-        .join("Programs")
-        .join("Startup");
-
-    if !startup_dir.exists() {
-        return Err(anyhow!("Startup 目录不存在: {:?}", startup_dir));
-    }
-
-    Ok(startup_dir)
-}
-
-/// 获取当前可执行文件路径
-#[cfg(target_os = "windows")]
-pub fn get_exe_path() -> Result<PathBuf> {
-    let exe_path =
-        std::env::current_exe().map_err(|e| anyhow!("无法获取当前可执行文件路径: {}", e))?;
-
-    Ok(exe_path)
-}
-
-/// 创建快捷方式
-#[cfg(target_os = "windows")]
-pub fn create_shortcut() -> Result<()> {
-    let exe_path = get_exe_path()?;
-    let startup_dir = get_startup_dir()?;
-    let shortcut_path = startup_dir.join("Clash-Verge.lnk");
-
-    // 如果快捷方式已存在，直接返回成功
-    if shortcut_path.exists() {
-        info!(target: "app", "启动快捷方式已存在");
-        return Ok(());
-    }
-
-    // 使用 PowerShell 创建快捷方式
-    let powershell_command = format!(
-        "$WshShell = New-Object -ComObject WScript.Shell; \
-         $Shortcut = $WshShell.CreateShortcut('{}'); \
-         $Shortcut.TargetPath = '{}'; \
-         $Shortcut.Save()",
-        shortcut_path.to_string_lossy().replace("\\", "\\\\"),
-        exe_path.to_string_lossy().replace("\\", "\\\\")
-    );
-
-    let output = std::process::Command::new("powershell")
-        .args(["-Command", &powershell_command])
-        .output()
-        .map_err(|e| anyhow!("执行 PowerShell 命令失败: {}", e))?;
-
-    if !output.status.success() {
-        let error_msg = String::from_utf8_lossy(&output.stderr);
-        return Err(anyhow!("创建快捷方式失败: {}", error_msg));
-    }
-
-    info!(target: "app", "成功创建启动快捷方式");
-    Ok(())
-}
-
-/// 删除快捷方式
-#[cfg(target_os = "windows")]
-pub fn remove_shortcut() -> Result<()> {
-    let startup_dir = get_startup_dir()?;
-    let shortcut_path = startup_dir.join("Clash-Verge.lnk");
-
-    // 如果快捷方式不存在，直接返回成功
-    if !shortcut_path.exists() {
-        info!(target: "app", "启动快捷方式不存在，无需删除");
-        return Ok(());
-    }
-
-    // 删除快捷方式
-    fs::remove_file(&shortcut_path).map_err(|e| anyhow!("删除快捷方式失败: {}", e))?;
-
-    info!(target: "app", "成功删除启动快捷方式");
-    Ok(())
-}
-
-/// 检查快捷方式是否存在
-#[cfg(target_os = "windows")]
-pub fn is_shortcut_enabled() -> Result<bool> {
-    let startup_dir = get_startup_dir()?;
-    let shortcut_path = startup_dir.join("Clash-Verge.lnk");
-
-    Ok(shortcut_path.exists())
-}
-
-// 非 Windows 平台使用的空方法
-// #[cfg(not(target_os = "windows"))]
-// pub fn create_shortcut() -> Result<()> {
-//     Ok(())
-// }
-
-// #[cfg(not(target_os = "windows"))]
-// pub fn remove_shortcut() -> Result<()> {
-//     Ok(())
-// }
-
-// #[cfg(not(target_os = "windows"))]
-// pub fn is_shortcut_enabled() -> Result<bool> {
-//     Ok(false)
-// }

src-tauri/src/utils/dirs.rs

@@ -49,55 +49,7 @@ pub fn app_home_dir() -> Result<PathBuf> {
             .ok_or(anyhow::anyhow!("failed to get the portable app dir"))?;
         return Ok(PathBuf::from(app_dir).join(".config").join(APP_ID));
     }
-
-    // 避免在Handle未初始化时崩溃
-    let app_handle = match handle::Handle::global().app_handle() {
-        Some(handle) => handle,
-        None => {
-            log::warn!(target: "app", "app_handle not initialized, using default path");
-            // 使用可执行文件目录作为备用
-            let exe_path = tauri::utils::platform::current_exe()?;
-            let exe_dir = exe_path
-                .parent()
-                .ok_or(anyhow::anyhow!("failed to get executable directory"))?;
-
-            // 使用系统临时目录 + 应用ID
-            #[cfg(target_os = "windows")]
-            {
-                if let Some(local_app_data) = std::env::var_os("LOCALAPPDATA") {
-                    let path = PathBuf::from(local_app_data).join(APP_ID);
-                    return Ok(path);
-                }
-            }
-
-            #[cfg(target_os = "macos")]
-            {
-                if let Some(home) = std::env::var_os("HOME") {
-                    let path = PathBuf::from(home)
-                        .join("Library")
-                        .join("Application Support")
-                        .join(APP_ID);
-                    return Ok(path);
-                }
-            }
-
-            #[cfg(target_os = "linux")]
-            {
-                if let Some(home) = std::env::var_os("HOME") {
-                    let path = PathBuf::from(home)
-                        .join(".local")
-                        .join("share")
-                        .join(APP_ID);
-                    return Ok(path);
-                }
-            }
-
-            // 如果无法获取系统目录，则回退到可执行文件目录
-            let fallback_dir = PathBuf::from(exe_dir).join(".config").join(APP_ID);
-            log::warn!(target: "app", "Using fallback data directory: {:?}", fallback_dir);
-            return Ok(fallback_dir);
-        }
-    };
+    let app_handle = handle::Handle::global().app_handle().unwrap();
 
     match app_handle.path().data_dir() {
         Ok(dir) => Ok(dir.join(APP_ID)),
@@ -110,20 +62,7 @@ pub fn app_home_dir() -> Result<PathBuf> {
 
 /// get the resources dir
 pub fn app_resources_dir() -> Result<PathBuf> {
-    // 避免在Handle未初始化时崩溃
-    let app_handle = match handle::Handle::global().app_handle() {
-        Some(handle) => handle,
-        None => {
-            log::warn!(target: "app", "app_handle not initialized in app_resources_dir, using fallback");
-            // 使用可执行文件目录作为备用
-            let exe_dir = tauri::utils::platform::current_exe()?
-                .parent()
-                .ok_or(anyhow::anyhow!("failed to get executable directory"))?
-                .to_path_buf();
-            return Ok(exe_dir.join("resources"));
-        }
-    };
-
+    let app_handle = handle::Handle::global().app_handle().unwrap();
     match app_handle.path().resource_dir() {
         Ok(dir) => Ok(dir.join("resources")),
         Err(e) => {
@@ -138,36 +77,6 @@ pub fn app_profiles_dir() -> Result<PathBuf> {
     Ok(app_home_dir()?.join("profiles"))
 }
 
-/// icons dir
-pub fn app_icons_dir() -> Result<PathBuf> {
-    Ok(app_home_dir()?.join("icons"))
-}
-
-pub fn find_target_icons(target: &str) -> Result<Option<String>> {
-    let icons_dir = app_icons_dir()?;
-    let mut matching_files = Vec::new();
-
-    for entry in fs::read_dir(icons_dir)? {
-        let entry = entry?;
-        let path = entry.path();
-
-        if let Some(file_name) = path.file_name().and_then(|n| n.to_str()) {
-            if file_name.starts_with(target)
-                && (file_name.ends_with(".ico") || file_name.ends_with(".png"))
-            {
-                matching_files.push(path);
-            }
-        }
-    }
-
-    if matching_files.is_empty() {
-        Ok(None)
-    } else {
-        let first = path_to_str(matching_files.first().unwrap())?;
-        Ok(Some(first.to_string()))
-    }
-}
-
 /// logs dir
 pub fn app_logs_dir() -> Result<PathBuf> {
     Ok(app_home_dir()?.join("logs"))
@@ -187,14 +96,12 @@ pub fn profiles_path() -> Result<PathBuf> {
 
 #[cfg(target_os = "macos")]
 pub fn service_path() -> Result<PathBuf> {
-    let res_dir = app_resources_dir()?;
-    Ok(res_dir.join("clash-verge-service"))
+    Ok(app_resources_dir()?.join("clash-verge-service"))
 }
 
 #[cfg(windows)]
 pub fn service_path() -> Result<PathBuf> {
-    let res_dir = app_resources_dir()?;
-    Ok(res_dir.join("clash-verge-service.exe"))
+    Ok(app_resources_dir()?.join("clash-verge-service.exe"))
 }
 
 pub fn service_log_file() -> Result<PathBuf> {

src-tauri/src/utils/error.rs

@@ -0,0 +1,40 @@
+use crate::log_err;
+use anyhow;
+use std::{
+    backtrace::{Backtrace, BacktraceStatus},
+    thread,
+};
+
+pub fn redirect_panic_to_log() {
+    std::panic::set_hook(Box::new(move |panic_info| {
+        let thread = thread::current();
+        let thread_name = thread.name().unwrap_or("<unnamed>");
+        let payload = panic_info.payload();
+
+        let payload = if let Some(s) = payload.downcast_ref::<&str>() {
+            &**s
+        } else if let Some(s) = payload.downcast_ref::<String>() {
+            s
+        } else {
+            &format!("{:?}", payload)
+        };
+
+        let location = panic_info
+            .location()
+            .map(|l| l.to_string())
+            .unwrap_or("unknown location".to_string());
+
+        let backtrace = Backtrace::capture();
+        let backtrace = if backtrace.status() == BacktraceStatus::Captured {
+            &format!("stack backtrace:\n{}", backtrace)
+        } else {
+            "note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace"
+        };
+
+        let err: Result<(), anyhow::Error> = Err(anyhow::anyhow!(format!(
+            "thread '{}' panicked at {}:\n{}\n{}",
+            thread_name, location, payload, backtrace
+        )));
+        log_err!(err);
+    }));
+}

src-tauri/src/utils/help.rs

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

src-tauri/src/utils/init.rs

@@ -142,8 +142,8 @@ pub fn delete_log() -> Result<()> {
 fn init_dns_config() -> Result<()> {
     use serde_yaml::Value;
 
-    // 创建DNS子配置
-    let dns_config = serde_yaml::Mapping::from_iter([
+    // 获取默认DNS配置
+    let default_dns_config = serde_yaml::Mapping::from_iter([
         ("enable".into(), Value::Bool(true)),
         ("listen".into(), Value::String(":53".into())),
         ("enhanced-mode".into(), Value::String("fake-ip".into())),
@@ -177,11 +177,8 @@ fn init_dns_config() -> Result<()> {
         (
             "default-nameserver".into(),
             Value::Sequence(vec![
-                Value::String("system".into()),
                 Value::String("223.6.6.6".into()),
                 Value::String("8.8.8.8".into()),
-                Value::String("2400:3200::1".into()),
-                Value::String("2001:4860:4860::8888".into()),
             ]),
         ),
         (
@@ -192,7 +189,14 @@ fn init_dns_config() -> Result<()> {
                 Value::String("https://dns.alidns.com/dns-query".into()),
             ]),
         ),
-        ("fallback".into(), Value::Sequence(vec![])),
+        (
+            "fallback".into(),
+            Value::Sequence(vec![
+                Value::String("https://dns.alidns.com/dns-query".into()),
+                Value::String("https://dns.google/dns-query".into()),
+                Value::String("https://cloudflare-dns.com/dns-query".into()),
+            ]),
+        ),
         (
             "nameserver-policy".into(),
             Value::Mapping(serde_yaml::Mapping::new()),
@@ -202,7 +206,6 @@ fn init_dns_config() -> Result<()> {
             Value::Sequence(vec![
                 Value::String("https://doh.pub/dns-query".into()),
                 Value::String("https://dns.alidns.com/dns-query".into()),
-                Value::String("tls://223.5.5.5".into()),
             ]),
         ),
         ("direct-nameserver".into(), Value::Sequence(vec![])),
@@ -231,12 +234,6 @@ fn init_dns_config() -> Result<()> {
         ),
     ]);
 
-    // 获取默认DNS和host配置
-    let default_dns_config = serde_yaml::Mapping::from_iter([
-        ("dns".into(), Value::Mapping(dns_config)),
-        ("hosts".into(), Value::Mapping(serde_yaml::Mapping::new())),
-    ]);
-
     // 检查DNS配置文件是否存在
     let app_dir = dirs::app_home_dir()?;
     let dns_path = app_dir.join("dns_config.yaml");
@@ -286,9 +283,6 @@ pub fn init_config() -> Result<()> {
         <Result<()>>::Ok(())
     }));
 
-    // 验证并修正verge.yaml中的clash_core配置
-    crate::log_err!(IVerge::validate_and_fix_config());
-
     crate::log_err!(dirs::profiles_path().map(|path| {
         if !path.exists() {
             help::save_yaml(&path, &IProfiles::template(), Some("# Clash Verge"))?;
@@ -306,11 +300,15 @@ pub fn init_config() -> Result<()> {
 /// after tauri setup
 pub fn init_resources() -> Result<()> {
     let app_dir = dirs::app_home_dir()?;
+    let test_dir = app_dir.join("test");
     let res_dir = dirs::app_resources_dir()?;
 
     if !app_dir.exists() {
         let _ = fs::create_dir_all(&app_dir);
     }
+    if !test_dir.exists() {
+        let _ = fs::create_dir_all(&test_dir);
+    }
     if !res_dir.exists() {
         let _ = fs::create_dir_all(&res_dir);
     }
@@ -322,6 +320,7 @@ pub fn init_resources() -> Result<()> {
     for file in file_list.iter() {
         let src_path = res_dir.join(file);
         let dest_path = app_dir.join(file);
+        let test_dest_path = test_dir.join(file);
         log::debug!(target: "app", "src_path: {src_path:?}, dest_path: {dest_path:?}");
 
         let handle_copy = |dest: &PathBuf| {
@@ -333,6 +332,9 @@ pub fn init_resources() -> Result<()> {
             };
         };
 
+        if src_path.exists() && !test_dest_path.exists() {
+            handle_copy(&test_dest_path);
+        }
         if src_path.exists() && !dest_path.exists() {
             handle_copy(&dest_path);
             continue;

src-tauri/src/utils/logging.rs

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

src-tauri/src/utils/mod.rs

@@ -1,11 +1,8 @@
-pub mod autostart;
 pub mod dirs;
+pub mod error;
 pub mod help;
 pub mod i18n;
 pub mod init;
-pub mod logging;
-pub mod network;
 pub mod resolve;
 pub mod server;
 pub mod tmpl;
-pub mod window_manager;

src-tauri/src/utils/network.rs

@@ -1,426 +0,0 @@
-use anyhow::Result;
-use lazy_static::lazy_static;
-use reqwest::{Client, ClientBuilder, Proxy, RequestBuilder, Response};
-use std::{
-    sync::{Arc, Mutex, Once},
-    time::{Duration, Instant},
-};
-use tokio::runtime::{Builder, Runtime};
-
-use crate::{config::Config, logging, utils::logging::Type};
-
-// HTTP2 相关
-const H2_CONNECTION_WINDOW_SIZE: u32 = 1024 * 1024;
-const H2_STREAM_WINDOW_SIZE: u32 = 1024 * 1024;
-const H2_MAX_FRAME_SIZE: u32 = 16 * 1024;
-const H2_KEEP_ALIVE_INTERVAL: Duration = Duration::from_secs(5);
-const H2_KEEP_ALIVE_TIMEOUT: Duration = Duration::from_secs(5);
-const DEFAULT_CONNECT_TIMEOUT: Duration = Duration::from_secs(10);
-const DEFAULT_REQUEST_TIMEOUT: Duration = Duration::from_secs(30);
-const POOL_MAX_IDLE_PER_HOST: usize = 5;
-const POOL_IDLE_TIMEOUT: Duration = Duration::from_secs(15);
-
-/// 网络管理器
-pub struct NetworkManager {
-    runtime: Arc<Runtime>,
-    self_proxy_client: Arc<Mutex<Option<Client>>>,
-    system_proxy_client: Arc<Mutex<Option<Client>>>,
-    no_proxy_client: Arc<Mutex<Option<Client>>>,
-    init: Once,
-    last_connection_error: Arc<Mutex<Option<(Instant, String)>>>,
-    connection_error_count: Arc<Mutex<usize>>,
-}
-
-lazy_static! {
-    static ref NETWORK_MANAGER: NetworkManager = NetworkManager::new();
-}
-
-impl NetworkManager {
-    fn new() -> Self {
-        // 创建专用的异步运行时，线程数限制为4个
-        let runtime = Builder::new_multi_thread()
-            .worker_threads(4)
-            .thread_name("clash-verge-network")
-            .enable_io()
-            .enable_time()
-            .build()
-            .expect("Failed to create network runtime");
-
-        NetworkManager {
-            runtime: Arc::new(runtime),
-            self_proxy_client: Arc::new(Mutex::new(None)),
-            system_proxy_client: Arc::new(Mutex::new(None)),
-            no_proxy_client: Arc::new(Mutex::new(None)),
-            init: Once::new(),
-            last_connection_error: Arc::new(Mutex::new(None)),
-            connection_error_count: Arc::new(Mutex::new(0)),
-        }
-    }
-
-    pub fn global() -> &'static Self {
-        &NETWORK_MANAGER
-    }
-
-    /// 初始化网络客户端
-    pub fn init(&self) {
-        self.init.call_once(|| {
-            self.runtime.spawn(async {
-                logging!(info, Type::Network, true, "初始化网络管理器");
-
-                // 创建无代理客户端
-                let no_proxy_client = ClientBuilder::new()
-                    .use_rustls_tls()
-                    .no_proxy()
-                    .pool_max_idle_per_host(POOL_MAX_IDLE_PER_HOST)
-                    .pool_idle_timeout(POOL_IDLE_TIMEOUT)
-                    .connect_timeout(Duration::from_secs(10))
-                    .timeout(Duration::from_secs(30))
-                    .build()
-                    .expect("Failed to build no_proxy client");
-
-                let mut no_proxy_guard = NETWORK_MANAGER.no_proxy_client.lock().unwrap();
-                *no_proxy_guard = Some(no_proxy_client);
-
-                logging!(info, Type::Network, true, "网络管理器初始化完成");
-            });
-        });
-    }
-
-    fn record_connection_error(&self, error: &str) {
-        let mut last_error = self.last_connection_error.lock().unwrap();
-        *last_error = Some((Instant::now(), error.to_string()));
-
-        let mut error_count = self.connection_error_count.lock().unwrap();
-        *error_count += 1;
-    }
-
-    fn should_reset_clients(&self) -> bool {
-        let error_count = *self.connection_error_count.lock().unwrap();
-        let last_error = self.last_connection_error.lock().unwrap();
-
-        if error_count > 5 {
-            return true;
-        }
-
-        if let Some((time, _)) = *last_error {
-            if time.elapsed() < Duration::from_secs(30) && error_count > 2 {
-                return true;
-            }
-        }
-
-        false
-    }
-
-    pub fn reset_clients(&self) {
-        logging!(info, Type::Network, true, "正在重置所有HTTP客户端");
-        {
-            let mut client = self.self_proxy_client.lock().unwrap();
-            *client = None;
-        }
-        {
-            let mut client = self.system_proxy_client.lock().unwrap();
-            *client = None;
-        }
-        {
-            let mut client = self.no_proxy_client.lock().unwrap();
-            *client = None;
-        }
-        {
-            let mut error_count = self.connection_error_count.lock().unwrap();
-            *error_count = 0;
-        }
-    }
-    /*
-       /// 获取或创建自代理客户端
-       fn get_or_create_self_proxy_client(&self) -> Client {
-           if self.should_reset_clients() {
-               self.reset_clients();
-           }
-
-           let mut client_guard = self.self_proxy_client.lock().unwrap();
-
-           if client_guard.is_none() {
-               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}");
-
-               let mut builder = ClientBuilder::new()
-                   .use_rustls_tls()
-                   .pool_max_idle_per_host(POOL_MAX_IDLE_PER_HOST)
-                   .pool_idle_timeout(POOL_IDLE_TIMEOUT)
-                   .connect_timeout(DEFAULT_CONNECT_TIMEOUT)
-                   .timeout(DEFAULT_REQUEST_TIMEOUT)
-                   .http2_initial_stream_window_size(H2_STREAM_WINDOW_SIZE)
-                   .http2_initial_connection_window_size(H2_CONNECTION_WINDOW_SIZE)
-                   .http2_adaptive_window(true)
-                   .http2_keep_alive_interval(Some(H2_KEEP_ALIVE_INTERVAL))
-                   .http2_keep_alive_timeout(H2_KEEP_ALIVE_TIMEOUT)
-                   .http2_max_frame_size(H2_MAX_FRAME_SIZE)
-                   .tcp_keepalive(Some(Duration::from_secs(10)))
-                   .http2_max_header_list_size(16 * 1024);
-
-               if let Ok(proxy) = Proxy::http(&proxy_scheme) {
-                   builder = builder.proxy(proxy);
-               }
-               if let Ok(proxy) = Proxy::https(&proxy_scheme) {
-                   builder = builder.proxy(proxy);
-               }
-               if let Ok(proxy) = Proxy::all(&proxy_scheme) {
-                   builder = builder.proxy(proxy);
-               }
-
-               let client = builder.build().expect("Failed to build self_proxy client");
-               *client_guard = Some(client);
-           }
-
-           client_guard.as_ref().unwrap().clone()
-       }
-
-       /// 获取或创建系统代理客户端
-       fn get_or_create_system_proxy_client(&self) -> Client {
-           if self.should_reset_clients() {
-               self.reset_clients();
-           }
-
-           let mut client_guard = self.system_proxy_client.lock().unwrap();
-
-           if client_guard.is_none() {
-               use sysproxy::Sysproxy;
-
-               let mut builder = ClientBuilder::new()
-                   .use_rustls_tls()
-                   .pool_max_idle_per_host(POOL_MAX_IDLE_PER_HOST)
-                   .pool_idle_timeout(POOL_IDLE_TIMEOUT)
-                   .connect_timeout(DEFAULT_CONNECT_TIMEOUT)
-                   .timeout(DEFAULT_REQUEST_TIMEOUT)
-                   .http2_initial_stream_window_size(H2_STREAM_WINDOW_SIZE)
-                   .http2_initial_connection_window_size(H2_CONNECTION_WINDOW_SIZE)
-                   .http2_adaptive_window(true)
-                   .http2_keep_alive_interval(Some(H2_KEEP_ALIVE_INTERVAL))
-                   .http2_keep_alive_timeout(H2_KEEP_ALIVE_TIMEOUT)
-                   .http2_max_frame_size(H2_MAX_FRAME_SIZE)
-                   .tcp_keepalive(Some(Duration::from_secs(10)))
-                   .http2_max_header_list_size(16 * 1024);
-
-               if let Ok(p @ Sysproxy { enable: true, .. }) = Sysproxy::get_system_proxy() {
-                   let proxy_scheme = format!("http://{}:{}", p.host, p.port);
-
-                   if let Ok(proxy) = Proxy::http(&proxy_scheme) {
-                       builder = builder.proxy(proxy);
-                   }
-                   if let Ok(proxy) = Proxy::https(&proxy_scheme) {
-                       builder = builder.proxy(proxy);
-                   }
-                   if let Ok(proxy) = Proxy::all(&proxy_scheme) {
-                       builder = builder.proxy(proxy);
-                   }
-               }
-
-               let client = builder
-                   .build()
-                   .expect("Failed to build system_proxy client");
-               *client_guard = Some(client);
-           }
-
-           client_guard.as_ref().unwrap().clone()
-       }
-
-       /// 根据代理设置选择合适的客户端
-       pub fn get_client(&self, proxy_type: ProxyType) -> Client {
-           match proxy_type {
-               ProxyType::NoProxy => {
-                   let client_guard = self.no_proxy_client.lock().unwrap();
-                   client_guard.as_ref().unwrap().clone()
-               }
-               ProxyType::SelfProxy => self.get_or_create_self_proxy_client(),
-               ProxyType::SystemProxy => self.get_or_create_system_proxy_client(),
-           }
-       }
-    */
-    /// 创建带有自定义选项的HTTP请求
-    pub fn create_request(
-        &self,
-        url: &str,
-        proxy_type: ProxyType,
-        timeout_secs: Option<u64>,
-        user_agent: Option<String>,
-        accept_invalid_certs: bool,
-    ) -> RequestBuilder {
-        if self.should_reset_clients() {
-            self.reset_clients();
-        }
-
-        let mut builder = ClientBuilder::new()
-            .use_rustls_tls()
-            .pool_max_idle_per_host(POOL_MAX_IDLE_PER_HOST)
-            .pool_idle_timeout(POOL_IDLE_TIMEOUT)
-            .connect_timeout(DEFAULT_CONNECT_TIMEOUT)
-            .http2_initial_stream_window_size(H2_STREAM_WINDOW_SIZE)
-            .http2_initial_connection_window_size(H2_CONNECTION_WINDOW_SIZE)
-            .http2_adaptive_window(true)
-            .http2_keep_alive_interval(Some(H2_KEEP_ALIVE_INTERVAL))
-            .http2_keep_alive_timeout(H2_KEEP_ALIVE_TIMEOUT)
-            .http2_max_frame_size(H2_MAX_FRAME_SIZE)
-            .tcp_keepalive(Some(Duration::from_secs(10)))
-            .http2_max_header_list_size(16 * 1024);
-
-        if let Some(timeout) = timeout_secs {
-            builder = builder.timeout(Duration::from_secs(timeout));
-        } else {
-            builder = builder.timeout(DEFAULT_REQUEST_TIMEOUT);
-        }
-
-        match proxy_type {
-            ProxyType::None => {
-                builder = builder.no_proxy();
-            }
-            ProxyType::Localhost => {
-                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) = Proxy::http(&proxy_scheme) {
-                    builder = builder.proxy(proxy);
-                }
-                if let Ok(proxy) = Proxy::https(&proxy_scheme) {
-                    builder = builder.proxy(proxy);
-                }
-                if let Ok(proxy) = Proxy::all(&proxy_scheme) {
-                    builder = builder.proxy(proxy);
-                }
-            }
-            ProxyType::System => {
-                use sysproxy::Sysproxy;
-
-                if let Ok(p @ Sysproxy { enable: true, .. }) = Sysproxy::get_system_proxy() {
-                    let proxy_scheme = format!("http://{}:{}", p.host, p.port);
-
-                    if let Ok(proxy) = Proxy::http(&proxy_scheme) {
-                        builder = builder.proxy(proxy);
-                    }
-                    if let Ok(proxy) = Proxy::https(&proxy_scheme) {
-                        builder = builder.proxy(proxy);
-                    }
-                    if let Ok(proxy) = Proxy::all(&proxy_scheme) {
-                        builder = builder.proxy(proxy);
-                    }
-                }
-            }
-        }
-
-        builder = builder.danger_accept_invalid_certs(accept_invalid_certs);
-
-        if let Some(ua) = user_agent {
-            builder = builder.user_agent(ua);
-        } else {
-            use crate::utils::resolve::VERSION;
-
-            let version = match VERSION.get() {
-                Some(v) => format!("clash-verge/v{}", v),
-                None => "clash-verge/unknown".to_string(),
-            };
-
-            builder = builder.user_agent(version);
-        }
-
-        let client = builder.build().expect("Failed to build custom HTTP client");
-
-        client.get(url)
-    }
-
-    /*     /// 执行GET请求，添加错误跟踪
-    pub async fn get(
-        &self,
-        url: &str,
-        proxy_type: ProxyType,
-        timeout_secs: Option<u64>,
-        user_agent: Option<String>,
-        accept_invalid_certs: bool,
-    ) -> Result<Response> {
-        let request = self.create_request(
-            url,
-            proxy_type,
-            timeout_secs,
-            user_agent,
-            accept_invalid_certs,
-        );
-
-        let timeout_duration = timeout_secs.unwrap_or(30);
-
-        match tokio::time::timeout(Duration::from_secs(timeout_duration), request.send()).await {
-            Ok(result) => match result {
-                Ok(response) => Ok(response),
-                Err(e) => {
-                    self.record_connection_error(&e.to_string());
-                    Err(anyhow::anyhow!("Failed to send HTTP request: {}", e))
-                }
-            },
-            Err(_) => {
-                self.record_connection_error("Request timeout");
-                Err(anyhow::anyhow!(
-                    "HTTP request timed out after {} seconds",
-                    timeout_duration
-                ))
-            }
-        }
-    } */
-
-    pub async fn get_with_interrupt(
-        &self,
-        url: &str,
-        proxy_type: ProxyType,
-        timeout_secs: Option<u64>,
-        user_agent: Option<String>,
-        accept_invalid_certs: bool,
-    ) -> Result<Response> {
-        let request = self.create_request(
-            url,
-            proxy_type,
-            timeout_secs,
-            user_agent,
-            accept_invalid_certs,
-        );
-
-        let timeout_duration = timeout_secs.unwrap_or(20);
-
-        let (cancel_tx, cancel_rx) = tokio::sync::oneshot::channel::<()>();
-
-        let url_clone = url.to_string();
-        let watchdog = tokio::spawn(async move {
-            tokio::time::sleep(Duration::from_secs(timeout_duration)).await;
-            let _ = cancel_tx.send(());
-            logging!(warn, Type::Network, true, "请求超时取消: {}", url_clone);
-        });
-
-        let result = tokio::select! {
-            result = request.send() => result,
-            _ = cancel_rx => {
-                self.record_connection_error(&format!("Request interrupted for: {}", url));
-                return Err(anyhow::anyhow!("Request interrupted after {} seconds", timeout_duration));
-            }
-        };
-        watchdog.abort();
-
-        match result {
-            Ok(response) => Ok(response),
-            Err(e) => {
-                self.record_connection_error(&e.to_string());
-                Err(anyhow::anyhow!("Failed to send HTTP request: {}", e))
-            }
-        }
-    }
-}
-
-/// 代理类型
-#[derive(Debug, Clone, Copy)]
-pub enum ProxyType {
-    None,
-    Localhost,
-    System,
-}

src-tauri/src/utils/resolve.rs

@@ -1,132 +1,24 @@
 #[cfg(target_os = "macos")]
 use crate::AppHandleManager;
 use crate::{
-    config::{Config, IVerge, PrfItem},
-    core::*,
-    logging, logging_error,
-    module::lightweight::{self, auto_lightweight_mode_init},
-    process::AsyncHandler,
-    utils::{init, logging::Type, server},
-    wrap_err,
+    config::{Config, IVerge, PrfItem}, core::*, log_err, module::lightweight, utils::{error, init, server}, wrap_err
 };
 use anyhow::{bail, Result};
 use once_cell::sync::OnceCell;
-use parking_lot::{Mutex, RwLock};
 use percent_encoding::percent_decode_str;
 use serde_yaml::Mapping;
-use std::{
-    sync::Arc,
-    time::{Duration, Instant},
-};
-use tauri::{AppHandle, Manager};
-use tokio::net::TcpListener;
+use std::net::TcpListener;
+use tauri::{App, Manager};
 
-use tauri::Url;
+use url::Url;
 //#[cfg(not(target_os = "linux"))]
 // use window_shadows::set_shadow;
+use tauri_plugin_notification::NotificationExt;
 
 pub static VERSION: OnceCell<String> = OnceCell::new();
 
-// 定义默认窗口尺寸常量
-const DEFAULT_WIDTH: u32 = 940;
-const DEFAULT_HEIGHT: u32 = 700;
-
-// 添加全局UI准备就绪标志
-static UI_READY: OnceCell<Arc<RwLock<bool>>> = OnceCell::new();
-
-// 窗口创建锁，防止并发创建窗口
-static WINDOW_CREATING: OnceCell<Mutex<(bool, Instant)>> = OnceCell::new();
-
-// UI就绪阶段状态枚举
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum UiReadyStage {
-    NotStarted,
-    Loading,
-    DomReady,
-    ResourcesLoaded,
-    Ready,
-}
-
-// UI就绪详细状态
-#[derive(Debug)]
-struct UiReadyState {
-    stage: RwLock<UiReadyStage>,
-    last_update: RwLock<Instant>,
-}
-
-impl Default for UiReadyState {
-    fn default() -> Self {
-        Self {
-            stage: RwLock::new(UiReadyStage::NotStarted),
-            last_update: RwLock::new(Instant::now()),
-        }
-    }
-}
-
-// 获取UI就绪状态细节
-static UI_READY_STATE: OnceCell<Arc<UiReadyState>> = OnceCell::new();
-
-fn get_window_creating_lock() -> &'static Mutex<(bool, Instant)> {
-    WINDOW_CREATING.get_or_init(|| Mutex::new((false, Instant::now())))
-}
-
-fn get_ui_ready() -> &'static Arc<RwLock<bool>> {
-    UI_READY.get_or_init(|| Arc::new(RwLock::new(false)))
-}
-
-fn get_ui_ready_state() -> &'static Arc<UiReadyState> {
-    UI_READY_STATE.get_or_init(|| Arc::new(UiReadyState::default()))
-}
-
-// 更新UI准备阶段
-pub fn update_ui_ready_stage(stage: UiReadyStage) {
-    let state = get_ui_ready_state();
-    let mut stage_lock = state.stage.write();
-    let mut time_lock = state.last_update.write();
-
-    *stage_lock = stage;
-    *time_lock = Instant::now();
-
-    logging!(
-        info,
-        Type::Window,
-        true,
-        "UI准备阶段更新: {:?}, 耗时: {:?}ms",
-        stage,
-        time_lock.elapsed().as_millis()
-    );
-
-    // 如果是最终阶段，标记UI完全就绪
-    if stage == UiReadyStage::Ready {
-        mark_ui_ready();
-    }
-}
-
-// 标记UI已准备就绪
-pub fn mark_ui_ready() {
-    let mut ready = get_ui_ready().write();
-    *ready = true;
-    logging!(info, Type::Window, true, "UI已标记为完全就绪");
-}
-
-// 重置UI就绪状态
-pub fn reset_ui_ready() {
-    {
-        let mut ready = get_ui_ready().write();
-        *ready = false;
-    }
-    {
-        let state = get_ui_ready_state();
-        let mut stage = state.stage.write();
-        let mut time = state.last_update.write();
-        *stage = UiReadyStage::NotStarted;
-        *time = Instant::now();
-    }
-    logging!(info, Type::Window, true, "UI就绪状态已重置");
-}
-
-pub async fn find_unused_port() -> Result<u16> {
-    match TcpListener::bind("127.0.0.1:0").await {
+pub fn find_unused_port() -> Result<u16> {
+    match TcpListener::bind("127.0.0.1:0") {
         Ok(listener) => {
             let port = listener.local_addr()?.port();
             Ok(port)
@@ -142,400 +34,184 @@ pub async fn find_unused_port() -> Result<u16> {
     }
 }
 
-/// 异步方式处理启动后的额外任务
-pub async fn resolve_setup_async(app_handle: &AppHandle) {
-    let start_time = std::time::Instant::now();
-    logging!(info, Type::Setup, true, "开始执行异步设置任务...");
-
-    if VERSION.get().is_none() {
-        let version = app_handle.package_info().version.to_string();
-        VERSION.get_or_init(|| {
-            logging!(info, Type::Setup, true, "初始化版本信息: {}", version);
-            version.clone()
-        });
-    }
-
-    logging_error!(Type::Setup, true, init::init_scheme());
-
-    logging_error!(Type::Setup, true, init::startup_script().await);
-
-    if let Err(err) = resolve_random_port_config().await {
-        logging!(
-            error,
-            Type::System,
-            true,
-            "Failed to resolve random port config: {}",
-            err
-        );
-    }
-
-    logging!(trace, Type::Config, true, "初始化配置...");
-    logging_error!(Type::Config, true, Config::init_config().await);
-
-    // 启动时清理冗余的 Profile 文件
-    logging!(info, Type::Setup, true, "清理冗余的Profile文件...");
-    let profiles = Config::profiles();
-    if let Err(e) = profiles.latest().auto_cleanup() {
-        logging!(warn, Type::Setup, true, "启动时清理Profile文件失败: {}", e);
-    } else {
-        logging!(info, Type::Setup, true, "启动时Profile文件清理完成");
-    }
-
-    logging!(trace, Type::Core, true, "启动核心管理器...");
-    logging_error!(Type::Core, true, CoreManager::global().init().await);
-
-    log::trace!(target: "app", "启动内嵌服务器...");
-    server::embed_server();
-
-    logging_error!(Type::Tray, true, tray::Tray::global().init());
-
-    if let Some(app_handle) = handle::Handle::global().app_handle() {
-        logging!(info, Type::Tray, true, "创建系统托盘...");
-        let result = tray::Tray::global().create_tray_from_handle(&app_handle);
-        if result.is_ok() {
-            logging!(info, Type::Tray, true, "系统托盘创建成功");
-        } else if let Err(e) = result {
-            logging!(error, Type::Tray, true, "系统托盘创建失败: {}", e);
-        }
-    } else {
-        logging!(
-            error,
-            Type::Tray,
-            true,
-            "无法创建系统托盘: app_handle不存在"
-        );
-    }
-
-    // 更新系统代理
-    logging_error!(
-        Type::System,
-        true,
-        sysopt::Sysopt::global().update_sysproxy().await
-    );
-    logging_error!(
-        Type::System,
-        true,
-        sysopt::Sysopt::global().init_guard_sysproxy()
-    );
-
-    // 创建窗口
-    let is_silent_start = { Config::verge().data().enable_silent_start }.unwrap_or(false);
+/// handle something when start app
+pub async fn resolve_setup(app: &mut App) {
+    error::redirect_panic_to_log();
     #[cfg(target_os = "macos")]
     {
-        if is_silent_start {
-            use crate::AppHandleManager;
-
+        AppHandleManager::global().init(app.app_handle().clone());
         AppHandleManager::global().set_activation_policy_accessory();
     }
-    }
-    create_window(!is_silent_start);
+    let version = app.package_info().version.to_string();
 
-    // 初始化定时器
-    logging_error!(Type::System, true, timer::Timer::global().init());
+    handle::Handle::global().init(app.app_handle());
+    VERSION.get_or_init(|| version.clone());
 
-    // 自动进入轻量模式
-    auto_lightweight_mode_init();
+    log_err!(init::init_config());
+    log_err!(init::init_resources());
+    log_err!(init::init_scheme());
+    log_err!(init::startup_script().await);
+    // 处理随机端口
+    log_err!(resolve_random_port_config());
+    // 启动核心
+    log::trace!(target:"app", "init config");
+    log_err!(Config::init_config().await);
 
-    logging_error!(Type::Tray, true, tray::Tray::global().update_part());
-
-    logging!(trace, Type::System, true, "初始化热键...");
-    logging_error!(Type::System, true, hotkey::Hotkey::global().init());
-
-    let elapsed = start_time.elapsed();
-    logging!(
-        info,
-        Type::Setup,
-        true,
-        "异步设置任务完成，耗时: {:?}",
-        elapsed
-    );
-
-    // 如果初始化时间过长，记录警告
-    if elapsed.as_secs() > 10 {
-        logging!(
-            warn,
-            Type::Setup,
-            true,
-            "异步设置任务耗时较长({:?})",
-            elapsed
-        );
-    }
-}
-
-/// reset system proxy (异步)
-pub async fn resolve_reset_async() {
+    if service::check_service().await.is_err() {
+        match service::reinstall_service().await {
+            Ok(_) => {
+                log::info!(target:"app", "install service susccess.");
+                #[cfg(not(target_os = "macos"))]
+                std::thread::sleep(std::time::Duration::from_millis(1000));
                 #[cfg(target_os = "macos")]
-    logging!(info, Type::Tray, true, "Unsubscribing from traffic updates");
+                {
+                    let mut service_runing = false;
+                    for _ in 0..40 {
+                        if service::check_service().await.is_ok() {
+                            service_runing = true;
+                            break;
+                        } else {
+                            log::warn!(target: "app", "service not runing, sleep 500ms and check again.");
+                            std::thread::sleep(std::time::Duration::from_millis(500));
+                        }
+                    }
+                    if !service_runing {
+                        log::warn!(target: "app", "service not running, will fallback to user mode");
+                    }
+                }
+            }
+            Err(e) => {
+                log::warn!(target: "app", "failed to install service: {e:?}, will fallback to user mode");
+            }
+        }
+    }
+
+    log::trace!(target: "app", "launch core");
+    log_err!(CoreManager::global().init().await);
+
+    // setup a simple http server for singleton
+    log::trace!(target: "app", "launch embed server");
+    server::embed_server();
+
+    log::trace!(target: "app", "init system tray");
+    log_err!(tray::Tray::global().init());
+    log_err!(tray::Tray::global().create_systray(app));
+
+    log_err!(sysopt::Sysopt::global().update_sysproxy().await);
+    log_err!(sysopt::Sysopt::global().init_guard_sysproxy());
+
+    // 初始化热键
+    log::trace!(target: "app", "init hotkeys");
+    log_err!(hotkey::Hotkey::global().init());
+
+    let silent_start = { Config::verge().data().enable_silent_start };
+    if !silent_start.unwrap_or(false) {
+        create_window();
+    }
+
+    log_err!(tray::Tray::global().update_part());
+    log_err!(timer::Timer::global().init());
+
+    let enable_auto_light_weight_mode = { Config::verge().data().enable_auto_light_weight_mode };
+    if enable_auto_light_weight_mode.unwrap_or(false) {
+        lightweight::enable_auto_light_weight_mode();
+    }
+}
+
+/// reset system proxy
+pub fn resolve_reset() {
+    tauri::async_runtime::block_on(async move {
         #[cfg(target_os = "macos")]
         tray::Tray::global().unsubscribe_traffic();
 
-    logging_error!(
-        Type::System,
-        true,
-        sysopt::Sysopt::global().reset_sysproxy().await
-    );
-    logging_error!(Type::Core, true, CoreManager::global().stop_core().await);
+        log_err!(sysopt::Sysopt::global().reset_sysproxy().await);
+        log_err!(CoreManager::global().stop_core().await);
         #[cfg(target_os = "macos")]
-    {
-        logging!(info, Type::System, true, "Restoring system DNS settings");
         restore_public_dns().await;
-    }
+    });
 }
 
-/// Create the main window
-pub fn create_window(is_show: bool) -> bool {
-    logging!(
-        info,
-        Type::Window,
-        true,
-        "开始创建/显示主窗口, is_show={}",
-        is_show
-    );
+/// create main window
+pub fn create_window() {
+    println!("Starting to create window");
+    log::info!(target: "app", "Starting to create window");
 
-    if !is_show {
-        logging!(info, Type::Window, true, "静默模式启动时不创建窗口");
-        handle::Handle::notify_startup_completed();
-        return false;
-    }
+    let app_handle = handle::Handle::global().app_handle().unwrap();
+    #[cfg(target_os = "macos")]
+    AppHandleManager::global().set_activation_policy_regular();
+
+    if let Some(window) = handle::Handle::global().get_window() {
+        println!("Found existing window, trying to show it");
+        log::info!(target: "app", "Found existing window, trying to show it");
 
-    if let Some(app_handle) = handle::Handle::global().app_handle() {
-        if let Some(window) = app_handle.get_webview_window("main") {
-            logging!(info, Type::Window, true, "主窗口已存在，将显示现有窗口");
-            if is_show {
         if window.is_minimized().unwrap_or(false) {
-                    logging!(info, Type::Window, true, "窗口已最小化，正在取消最小化");
+            println!("Window is minimized, unminimizing");
+            log::info!(target: "app", "Window is minimized, unminimizing");
             let _ = window.unminimize();
         }
         let _ = window.show();
         let _ = window.set_focus();
-
-                #[cfg(target_os = "macos")]
-                {
-                    AppHandleManager::global().set_activation_policy_regular();
-                }
-            }
-            return true;
-        }
-    }
-
-    let creating_lock = get_window_creating_lock();
-    let mut creating = creating_lock.lock();
-
-    let (is_creating, last_time) = *creating;
-    let elapsed = last_time.elapsed();
-
-    if is_creating && elapsed < Duration::from_secs(2) {
-        logging!(
-            info,
-            Type::Window,
-            true,
-            "窗口创建请求被忽略，因为最近创建过 ({:?}ms)",
-            elapsed.as_millis()
-        );
-        return false;
-    }
-
-    *creating = (true, Instant::now());
-
-    match tauri::WebviewWindowBuilder::new(
-        &handle::Handle::global().app_handle().unwrap(),
-        "main", /* the unique window label */
-        tauri::WebviewUrl::App("index.html".into()),
-    )
-    .title("Clash Verge")
-    .center()
-    .decorations(true)
-    .fullscreen(false)
-    .inner_size(DEFAULT_WIDTH as f64, DEFAULT_HEIGHT as f64)
-    .min_inner_size(520.0, 520.0)
-    .visible(true) // 立即显示窗口，避免用户等待
-    .initialization_script(
-        r#"
-        console.log('[Tauri] 窗口初始化脚本开始执行');
-
-        function createLoadingOverlay() {
-
-            if (document.getElementById('initial-loading-overlay')) {
-                console.log('[Tauri] 加载指示器已存在');
         return;
     }
 
-            console.log('[Tauri] 创建加载指示器');
-            const loadingDiv = document.createElement('div');
-            loadingDiv.id = 'initial-loading-overlay';
-            loadingDiv.innerHTML = `
-                <div style="
-                    position: fixed; top: 0; left: 0; right: 0; bottom: 0;
-                    background: var(--bg-color, #f5f5f5); color: var(--text-color, #333);
-                    display: flex; flex-direction: column; align-items: center;
-                    justify-content: center; z-index: 9999;
-                    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
-                    transition: opacity 0.3s ease;
-                ">
-                    <div style="margin-bottom: 20px;">
-                        <div style="
-                            width: 40px; height: 40px; border: 3px solid #e3e3e3;
-                            border-top: 3px solid #3498db; border-radius: 50%;
-                            animation: spin 1s linear infinite;
-                        "></div>
-                    </div>
-                    <div style="font-size: 14px; opacity: 0.7;">Loading Clash Verge...</div>
-                </div>
-                <style>
-                    @keyframes spin {
-                        0% { transform: rotate(0deg); }
-                        100% { transform: rotate(360deg); }
-                    }
-                    @media (prefers-color-scheme: dark) {
-                        :root { --bg-color: #1a1a1a; --text-color: #ffffff; }
-                    }
-                </style>
-            `;
+    println!("Creating new window");
+    log::info!(target: "app", "Creating new window");
 
-            if (document.body) {
-                document.body.appendChild(loadingDiv);
-            } else {
-                document.addEventListener('DOMContentLoaded', () => {
-                    if (document.body && !document.getElementById('initial-loading-overlay')) {
-                        document.body.appendChild(loadingDiv);
-                    }
-                });
-            }
-        }
-
-        createLoadingOverlay();
-
-        if (document.readyState === 'loading') {
-            document.addEventListener('DOMContentLoaded', createLoadingOverlay);
-        } else {
-            createLoadingOverlay();
-        }
-
-        console.log('[Tauri] 窗口初始化脚本执行完成');
-    "#,
+    #[cfg(target_os = "windows")]
+    let window = tauri::WebviewWindowBuilder::new(
+                &app_handle,
+                "main".to_string(),
+                tauri::WebviewUrl::App("index.html".into()),
             )
-    .build()
-    {
-        Ok(newly_created_window) => {
-            logging!(debug, Type::Window, true, "主窗口实例创建成功");
+            .title("Clash Verge")
+            .inner_size(890.0, 700.0)
+            .min_inner_size(620.0, 550.0)
+            .decorations(false)
+            .maximizable(true)
+            .additional_browser_args("--enable-features=msWebView2EnableDraggableRegions --disable-features=OverscrollHistoryNavigation,msExperimentalScrolling")
+            .transparent(true)
+            .shadow(true)
+            .build();
 
-            *creating = (false, Instant::now());
-
-            update_ui_ready_stage(UiReadyStage::NotStarted);
-
-            AsyncHandler::spawn(move || async move {
-                handle::Handle::global().mark_startup_completed();
-                logging!(
-                    debug,
-                    Type::Window,
-                    true,
-                    "异步窗口任务开始 (启动已标记完成)"
-                );
-
-                // 先运行轻量模式检测
-                lightweight::run_once_auto_lightweight();
-
-                // 发送启动完成事件，触发前端开始加载
-                logging!(
-                    debug,
-                    Type::Window,
-                    true,
-                    "发送 verge://startup-completed 事件"
-                );
-                handle::Handle::notify_startup_completed();
-
-                if is_show {
-                    let window_clone = newly_created_window.clone();
-
-                    // 立即显示窗口
-                    let _ = window_clone.show();
-                    let _ = window_clone.set_focus();
-                    logging!(info, Type::Window, true, "窗口已立即显示");
     #[cfg(target_os = "macos")]
-                    {
-                        AppHandleManager::global().set_activation_policy_regular();
-                    }
+    let window = tauri::WebviewWindowBuilder::new(
+        &app_handle,
+        "main".to_string(),
+        tauri::WebviewUrl::App("index.html".into()),
+    )
+    .decorations(true)
+    .hidden_title(true)
+    .title_bar_style(tauri::TitleBarStyle::Overlay)
+    .inner_size(890.0, 700.0)
+    .min_inner_size(620.0, 550.0)
+    .build();
 
-                    let timeout_seconds = if crate::module::lightweight::is_in_lightweight_mode() {
-                        3
-                    } else {
-                        8
-                    };
+    #[cfg(target_os = "linux")]
+    let window = tauri::WebviewWindowBuilder::new(
+        &app_handle,
+        "main".to_string(),
+        tauri::WebviewUrl::App("index.html".into()),
+    )
+    .title("Clash Verge")
+    .decorations(false)
+    .inner_size(890.0, 700.0)
+    .min_inner_size(620.0, 550.0)
+    .transparent(true)
+    .build();
 
-                    logging!(
-                        info,
-                        Type::Window,
-                        true,
-                        "开始监控UI加载状态 (最多{}秒)...",
-                        timeout_seconds
-                    );
+    match window {
+        Ok(window) => {
+            println!("Window created successfully, attempting to show");
+            log::info!(target: "app", "Window created successfully, attempting to show");
+            let _ = window.show();
+            let _ = window.set_focus();
 
-                    // 异步监控UI状态，不影响窗口显示
-                    tokio::spawn(async move {
-                        let wait_result =
-                            tokio::time::timeout(Duration::from_secs(timeout_seconds), async {
-                                let mut check_count = 0;
-                                while !*get_ui_ready().read() {
-                                    tokio::time::sleep(Duration::from_millis(100)).await;
-                                    check_count += 1;
-
-                                    // 每2秒记录一次等待状态
-                                    if check_count % 20 == 0 {
-                                        logging!(
-                                            debug,
-                                            Type::Window,
-                                            true,
-                                            "UI加载状态检查... ({}秒)",
-                                            check_count / 10
-                                        );
-                                    }
-                                }
-                            })
-                            .await;
-
-                        match wait_result {
-                            Ok(_) => {
-                                logging!(info, Type::Window, true, "UI已完全加载就绪");
-                                // 移除初始加载指示器
-                                if let Some(window) = handle::Handle::global().get_window() {
-                                    let _ = window.eval(r#"
-                                        const overlay = document.getElementById('initial-loading-overlay');
-                                        if (overlay) {
-                                            overlay.style.opacity = '0';
-                                            setTimeout(() => overlay.remove(), 300);
-                                        }
-                                    "#);
-                                }
-                            }
-                            Err(_) => {
-                                logging!(
-                                    warn,
-                                    Type::Window,
-                                    true,
-                                    "UI加载监控超时({}秒)，但窗口已正常显示",
-                                    timeout_seconds
-                                );
-                                *get_ui_ready().write() = true;
-                            }
-                        }
-                    });
-
-                    logging!(info, Type::Window, true, "窗口显示流程完成");
-                } else {
-                    logging!(
-                        debug,
-                        Type::Window,
-                        true,
-                        "is_show为false，窗口保持隐藏状态"
-                    );
-                }
-            });
-            true
+            // 设置窗口状态监控，实时保存窗口位置和大小
+            crate::feat::setup_window_state_monitor(&app_handle);
         }
         Err(e) => {
-            logging!(error, Type::Window, true, "主窗口构建失败: {}", e);
-            *creating = (false, Instant::now()); // Reset the creating state if window creation failed
-            false
+            println!("Failed to create window: {:?}", e);
+            log::error!(target: "app", "Failed to create window: {:?}", e);
         }
     }
 }
@@ -543,6 +219,8 @@ pub fn create_window(is_show: bool) -> bool {
 pub async fn resolve_scheme(param: String) -> Result<()> {
     log::info!(target:"app", "received deep link: {}", param);
 
+    let app_handle = handle::Handle::global().app_handle().unwrap();
+
     let param_str = if param.starts_with("[") && param.len() > 4 {
         param
             .get(2..param.len() - 2)
@@ -565,31 +243,41 @@ pub async fn resolve_scheme(param: String) -> Result<()> {
             .find(|(key, _)| key == "name")
             .map(|(_, value)| value.into_owned());
 
-        let url_param = if let Some(query) = link_parsed.query() {
-            let prefix = "url=";
-            if let Some(pos) = query.find(prefix) {
-                let raw_url = &query[pos + prefix.len()..];
-                Some(percent_decode_str(raw_url).decode_utf8_lossy().to_string())
-            } else {
-                None
-            }
-        } else {
-            None
-        };
+        let encode_url = link_parsed
+            .query_pairs()
+            .find(|(key, _)| key == "url")
+            .map(|(_, value)| value.into_owned());
 
-        match url_param {
+        match encode_url {
             Some(url) => {
-                log::info!(target:"app", "decoded subscription url: {}", url);
+                let url = percent_decode_str(url.as_ref())
+                    .decode_utf8_lossy()
+                    .to_string();
 
-                create_window(false);
+                create_window();
                 match PrfItem::from_url(url.as_ref(), name, None, None).await {
                     Ok(item) => {
                         let uid = item.uid.clone().unwrap();
                         let _ = wrap_err!(Config::profiles().data().append_item(item));
                         handle::Handle::notice_message("import_sub_url::ok", uid);
+
+                        app_handle
+                            .notification()
+                            .builder()
+                            .title("Clash Verge")
+                            .body("Import profile success")
+                            .show()
+                            .unwrap();
                     }
                     Err(e) => {
                         handle::Handle::notice_message("import_sub_url::error", e.to_string());
+                        app_handle
+                            .notification()
+                            .builder()
+                            .title("Clash Verge")
+                            .body(format!("Import profile failed: {e}"))
+                            .show()
+                            .unwrap();
                     }
                 }
             }
@@ -600,7 +288,7 @@ pub async fn resolve_scheme(param: String) -> Result<()> {
     Ok(())
 }
 
-async fn resolve_random_port_config() -> Result<()> {
+fn resolve_random_port_config() -> Result<()> {
     let verge_config = Config::verge();
     let clash_config = Config::clash();
     let enable_random_port = verge_config.latest().enable_random_port.unwrap_or(false);
@@ -611,34 +299,21 @@ async fn resolve_random_port_config() -> Result<()> {
         .unwrap_or(clash_config.data().get_mixed_port());
 
     let port = if enable_random_port {
-        find_unused_port().await.unwrap_or(default_port)
+        find_unused_port().unwrap_or(default_port)
     } else {
         default_port
     };
 
-    let port_to_save = port;
-
-    tokio::task::spawn_blocking(move || {
-        let verge_config_accessor = Config::verge();
-        let mut verge_data = verge_config_accessor.data();
-        verge_data.patch_config(IVerge {
-            verge_mixed_port: Some(port_to_save),
+    verge_config.data().patch_config(IVerge {
+        verge_mixed_port: Some(port),
         ..IVerge::default()
     });
-        verge_data.save_file()
-    })
-    .await??; // First ? for spawn_blocking error, second for save_file Result
+    verge_config.data().save_file()?;
 
-    tokio::task::spawn_blocking(move || {
-        let clash_config_accessor = Config::clash(); // Extend lifetime of the accessor
-        let mut clash_data = clash_config_accessor.data(); // Access within blocking task, made mutable
     let mut mapping = Mapping::new();
-        mapping.insert("mixed-port".into(), port_to_save.into());
-        clash_data.patch_config(mapping);
-        clash_data.save_config()
-    })
-    .await??;
-
+    mapping.insert("mixed-port".into(), port.into());
+    clash_config.data().patch_config(mapping);
+    clash_config.data().save_config()?;
     Ok(())
 }
 

src-tauri/src/utils/server.rs

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

src-tauri/src/utils/tmpl.rs

@@ -15,6 +15,9 @@ pub const ITEM_MERGE: &str = "# Profile Enhancement Merge Template for Clash Ver
 
 profile:
   store-selected: true
+
+dns:
+  use-system-hosts: false
 ";
 
 pub const ITEM_MERGE_EMPTY: &str = "# Profile Enhancement Merge Template for Clash Verge

src-tauri/src/utils/window_manager.rs

@@ -1,272 +0,0 @@
-use crate::{core::handle, logging, utils::logging::Type};
-use tauri::{Manager, WebviewWindow, Wry};
-
-#[cfg(target_os = "macos")]
-use crate::AppHandleManager;
-
-/// 窗口操作结果
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum WindowOperationResult {
-    /// 窗口已显示并获得焦点
-    Shown,
-    /// 窗口已隐藏
-    Hidden,
-    /// 创建了新窗口
-    Created,
-    /// 操作失败
-    Failed,
-    /// 无需操作
-    NoAction,
-}
-
-/// 窗口状态
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum WindowState {
-    /// 窗口可见且有焦点
-    VisibleFocused,
-    /// 窗口可见但无焦点
-    VisibleUnfocused,
-    /// 窗口最小化
-    Minimized,
-    /// 窗口隐藏
-    Hidden,
-    /// 窗口不存在
-    NotExist,
-}
-
-/// 统一的窗口管理器
-pub struct WindowManager;
-
-impl WindowManager {
-    pub fn get_main_window_state() -> WindowState {
-        if let Some(window) = Self::get_main_window() {
-            if window.is_minimized().unwrap_or(false) {
-                WindowState::Minimized
-            } else if window.is_visible().unwrap_or(false) {
-                if window.is_focused().unwrap_or(false) {
-                    WindowState::VisibleFocused
-                } else {
-                    WindowState::VisibleUnfocused
-                }
-            } else {
-                WindowState::Hidden
-            }
-        } else {
-            WindowState::NotExist
-        }
-    }
-
-    /// 获取主窗口实例
-    pub fn get_main_window() -> Option<WebviewWindow<Wry>> {
-        handle::Handle::global()
-            .app_handle()
-            .and_then(|app| app.get_webview_window("main"))
-    }
-
-    /// 智能显示主窗口
-    pub fn show_main_window() -> WindowOperationResult {
-        logging!(info, Type::Window, true, "开始智能显示主窗口");
-        logging!(
-            debug,
-            Type::Window,
-            true,
-            "{}",
-            Self::get_window_status_info()
-        );
-
-        let current_state = Self::get_main_window_state();
-
-        match current_state {
-            WindowState::NotExist => {
-                logging!(info, Type::Window, true, "窗口不存在，创建新窗口");
-                if Self::create_new_window() {
-                    WindowOperationResult::Created
-                } else {
-                    WindowOperationResult::Failed
-                }
-            }
-            WindowState::VisibleFocused => {
-                logging!(info, Type::Window, true, "窗口已经可见且有焦点，无需操作");
-                WindowOperationResult::NoAction
-            }
-            WindowState::VisibleUnfocused | WindowState::Minimized | WindowState::Hidden => {
-                if let Some(window) = Self::get_main_window() {
-                    Self::activate_window(&window)
-                } else {
-                    WindowOperationResult::Failed
-                }
-            }
-        }
-    }
-
-    /// 切换主窗口显示状态（显示/隐藏）
-    pub fn toggle_main_window() -> WindowOperationResult {
-        logging!(info, Type::Window, true, "开始切换主窗口显示状态");
-
-        let current_state = Self::get_main_window_state();
-        logging!(
-            info,
-            Type::Window,
-            true,
-            "当前窗口状态: {:?}",
-            current_state
-        );
-
-        match current_state {
-            WindowState::NotExist => {
-                // 窗口不存在，创建新窗口
-                if Self::create_new_window() {
-                    WindowOperationResult::Created
-                } else {
-                    WindowOperationResult::Failed
-                }
-            }
-            WindowState::VisibleFocused => {
-                // 窗口可见且有焦点，隐藏它
-                if let Some(window) = Self::get_main_window() {
-                    if window.hide().is_ok() {
-                        logging!(info, Type::Window, true, "窗口已隐藏");
-                        WindowOperationResult::Hidden
-                    } else {
-                        WindowOperationResult::Failed
-                    }
-                } else {
-                    WindowOperationResult::Failed
-                }
-            }
-            WindowState::VisibleUnfocused | WindowState::Minimized | WindowState::Hidden => {
-                // 窗口存在但不可见或无焦点，激活它
-                if let Some(window) = Self::get_main_window() {
-                    Self::activate_window(&window)
-                } else {
-                    WindowOperationResult::Failed
-                }
-            }
-        }
-    }
-
-    /// 激活窗口（取消最小化、显示、设置焦点）
-    fn activate_window(window: &WebviewWindow<Wry>) -> WindowOperationResult {
-        logging!(info, Type::Window, true, "开始激活窗口");
-
-        let mut operations_successful = true;
-
-        // 1. 如果窗口最小化，先取消最小化
-        if window.is_minimized().unwrap_or(false) {
-            logging!(info, Type::Window, true, "窗口已最小化，正在取消最小化");
-            if let Err(e) = window.unminimize() {
-                logging!(warn, Type::Window, true, "取消最小化失败: {}", e);
-                operations_successful = false;
-            }
-        }
-
-        // 2. 显示窗口
-        if let Err(e) = window.show() {
-            logging!(warn, Type::Window, true, "显示窗口失败: {}", e);
-            operations_successful = false;
-        }
-
-        // 3. 设置焦点
-        if let Err(e) = window.set_focus() {
-            logging!(warn, Type::Window, true, "设置窗口焦点失败: {}", e);
-            operations_successful = false;
-        }
-
-        // 4. 平台特定的激活策略
-        #[cfg(target_os = "macos")]
-        {
-            logging!(info, Type::Window, true, "应用 macOS 特定的激活策略");
-            AppHandleManager::global().set_activation_policy_regular();
-        }
-
-        #[cfg(target_os = "windows")]
-        {
-            // Windows 尝试额外的激活方法
-            if let Err(e) = window.set_always_on_top(true) {
-                logging!(
-                    debug,
-                    Type::Window,
-                    true,
-                    "设置置顶失败（非关键错误）: {}",
-                    e
-                );
-            }
-            // 立即取消置顶
-            if let Err(e) = window.set_always_on_top(false) {
-                logging!(
-                    debug,
-                    Type::Window,
-                    true,
-                    "取消置顶失败（非关键错误）: {}",
-                    e
-                );
-            }
-        }
-
-        if operations_successful {
-            logging!(info, Type::Window, true, "窗口激活成功");
-            WindowOperationResult::Shown
-        } else {
-            logging!(warn, Type::Window, true, "窗口激活部分失败");
-            WindowOperationResult::Failed
-        }
-    }
-
-    /// 隐藏主窗口
-    pub fn hide_main_window() -> WindowOperationResult {
-        logging!(info, Type::Window, true, "开始隐藏主窗口");
-
-        if let Some(window) = Self::get_main_window() {
-            if window.hide().is_ok() {
-                logging!(info, Type::Window, true, "窗口已隐藏");
-                WindowOperationResult::Hidden
-            } else {
-                logging!(warn, Type::Window, true, "隐藏窗口失败");
-                WindowOperationResult::Failed
-            }
-        } else {
-            logging!(info, Type::Window, true, "窗口不存在，无需隐藏");
-            WindowOperationResult::NoAction
-        }
-    }
-
-    /// 检查窗口是否可见
-    pub fn is_main_window_visible() -> bool {
-        Self::get_main_window()
-            .map(|window| window.is_visible().unwrap_or(false))
-            .unwrap_or(false)
-    }
-
-    /// 检查窗口是否有焦点
-    pub fn is_main_window_focused() -> bool {
-        Self::get_main_window()
-            .map(|window| window.is_focused().unwrap_or(false))
-            .unwrap_or(false)
-    }
-
-    /// 检查窗口是否最小化
-    pub fn is_main_window_minimized() -> bool {
-        Self::get_main_window()
-            .map(|window| window.is_minimized().unwrap_or(false))
-            .unwrap_or(false)
-    }
-
-    /// 创建新窗口现有的实现
-    fn create_new_window() -> bool {
-        use crate::utils::resolve;
-        resolve::create_window(true)
-    }
-
-    /// 获取详细的窗口状态信息
-    pub fn get_window_status_info() -> String {
-        let state = Self::get_main_window_state();
-        let is_visible = Self::is_main_window_visible();
-        let is_focused = Self::is_main_window_focused();
-        let is_minimized = Self::is_main_window_minimized();
-
-        format!(
-            "窗口状态: {:?} | 可见: {} | 有焦点: {} | 最小化: {}",
-            state, is_visible, is_focused, is_minimized
-        )
-    }
-}

src-tauri/src_crates/crate_mihomo_api/.env

@@ -1,2 +0,0 @@
-# LOCAL_SOCK="/Users/tunglies/Library/Application Support/io.github.clash-verge-rev.clash-verge-rev.dev/mihomo.sock"
-LOCAL_SOCK="/Users/tunglies/Library/Application Support/io.github.clash-verge-rev.clash-verge-rev/mihomo.sock"

src-tauri/src_crates/crate_mihomo_api/Cargo.toml

@@ -2,10 +2,13 @@
 name = "mihomo_api"
 edition = "2024"
 
+[features]
+debug = []
+
 [dependencies]
-reqwest = { version = "0.12.20", features = ["json"] }
-serde = { version = "1.0.219", features = ["derive"] }
+reqwest = { version = "0.12.12", features = ["json"] }
+serde = { version = "1.0.218", features = ["derive"] }
 serde_json = "1.0.140"
-tokio = { version = "1.45.1", features = ["rt", "macros", "time"] }
 
 [dev-dependencies]
+tokio = { version = "1.43.0", features = ["rt", "macros"] }

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

@@ -1,34 +1,60 @@
 use reqwest::{Method, header::HeaderMap};
-use serde_json::{Value, json};
-use std::time::Duration;
+use serde_json::json;
+use std::{
+    sync::{Arc, Mutex},
+    time::Duration,
+};
 pub mod model;
-pub use model::MihomoManager;
+pub use model::{MihomoData, MihomoManager};
 
 impl MihomoManager {
     pub fn new(mihomo_server: String, headers: HeaderMap) -> Self {
-        let client = reqwest::ClientBuilder::new()
-            .default_headers(headers)
-            .no_proxy()
-            .timeout(Duration::from_secs(15))
-            .pool_max_idle_per_host(5)
-            .pool_idle_timeout(Duration::from_secs(15))
-            .build()
-            .expect("Failed to build reqwest client");
-
         Self {
             mihomo_server,
-            client,
+            data: Arc::new(Mutex::new(MihomoData {
+                proxies: serde_json::Value::Null,
+                providers_proxies: serde_json::Value::Null,
+            })),
+            headers,
         }
     }
 
+    fn update_proxies(&self, proxies: serde_json::Value) {
+        let mut data = self.data.lock().unwrap();
+        data.proxies = proxies;
+    }
+
+    fn update_providers_proxies(&self, providers_proxies: serde_json::Value) {
+        let mut data = self.data.lock().unwrap();
+        data.providers_proxies = providers_proxies;
+    }
+
+    pub fn get_mihomo_server(&self) -> String {
+        self.mihomo_server.clone()
+    }
+
+    pub fn get_proxies(&self) -> serde_json::Value {
+        let data = self.data.lock().unwrap();
+        data.proxies.clone()
+    }
+
+    pub fn get_providers_proxies(&self) -> serde_json::Value {
+        let data = self.data.lock().unwrap();
+        data.providers_proxies.clone()
+    }
+
     async fn send_request(
         &self,
         method: Method,
         url: String,
         data: Option<serde_json::Value>,
     ) -> Result<serde_json::Value, String> {
-        let client_response = self
-            .client
+        let client_response = reqwest::ClientBuilder::new()
+            .default_headers(self.headers.clone())
+            .no_proxy()
+            .timeout(Duration::from_secs(60))
+            .build()
+            .map_err(|e| e.to_string())?
             .request(method.clone(), &url)
             .json(&data.unwrap_or(json!({})))
             .send()
@@ -56,39 +82,22 @@ impl MihomoManager {
         Ok(response)
     }
 
-    pub async fn get_refresh_proxies(&self) -> Result<Value, String> {
+    pub async fn refresh_proxies(&self) -> Result<&Self, String> {
         let url = format!("{}/proxies", self.mihomo_server);
         let proxies = self.send_request(Method::GET, url, None).await?;
-        Ok(proxies)
+        self.update_proxies(proxies);
+        Ok(self)
     }
 
-    pub async fn get_providers_proxies(&self) -> Result<Value, String> {
+    pub async fn refresh_providers_proxies(&self) -> Result<&Self, String> {
         let url = format!("{}/providers/proxies", self.mihomo_server);
         let providers_proxies = self.send_request(Method::GET, url, None).await?;
-        Ok(providers_proxies)
-    }
-
-    pub async fn close_all_connections(&self) -> Result<(), String> {
-        let url = format!("{}/connections", self.mihomo_server);
-        let response = self.send_request(Method::DELETE, url, None).await?;
-        if response["code"] == 204 {
-            Ok(())
-        } else {
-            Err(response["message"]
-                .as_str()
-                .unwrap_or("unknown error")
-                .to_string())
-        }
+        self.update_providers_proxies(providers_proxies);
+        Ok(self)
     }
 }
 
 impl MihomoManager {
-    pub async fn is_mihomo_running(&self) -> Result<(), String> {
-        let url = format!("{}/version", self.mihomo_server);
-        let _response = self.send_request(Method::GET, url, None).await?;
-        Ok(())
-    }
-
     pub async fn put_configs_force(&self, clash_config_path: &str) -> Result<(), String> {
         let url = format!("{}/configs?force=true", self.mihomo_server);
         let payload = serde_json::json!({
@@ -117,7 +126,7 @@ impl MihomoManager {
         test_url: Option<String>,
         timeout: i32,
     ) -> Result<serde_json::Value, String> {
-        let test_url = test_url.unwrap_or("https://cp.cloudflare.com/generate_204".to_string());
+        let test_url = test_url.unwrap_or("http://cp.cloudflare.com/generate_204".to_string());
         let url = format!(
             "{}/proxies/{}/delay?url={}&timeout={}",
             self.mihomo_server, name, test_url, timeout
@@ -125,23 +134,4 @@ impl MihomoManager {
         let response = self.send_request(Method::GET, url, None).await?;
         Ok(response)
     }
-
-    pub async fn get_connections(&self) -> Result<serde_json::Value, String> {
-        let url = format!("{}/connections", self.mihomo_server);
-        let response = self.send_request(Method::GET, url, None).await?;
-        Ok(response)
-    }
-
-    pub async fn delete_connection(&self, id: &str) -> Result<(), String> {
-        let url = format!("{}/connections/{}", self.mihomo_server, id);
-        let response = self.send_request(Method::DELETE, url, None).await?;
-        if response["code"] == 204 {
-            Ok(())
-        } else {
-            Err(response["message"]
-                .as_str()
-                .unwrap_or("unknown error")
-                .to_string())
-        }
-    }
 }